quote
$(Expr(:toplevel, quote
    gboxed_types = Any[]
    mutable struct GdkContentFormats <: GBoxed
        handle::Ptr{GdkContentFormats}
        begin
            (GLib.g_type(::Type{T}) where T <: GdkContentFormats) = begin
                    ccall(("gdk_content_formats_get_type", libgtk4), GType, ())
                end
            function GdkContentFormats(ref::Ptr{T}, own::Bool = false) where T <: GBoxed
                x = new(ref)
                if own
                    finalizer(x) do x
                        GLib.delboxed(x)
                    end
                end
                x
            end
            push!(gboxed_types, GdkContentFormats)
        end
    end
    mutable struct GdkContentFormatsBuilder <: GBoxed
        handle::Ptr{GdkContentFormatsBuilder}
        begin
            (GLib.g_type(::Type{T}) where T <: GdkContentFormatsBuilder) = begin
                    ccall(("gdk_content_formats_builder_get_type", libgtk4), GType, ())
                end
            function GdkContentFormatsBuilder(ref::Ptr{T}, own::Bool = false) where T <: GBoxed
                x = new(ref)
                if own
                    finalizer(x) do x
                        GLib.delboxed(x)
                    end
                end
                x
            end
            push!(gboxed_types, GdkContentFormatsBuilder)
        end
    end
    mutable struct GdkEventSequence <: GBoxed
        handle::Ptr{GdkEventSequence}
        begin
            (GLib.g_type(::Type{T}) where T <: GdkEventSequence) = begin
                    ccall(("gdk_event_sequence_get_type", libgtk4), GType, ())
                end
            function GdkEventSequence(ref::Ptr{T}, own::Bool = false) where T <: GBoxed
                x = new(ref)
                if own
                    finalizer(x) do x
                        GLib.delboxed(x)
                    end
                end
                x
            end
            push!(gboxed_types, GdkEventSequence)
        end
    end
    mutable struct GdkFileList <: GBoxed
        handle::Ptr{GdkFileList}
        begin
            (GLib.g_type(::Type{T}) where T <: GdkFileList) = begin
                    ccall(("gdk_file_list_get_type", libgtk4), GType, ())
                end
            function GdkFileList(ref::Ptr{T}, own::Bool = false) where T <: GBoxed
                x = new(ref)
                if own
                    finalizer(x) do x
                        GLib.delboxed(x)
                    end
                end
                x
            end
            push!(gboxed_types, GdkFileList)
        end
    end
    mutable struct GdkFrameTimings <: GBoxed
        handle::Ptr{GdkFrameTimings}
        begin
            (GLib.g_type(::Type{T}) where T <: GdkFrameTimings) = begin
                    ccall(("gdk_frame_timings_get_type", libgtk4), GType, ())
                end
            function GdkFrameTimings(ref::Ptr{T}, own::Bool = false) where T <: GBoxed
                x = new(ref)
                if own
                    finalizer(x) do x
                        GLib.delboxed(x)
                    end
                end
                x
            end
            push!(gboxed_types, GdkFrameTimings)
        end
    end
    begin
        struct _GdkKeymapKey
            keycode::UInt32
            group::Int32
            level::Int32
        end
        mutable struct GdkKeymapKey
            handle::Ptr{_GdkKeymapKey}
        end
        unsafe_convert(::Type{Ptr{_GdkKeymapKey}}, box::GdkKeymapKey) = begin
                convert(Ptr{_GdkKeymapKey}, box.handle)
            end
    end
    mutable struct GdkPopupLayout <: GBoxed
        handle::Ptr{GdkPopupLayout}
        begin
            (GLib.g_type(::Type{T}) where T <: GdkPopupLayout) = begin
                    ccall(("gdk_popup_layout_get_type", libgtk4), GType, ())
                end
            function GdkPopupLayout(ref::Ptr{T}, own::Bool = false) where T <: GBoxed
                x = new(ref)
                if own
                    finalizer(x) do x
                        GLib.delboxed(x)
                    end
                end
                x
            end
            push!(gboxed_types, GdkPopupLayout)
        end
    end
    begin
        struct _GdkRGBA
            red::Float32
            green::Float32
            blue::Float32
            alpha::Float32
        end
        mutable struct GdkRGBA <: GBoxed
            handle::Ptr{_GdkRGBA}
            begin
                (GLib.g_type(::Type{T}) where T <: GdkRGBA) = begin
                        ccall(("gdk_rgba_get_type", libgtk4), GType, ())
                    end
                function GdkRGBA(ref::Ptr{T}, own::Bool = false) where T <: GBoxed
                    x = new(ref)
                    if own
                        finalizer(x) do x
                            GLib.delboxed(x)
                        end
                    end
                    x
                end
                push!(gboxed_types, GdkRGBA)
            end
        end
        unsafe_convert(::Type{Ptr{_GdkRGBA}}, box::GdkRGBA) = begin
                convert(Ptr{_GdkRGBA}, box.handle)
            end
    end
    begin
        struct _GdkRectangle
            x::Int32
            y::Int32
            width::Int32
            height::Int32
        end
        mutable struct GdkRectangle <: GBoxed
            handle::Ptr{_GdkRectangle}
            begin
                (GLib.g_type(::Type{T}) where T <: GdkRectangle) = begin
                        ccall(("gdk_rectangle_get_type", libgtk4), GType, ())
                    end
                function GdkRectangle(ref::Ptr{T}, own::Bool = false) where T <: GBoxed
                    x = new(ref)
                    if own
                        finalizer(x) do x
                            GLib.delboxed(x)
                        end
                    end
                    x
                end
                push!(gboxed_types, GdkRectangle)
            end
        end
        unsafe_convert(::Type{Ptr{_GdkRectangle}}, box::GdkRectangle) = begin
                convert(Ptr{_GdkRectangle}, box.handle)
            end
    end
    begin
        mutable struct GdkTimeCoord
            handle::Ptr{GdkTimeCoord}
        end
        const _GdkTimeCoord = GdkTimeCoord
    end
    mutable struct GdkToplevelLayout <: GBoxed
        handle::Ptr{GdkToplevelLayout}
        begin
            (GLib.g_type(::Type{T}) where T <: GdkToplevelLayout) = begin
                    ccall(("gdk_toplevel_layout_get_type", libgtk4), GType, ())
                end
            function GdkToplevelLayout(ref::Ptr{T}, own::Bool = false) where T <: GBoxed
                x = new(ref)
                if own
                    finalizer(x) do x
                        GLib.delboxed(x)
                    end
                end
                x
            end
            push!(gboxed_types, GdkToplevelLayout)
        end
    end
    gboxed_cache_init() = begin
            append!(GLib.gboxed_types, gboxed_types)
        end
    function GdkContentFormats(_mime_types)
        G_.ContentFormats_new(_mime_types)
    end
    function GdkContentFormats(_type::Integer)
        G_.ContentFormats_new_for_gtype(_type)
    end
    function GdkContentFormatsBuilder()
        G_.ContentFormatsBuilder_new()
    end
    function GdkFileList(_files)
        G_.FileList_new_from_array(_files)
    end
    function GdkFileList(_files::GLib.LList{GLib._GSList{Ptr{GObject}}})
        G_.FileList_new_from_list(_files)
    end
    function GdkPopupLayout(_anchor_rect::Union{GdkRectangle, Ref{_GdkRectangle}}, _rect_anchor, _surface_anchor)
        G_.PopupLayout_new(_anchor_rect, _rect_anchor, _surface_anchor)
    end
    function GdkToplevelLayout()
        G_.ToplevelLayout_new()
    end
    @doc "The `GdkContentFormats` structure is used to advertise and negotiate the\nformat of content.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gdk4/struct.ContentFormats.html)." GdkContentFormats
    @doc "A `GdkContentFormatsBuilder` is an auxiliary struct used to create\nnew `GdkContentFormats`, and should not be kept around.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gdk4/struct.ContentFormatsBuilder.html)." GdkContentFormatsBuilder
    @doc "`GdkEventSequence` is an opaque type representing a sequence\nof related touch events.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gdk4/struct.EventSequence.html)." GdkEventSequence
    @doc "An opaque type representing a list of files.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gdk4/struct.FileList.html)." GdkFileList
    @doc "A `GdkFrameTimings` object holds timing information for a single frame\nof the application’s displays.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gdk4/struct.FrameTimings.html)." GdkFrameTimings
    @doc "A `GdkKeymapKey` is a hardware key that can be mapped to a keyval.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gdk4/struct.KeymapKey.html)." GdkKeymapKey
    @doc "The `GdkPopupLayout` struct contains information that is\nnecessary position a [iface@Gdk.Popup] relative to its parent.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gdk4/struct.PopupLayout.html)." GdkPopupLayout
    @doc "A `GdkRGBA` is used to represent a color, in a way that is compatible\nwith cairo’s notion of color.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gdk4/struct.RGBA.html)." GdkRGBA
    @doc "A `GdkRectangle` data type for representing rectangles.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gdk4/struct.Rectangle.html)." GdkRectangle
    @doc "A `GdkTimeCoord` stores a single event in a motion history.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gdk4/struct.TimeCoord.html)." GdkTimeCoord
    @doc "The `GdkToplevelLayout` struct contains information that\nis necessary to present a sovereign window on screen.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gdk4/struct.ToplevelLayout.html)." GdkToplevelLayout
    gtype_wrapper_cache = Dict{Symbol, Type}()
    begin
        abstract type GdkAppLaunchContext <: GAppLaunchContext end
        mutable struct GdkAppLaunchContextLeaf <: GdkAppLaunchContext
            handle::Ptr{GObject}
            function GdkAppLaunchContextLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GdkAppLaunchContextLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        gtype_wrapper_cache[:GdkAppLaunchContext] = GdkAppLaunchContextLeaf
    end
    begin
        abstract type GdkEvent end
        Base.convert(::Type{GdkEvent}, ptr::Ptr{GdkEvent}) = begin
                GdkEventLeaf(ptr)
            end
        Base.unsafe_convert(::Type{Ptr{GdkEvent}}, o::GdkEvent) = begin
                o.handle
            end
    end
    begin
        mutable struct GdkEventLeaf <: GdkEvent
            handle::Ptr{GdkEvent}
        end
    end
    begin
        abstract type GdkButtonEvent <: GdkEvent end
    end
    begin
        mutable struct GdkButtonEventLeaf <: GdkButtonEvent
            handle::Ptr{GdkEvent}
        end
    end
    begin
        abstract type GdkDrawContext <: GObject end
        mutable struct GdkDrawContextLeaf <: GdkDrawContext
            handle::Ptr{GObject}
            function GdkDrawContextLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GdkDrawContextLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        gtype_wrapper_cache[:GdkDrawContext] = GdkDrawContextLeaf
    end
    begin
        abstract type GdkCairoContext <: GdkDrawContext end
        mutable struct GdkCairoContextLeaf <: GdkCairoContext
            handle::Ptr{GObject}
            function GdkCairoContextLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GdkCairoContextLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        gtype_wrapper_cache[:GdkCairoContext] = GdkCairoContextLeaf
    end
    begin
        abstract type GdkClipboard <: GObject end
        mutable struct GdkClipboardLeaf <: GdkClipboard
            handle::Ptr{GObject}
            function GdkClipboardLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GdkClipboardLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        gtype_wrapper_cache[:GdkClipboard] = GdkClipboardLeaf
    end
    begin
        abstract type GdkContentDeserializer <: GObject end
        mutable struct GdkContentDeserializerLeaf <: GdkContentDeserializer
            handle::Ptr{GObject}
            function GdkContentDeserializerLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GdkContentDeserializerLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        gtype_wrapper_cache[:GdkContentDeserializer] = GdkContentDeserializerLeaf
    end
    begin
        abstract type GdkContentProvider <: GObject end
        mutable struct GdkContentProviderLeaf <: GdkContentProvider
            handle::Ptr{GObject}
            function GdkContentProviderLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GdkContentProviderLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        gtype_wrapper_cache[:GdkContentProvider] = GdkContentProviderLeaf
    end
    begin
        abstract type GdkContentSerializer <: GObject end
        mutable struct GdkContentSerializerLeaf <: GdkContentSerializer
            handle::Ptr{GObject}
            function GdkContentSerializerLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GdkContentSerializerLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        gtype_wrapper_cache[:GdkContentSerializer] = GdkContentSerializerLeaf
    end
    begin
        abstract type GdkCrossingEvent <: GdkEvent end
    end
    begin
        mutable struct GdkCrossingEventLeaf <: GdkCrossingEvent
            handle::Ptr{GdkEvent}
        end
    end
    begin
        abstract type GdkCursor <: GObject end
        mutable struct GdkCursorLeaf <: GdkCursor
            handle::Ptr{GObject}
            function GdkCursorLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GdkCursorLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        gtype_wrapper_cache[:GdkCursor] = GdkCursorLeaf
    end
    begin
        abstract type GdkDNDEvent <: GdkEvent end
    end
    begin
        mutable struct GdkDNDEventLeaf <: GdkDNDEvent
            handle::Ptr{GdkEvent}
        end
    end
    begin
        abstract type GdkDeleteEvent <: GdkEvent end
    end
    begin
        mutable struct GdkDeleteEventLeaf <: GdkDeleteEvent
            handle::Ptr{GdkEvent}
        end
    end
    begin
        abstract type GdkDevice <: GObject end
        mutable struct GdkDeviceLeaf <: GdkDevice
            handle::Ptr{GObject}
            function GdkDeviceLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GdkDeviceLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        gtype_wrapper_cache[:GdkDevice] = GdkDeviceLeaf
    end
    begin
        abstract type GdkDeviceTool <: GObject end
        mutable struct GdkDeviceToolLeaf <: GdkDeviceTool
            handle::Ptr{GObject}
            function GdkDeviceToolLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GdkDeviceToolLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        gtype_wrapper_cache[:GdkDeviceTool] = GdkDeviceToolLeaf
    end
    begin
        abstract type GdkDisplay <: GObject end
        mutable struct GdkDisplayLeaf <: GdkDisplay
            handle::Ptr{GObject}
            function GdkDisplayLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GdkDisplayLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        gtype_wrapper_cache[:GdkDisplay] = GdkDisplayLeaf
    end
    begin
        abstract type GdkDisplayManager <: GObject end
        mutable struct GdkDisplayManagerLeaf <: GdkDisplayManager
            handle::Ptr{GObject}
            function GdkDisplayManagerLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GdkDisplayManagerLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        gtype_wrapper_cache[:GdkDisplayManager] = GdkDisplayManagerLeaf
    end
    begin
        abstract type GdkDrag <: GObject end
        mutable struct GdkDragLeaf <: GdkDrag
            handle::Ptr{GObject}
            function GdkDragLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GdkDragLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        gtype_wrapper_cache[:GdkDrag] = GdkDragLeaf
    end
    begin
        abstract type GdkDrop <: GObject end
        mutable struct GdkDropLeaf <: GdkDrop
            handle::Ptr{GObject}
            function GdkDropLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GdkDropLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        gtype_wrapper_cache[:GdkDrop] = GdkDropLeaf
    end
    begin
        abstract type GdkFocusEvent <: GdkEvent end
    end
    begin
        mutable struct GdkFocusEventLeaf <: GdkFocusEvent
            handle::Ptr{GdkEvent}
        end
    end
    begin
        abstract type GdkFrameClock <: GObject end
        mutable struct GdkFrameClockLeaf <: GdkFrameClock
            handle::Ptr{GObject}
            function GdkFrameClockLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GdkFrameClockLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        gtype_wrapper_cache[:GdkFrameClock] = GdkFrameClockLeaf
    end
    begin
        abstract type GdkGLContext <: GdkDrawContext end
        mutable struct GdkGLContextLeaf <: GdkGLContext
            handle::Ptr{GObject}
            function GdkGLContextLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GdkGLContextLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        gtype_wrapper_cache[:GdkGLContext] = GdkGLContextLeaf
    end
    begin
        abstract type GdkTexture <: GObject end
        mutable struct GdkTextureLeaf <: GdkTexture
            handle::Ptr{GObject}
            function GdkTextureLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GdkTextureLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        gtype_wrapper_cache[:GdkTexture] = GdkTextureLeaf
    end
    begin
        abstract type GdkGLTexture <: GdkTexture end
        mutable struct GdkGLTextureLeaf <: GdkGLTexture
            handle::Ptr{GObject}
            function GdkGLTextureLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GdkGLTextureLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        gtype_wrapper_cache[:GdkGLTexture] = GdkGLTextureLeaf
    end
    begin
        abstract type GdkGrabBrokenEvent <: GdkEvent end
    end
    begin
        mutable struct GdkGrabBrokenEventLeaf <: GdkGrabBrokenEvent
            handle::Ptr{GdkEvent}
        end
    end
    begin
        abstract type GdkKeyEvent <: GdkEvent end
    end
    begin
        mutable struct GdkKeyEventLeaf <: GdkKeyEvent
            handle::Ptr{GdkEvent}
        end
    end
    begin
        abstract type GdkMemoryTexture <: GdkTexture end
        mutable struct GdkMemoryTextureLeaf <: GdkMemoryTexture
            handle::Ptr{GObject}
            function GdkMemoryTextureLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GdkMemoryTextureLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        gtype_wrapper_cache[:GdkMemoryTexture] = GdkMemoryTextureLeaf
    end
    begin
        abstract type GdkMonitor <: GObject end
        mutable struct GdkMonitorLeaf <: GdkMonitor
            handle::Ptr{GObject}
            function GdkMonitorLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GdkMonitorLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        gtype_wrapper_cache[:GdkMonitor] = GdkMonitorLeaf
    end
    begin
        abstract type GdkMotionEvent <: GdkEvent end
    end
    begin
        mutable struct GdkMotionEventLeaf <: GdkMotionEvent
            handle::Ptr{GdkEvent}
        end
    end
    begin
        abstract type GdkPadEvent <: GdkEvent end
    end
    begin
        mutable struct GdkPadEventLeaf <: GdkPadEvent
            handle::Ptr{GdkEvent}
        end
    end
    begin
        abstract type GdkProximityEvent <: GdkEvent end
    end
    begin
        mutable struct GdkProximityEventLeaf <: GdkProximityEvent
            handle::Ptr{GdkEvent}
        end
    end
    begin
        abstract type GdkScrollEvent <: GdkEvent end
    end
    begin
        mutable struct GdkScrollEventLeaf <: GdkScrollEvent
            handle::Ptr{GdkEvent}
        end
    end
    begin
        abstract type GdkSeat <: GObject end
        mutable struct GdkSeatLeaf <: GdkSeat
            handle::Ptr{GObject}
            function GdkSeatLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GdkSeatLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        gtype_wrapper_cache[:GdkSeat] = GdkSeatLeaf
    end
    begin
        abstract type GdkSnapshot <: GObject end
        mutable struct GdkSnapshotLeaf <: GdkSnapshot
            handle::Ptr{GObject}
            function GdkSnapshotLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GdkSnapshotLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        gtype_wrapper_cache[:GdkSnapshot] = GdkSnapshotLeaf
    end
    begin
        abstract type GdkSurface <: GObject end
        mutable struct GdkSurfaceLeaf <: GdkSurface
            handle::Ptr{GObject}
            function GdkSurfaceLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GdkSurfaceLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        gtype_wrapper_cache[:GdkSurface] = GdkSurfaceLeaf
    end
    begin
        abstract type GdkTouchEvent <: GdkEvent end
    end
    begin
        mutable struct GdkTouchEventLeaf <: GdkTouchEvent
            handle::Ptr{GdkEvent}
        end
    end
    begin
        abstract type GdkTouchpadEvent <: GdkEvent end
    end
    begin
        mutable struct GdkTouchpadEventLeaf <: GdkTouchpadEvent
            handle::Ptr{GdkEvent}
        end
    end
    begin
        abstract type GdkVulkanContext <: GdkDrawContext end
        mutable struct GdkVulkanContextLeaf <: GdkVulkanContext
            handle::Ptr{GObject}
            function GdkVulkanContextLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GdkVulkanContextLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        gtype_wrapper_cache[:GdkVulkanContext] = GdkVulkanContextLeaf
    end
    begin
        gtype_wrapper_cache_init() = begin
                merge!(GLib.gtype_wrappers, gtype_wrapper_cache)
            end
    end
    function GdkContentProvider(_mime_type::Union{AbstractString, Symbol}, _bytes::GBytes; kwargs...)
        obj = G_.ContentProvider_new_for_bytes(_mime_type, _bytes)
        GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GdkContentProvider(_value::Union{GValue, Ref{_GValue}}; kwargs...)
        obj = G_.ContentProvider_new_for_value(_value)
        GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GdkContentProvider(_providers; kwargs...)
        obj = G_.ContentProvider_new_union(_providers)
        GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GdkCursor(_name::Union{AbstractString, Symbol}, _fallback::Maybe(GdkCursor); kwargs...)
        obj = G_.Cursor_new_from_name(_name, _fallback)
        GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GdkCursor(_texture::GdkTexture, _hotspot_x::Integer, _hotspot_y::Integer, _fallback::Maybe(GdkCursor); kwargs...)
        obj = G_.Cursor_new_from_texture(_texture, _hotspot_x, _hotspot_y, _fallback)
        GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GdkGLTexture(_context::GdkGLContext, _id::Integer, _width::Integer, _height::Integer, _destroy::Function, _data::Maybe(Nothing))
        G_.GLTexture_new(_context, _id, _width, _height, _destroy, _data)
    end
    function GdkMemoryTexture(_width::Integer, _height::Integer, _format, _bytes::GBytes, _stride::Integer)
        G_.MemoryTexture_new(_width, _height, _format, _bytes, _stride)
    end
    function GdkSurface(_parent::GdkSurface, _autohide::Bool; kwargs...)
        obj = G_.Surface_new_popup(_parent, _autohide)
        GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GdkSurface(_display::GdkDisplay; kwargs...)
        obj = G_.Surface_new_toplevel(_display)
        GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GdkTexture(_pixbuf::GdkPixbuf; kwargs...)
        obj = G_.Texture_new_for_pixbuf(_pixbuf)
        GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GdkTexture(_bytes::GBytes; kwargs...)
        obj = G_.Texture_new_from_bytes(_bytes)
        GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GdkTexture(_file::GFile; kwargs...)
        obj = G_.Texture_new_from_file(_file)
        GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GdkTexture(_path::Union{AbstractString, Symbol}; kwargs...)
        obj = G_.Texture_new_from_filename(_path)
        GLib.setproperties!(obj; kwargs...)
        obj
    end
    @doc "`GdkAppLaunchContext` handles launching an application in a graphical context.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gdk4/class.AppLaunchContext.html)." GdkAppLaunchContext
    @doc "An event related to a button on a pointer device.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gdk4/class.ButtonEvent.html)." GdkButtonEvent
    @doc "`GdkCairoContext` is an object representing the platform-specific\ndraw context.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gdk4/class.CairoContext.html)." GdkCairoContext
    @doc "The `GdkClipboard` object represents data shared between applications or\ninside an application.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gdk4/class.Clipboard.html)." GdkClipboard
    @doc "A `GdkContentDeserializer` is used to deserialize content received via\ninter-application data transfers.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gdk4/class.ContentDeserializer.html)." GdkContentDeserializer
    @doc "A `GdkContentProvider` is used to provide content for the clipboard or\nfor drag-and-drop operations in a number of formats.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gdk4/class.ContentProvider.html)." GdkContentProvider
    @doc "A `GdkContentSerializer` is used to serialize content for\ninter-application data transfers.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gdk4/class.ContentSerializer.html)." GdkContentSerializer
    @doc "An event caused by a pointing device moving between surfaces.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gdk4/class.CrossingEvent.html)." GdkCrossingEvent
    @doc "`GdkCursor` is used to create and destroy cursors.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gdk4/class.Cursor.html)." GdkCursor
    @doc "An event related to drag and drop operations.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gdk4/class.DNDEvent.html)." GdkDNDEvent
    @doc "An event related to closing a top-level surface.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gdk4/class.DeleteEvent.html)." GdkDeleteEvent
    @doc "The `GdkDevice` object represents an input device, such\nas a keyboard, a mouse, or a touchpad.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gdk4/class.Device.html)." GdkDevice
    @doc "A physical tool associated to a `GdkDevice`.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gdk4/class.DeviceTool.html)." GdkDeviceTool
    @doc "`GdkDisplay` objects are the GDK representation of a workstation.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gdk4/class.Display.html)." GdkDisplay
    @doc "A singleton object that offers notification when displays appear or\ndisappear.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gdk4/class.DisplayManager.html)." GdkDisplayManager
    @doc "The `GdkDrag` object represents the source of an ongoing DND operation.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gdk4/class.Drag.html)." GdkDrag
    @doc "Base class for objects implementing different rendering methods.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gdk4/class.DrawContext.html)." GdkDrawContext
    @doc "The `GdkDrop` object represents the target of an ongoing DND operation.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gdk4/class.Drop.html)." GdkDrop
    @doc "`GdkEvent`s are immutable data structures, created by GDK to\nrepresent windowing system events.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gdk4/class.Event.html)." GdkEvent
    @doc "An event related to a keyboard focus change.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gdk4/class.FocusEvent.html)." GdkFocusEvent
    @doc "A `GdkFrameClock` tells the application when to update and repaint\na surface.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gdk4/class.FrameClock.html)." GdkFrameClock
    @doc "`GdkGLContext` is an object representing a platform-specific\nOpenGL draw context.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gdk4/class.GLContext.html)." GdkGLContext
    @doc "A GdkTexture representing a GL texture object.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gdk4/class.GLTexture.html)." GdkGLTexture
    @doc "An event related to a broken windowing system grab.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gdk4/class.GrabBrokenEvent.html)." GdkGrabBrokenEvent
    @doc "An event related to a key-based device.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gdk4/class.KeyEvent.html)." GdkKeyEvent
    @doc "A `GdkTexture` representing image data in memory.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gdk4/class.MemoryTexture.html)." GdkMemoryTexture
    @doc "`GdkMonitor` objects represent the individual outputs that are\nassociated with a `GdkDisplay`.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gdk4/class.Monitor.html)." GdkMonitor
    @doc "An event related to a pointer or touch device motion.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gdk4/class.MotionEvent.html)." GdkMotionEvent
    @doc "An event related to a pad-based device.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gdk4/class.PadEvent.html)." GdkPadEvent
    @doc "An event related to the proximity of a tool to a device.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gdk4/class.ProximityEvent.html)." GdkProximityEvent
    @doc "An event related to a scrolling motion.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gdk4/class.ScrollEvent.html)." GdkScrollEvent
    @doc "The `GdkSeat` object represents a collection of input devices\nthat belong to a user.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gdk4/class.Seat.html)." GdkSeat
    @doc "Base type for snapshot operations.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gdk4/class.Snapshot.html)." GdkSnapshot
    @doc "A `GdkSurface` is a rectangular region on the screen.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gdk4/class.Surface.html)." GdkSurface
    @doc "`GdkTexture` is the basic element used to refer to pixel data.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gdk4/class.Texture.html)." GdkTexture
    @doc "An event related to a touch-based device.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gdk4/class.TouchEvent.html)." GdkTouchEvent
    @doc "An event related to a gesture on a touchpad device.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gdk4/class.TouchpadEvent.html)." GdkTouchpadEvent
    @doc "`GdkVulkanContext` is an object representing the platform-specific\nVulkan draw context.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gdk4/class.VulkanContext.html)." GdkVulkanContext
    struct GdkDevicePad <: GInterface
        handle::Ptr{GObject}
        gc::Any
        GdkDevicePad(x::GObject) = begin
                new(unsafe_convert(Ptr{GObject}, x), x)
            end
    end
    struct GdkDragSurface <: GInterface
        handle::Ptr{GObject}
        gc::Any
        GdkDragSurface(x::GObject) = begin
                new(unsafe_convert(Ptr{GObject}, x), x)
            end
    end
    struct GdkPaintable <: GInterface
        handle::Ptr{GObject}
        gc::Any
        GdkPaintable(x::GObject) = begin
                new(unsafe_convert(Ptr{GObject}, x), x)
            end
    end
    struct GdkPopup <: GInterface
        handle::Ptr{GObject}
        gc::Any
        GdkPopup(x::GObject) = begin
                new(unsafe_convert(Ptr{GObject}, x), x)
            end
    end
    struct GdkToplevel <: GInterface
        handle::Ptr{GObject}
        gc::Any
        GdkToplevel(x::GObject) = begin
                new(unsafe_convert(Ptr{GObject}, x), x)
            end
    end
    export GdkContentFormats, GdkContentFormatsBuilder, GdkEventSequence, GdkFileList, GdkFrameTimings, GdkKeymapKey, _GdkKeymapKey, GdkPopupLayout, GdkRGBA, _GdkRGBA, GdkRectangle, _GdkRectangle, GdkTimeCoord, _GdkTimeCoord, GdkToplevelLayout, GdkAppLaunchContext, GdkAppLaunchContextLeaf, GdkButtonEvent, GdkButtonEventLeaf, GdkCairoContext, GdkClipboard, GdkClipboardLeaf, GdkContentDeserializer, GdkContentDeserializerLeaf, GdkContentProvider, GdkContentProviderLeaf, GdkContentSerializer, GdkContentSerializerLeaf, GdkCrossingEvent, GdkCrossingEventLeaf, GdkCursor, GdkCursorLeaf, GdkDNDEvent, GdkDNDEventLeaf, GdkDeleteEvent, GdkDeleteEventLeaf, GdkDevice, GdkDeviceTool, GdkDeviceToolLeaf, GdkDisplay, GdkDisplayLeaf, GdkDisplayManager, GdkDisplayManagerLeaf, GdkDrag, GdkDrawContext, GdkDrop, GdkEvent, GdkFocusEvent, GdkFocusEventLeaf, GdkFrameClock, GdkGLContext, GdkGLTexture, GdkGLTextureLeaf, GdkGrabBrokenEvent, GdkGrabBrokenEventLeaf, GdkKeyEvent, GdkKeyEventLeaf, GdkMemoryTexture, GdkMemoryTextureLeaf, GdkMonitor, GdkMonitorLeaf, GdkMotionEvent, GdkMotionEventLeaf, GdkPadEvent, GdkPadEventLeaf, GdkProximityEvent, GdkProximityEventLeaf, GdkScrollEvent, GdkScrollEventLeaf, GdkSeat, GdkSnapshot, GdkSurface, GdkTexture, GdkTouchEvent, GdkTouchEventLeaf, GdkTouchpadEvent, GdkTouchpadEventLeaf, GdkVulkanContext, GdkDevicePad, GdkDragSurface, GdkPaintable, GdkPopup, GdkToplevel
end))
end
