quote
$(Expr(:toplevel, quote
    begin
        gboxed_types = Any[]
    end
    mutable struct GtkBitset <: GBoxed
        handle::Ptr{GtkBitset}
        begin
            (GLib.g_type(::Type{T}) where T <: GtkBitset) = begin
                    ccall(("gtk_bitset_get_type", libgtk4), GType, ())
                end
            function GtkBitset(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, GtkBitset)
        end
    end
    begin
        mutable struct GtkBitsetIter <: GBoxed
            handle::Ptr{GtkBitsetIter}
            begin
                (GLib.g_type(::Type{T}) where T <: GtkBitsetIter) = begin
                        ccall(("gtk_bitset_iter_get_type", libgtk4), GType, ())
                    end
                function GtkBitsetIter(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, GtkBitsetIter)
            end
        end
        const _GtkBitsetIter = GtkBitsetIter
    end
    begin
        struct _GtkBorder
            left::Int16
            right::Int16
            top::Int16
            bottom::Int16
        end
        mutable struct GtkBorder <: GBoxed
            handle::Ptr{_GtkBorder}
            begin
                (GLib.g_type(::Type{T}) where T <: GtkBorder) = begin
                        ccall(("gtk_border_get_type", libgtk4), GType, ())
                    end
                function GtkBorder(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, GtkBorder)
            end
        end
        unsafe_convert(::Type{Ptr{_GtkBorder}}, box::GtkBorder) = begin
                convert(Ptr{_GtkBorder}, box.handle)
            end
    end
    mutable struct GtkBuildableParseContext
        handle::Ptr{GtkBuildableParseContext}
    end
    begin
        mutable struct GtkBuildableParser
            handle::Ptr{GtkBuildableParser}
        end
        const _GtkBuildableParser = GtkBuildableParser
    end
    begin
        struct _GtkCssLocation
            bytes::UInt64
            chars::UInt64
            lines::UInt64
            line_bytes::UInt64
            line_chars::UInt64
        end
        mutable struct GtkCssLocation
            handle::Ptr{_GtkCssLocation}
        end
        unsafe_convert(::Type{Ptr{_GtkCssLocation}}, box::GtkCssLocation) = begin
                convert(Ptr{_GtkCssLocation}, box.handle)
            end
    end
    mutable struct GtkCssSection <: GBoxed
        handle::Ptr{GtkCssSection}
        begin
            (GLib.g_type(::Type{T}) where T <: GtkCssSection) = begin
                    ccall(("gtk_css_section_get_type", libgtk4), GType, ())
                end
            function GtkCssSection(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, GtkCssSection)
        end
    end
    mutable struct GtkCssStyleChange
        handle::Ptr{GtkCssStyleChange}
    end
    mutable struct GtkExpressionWatch <: GBoxed
        handle::Ptr{GtkExpressionWatch}
        begin
            (GLib.g_type(::Type{T}) where T <: GtkExpressionWatch) = begin
                    ccall(("gtk_expression_watch_get_type", libgtk4), GType, ())
                end
            function GtkExpressionWatch(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, GtkExpressionWatch)
        end
    end
    begin
        struct _GtkPadActionEntry
            type::UInt32
            index::Int32
            mode::Int32
            label::Cstring
            action_name::Cstring
        end
        mutable struct GtkPadActionEntry
            handle::Ptr{_GtkPadActionEntry}
        end
        unsafe_convert(::Type{Ptr{_GtkPadActionEntry}}, box::GtkPadActionEntry) = begin
                convert(Ptr{_GtkPadActionEntry}, box.handle)
            end
    end
    mutable struct GtkPaperSize <: GBoxed
        handle::Ptr{GtkPaperSize}
        begin
            (GLib.g_type(::Type{T}) where T <: GtkPaperSize) = begin
                    ccall(("gtk_paper_size_get_type", libgtk4), GType, ())
                end
            function GtkPaperSize(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, GtkPaperSize)
        end
    end
    mutable struct GtkPrintBackend
        handle::Ptr{GtkPrintBackend}
    end
    begin
        struct _GtkRecentData
            display_name::Cstring
            description::Cstring
            mime_type::Cstring
            app_name::Cstring
            app_exec::Cstring
            groups::Ptr{Cstring}
            is_private::Cint
        end
        mutable struct GtkRecentData
            handle::Ptr{_GtkRecentData}
        end
        unsafe_convert(::Type{Ptr{_GtkRecentData}}, box::GtkRecentData) = begin
                convert(Ptr{_GtkRecentData}, box.handle)
            end
    end
    mutable struct GtkRecentInfo <: GBoxed
        handle::Ptr{GtkRecentInfo}
        begin
            (GLib.g_type(::Type{T}) where T <: GtkRecentInfo) = begin
                    ccall(("gtk_recent_info_get_type", libgtk4), GType, ())
                end
            function GtkRecentInfo(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, GtkRecentInfo)
        end
    end
    begin
        struct _GtkRequestedSize
            data::Ptr{Nothing}
            minimum_size::Int32
            natural_size::Int32
        end
        mutable struct GtkRequestedSize
            handle::Ptr{_GtkRequestedSize}
        end
        unsafe_convert(::Type{Ptr{_GtkRequestedSize}}, box::GtkRequestedSize) = begin
                convert(Ptr{_GtkRequestedSize}, box.handle)
            end
    end
    begin
        struct _GtkRequisition
            width::Int32
            height::Int32
        end
        mutable struct GtkRequisition <: GBoxed
            handle::Ptr{_GtkRequisition}
            begin
                (GLib.g_type(::Type{T}) where T <: GtkRequisition) = begin
                        ccall(("gtk_requisition_get_type", libgtk4), GType, ())
                    end
                function GtkRequisition(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, GtkRequisition)
            end
        end
        unsafe_convert(::Type{Ptr{_GtkRequisition}}, box::GtkRequisition) = begin
                convert(Ptr{_GtkRequisition}, box.handle)
            end
    end
    begin
        struct _GtkTextIter
            dummy1::Ptr{Nothing}
            dummy2::Ptr{Nothing}
            dummy3::Int32
            dummy4::Int32
            dummy5::Int32
            dummy6::Int32
            dummy7::Int32
            dummy8::Int32
            dummy9::Ptr{Nothing}
            dummy10::Ptr{Nothing}
            dummy11::Int32
            dummy12::Int32
            dummy13::Int32
            dummy14::Ptr{Nothing}
        end
        mutable struct GtkTextIter <: GBoxed
            handle::Ptr{_GtkTextIter}
            begin
                (GLib.g_type(::Type{T}) where T <: GtkTextIter) = begin
                        ccall(("gtk_text_iter_get_type", libgtk4), GType, ())
                    end
                function GtkTextIter(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, GtkTextIter)
            end
        end
        unsafe_convert(::Type{Ptr{_GtkTextIter}}, box::GtkTextIter) = begin
                convert(Ptr{_GtkTextIter}, box.handle)
            end
    end
    begin
        struct _GtkTreeIter
            stamp::Int32
            user_data::Ptr{Nothing}
            user_data2::Ptr{Nothing}
            user_data3::Ptr{Nothing}
        end
        mutable struct GtkTreeIter <: GBoxed
            handle::Ptr{_GtkTreeIter}
            begin
                (GLib.g_type(::Type{T}) where T <: GtkTreeIter) = begin
                        ccall(("gtk_tree_iter_get_type", libgtk4), GType, ())
                    end
                function GtkTreeIter(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, GtkTreeIter)
            end
        end
        unsafe_convert(::Type{Ptr{_GtkTreeIter}}, box::GtkTreeIter) = begin
                convert(Ptr{_GtkTreeIter}, box.handle)
            end
    end
    mutable struct GtkTreePath <: GBoxed
        handle::Ptr{GtkTreePath}
        begin
            (GLib.g_type(::Type{T}) where T <: GtkTreePath) = begin
                    ccall(("gtk_tree_path_get_type", libgtk4), GType, ())
                end
            function GtkTreePath(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, GtkTreePath)
        end
    end
    mutable struct GtkTreeRowReference <: GBoxed
        handle::Ptr{GtkTreeRowReference}
        begin
            (GLib.g_type(::Type{T}) where T <: GtkTreeRowReference) = begin
                    ccall(("gtk_tree_row_reference_get_type", libgtk4), GType, ())
                end
            function GtkTreeRowReference(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, GtkTreeRowReference)
        end
    end
    @doc "A `GtkBitset` represents a set of unsigned integers.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/struct.Bitset.html)." GtkBitset
    @doc "An opaque, stack-allocated struct for iterating\nover the elements of a `GtkBitset`.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/struct.BitsetIter.html)." GtkBitsetIter
    @doc "A struct that specifies a border around a rectangular area.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/struct.Border.html)." GtkBorder
    @doc "An opaque context struct for `GtkBuildableParser`.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/struct.BuildableParseContext.html)." GtkBuildableParseContext
    @doc "A sub-parser for `GtkBuildable` implementations.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/struct.BuildableParser.html)." GtkBuildableParser
    @doc "Represents a location in a file or other source of data parsed\nby the CSS engine.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/struct.CssLocation.html)." GtkCssLocation
    @doc "Defines a part of a CSS document.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/struct.CssSection.html)." GtkCssSection
    @doc "An opaque structure representing a watched `GtkExpression`.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/struct.ExpressionWatch.html)." GtkExpressionWatch
    @doc "Struct defining a pad action entry.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/struct.PadActionEntry.html)." GtkPadActionEntry
    @doc "`GtkPaperSize` handles paper sizes.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/struct.PaperSize.html)." GtkPaperSize
    @doc "Meta-data to be passed to gtk_recent_manager_add_full() when\nregistering a recently used resource.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/struct.RecentData.html)." GtkRecentData
    @doc "`GtkRecentInfo` contains the metadata associated with an item in the\nrecently used files list.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/struct.RecentInfo.html)." GtkRecentInfo
    @doc "Represents a request of a screen object in a given orientation. These\nare primarily used in container implementations when allocating a natural\nsize for children calling. See [func@distribute_natural_allocation].\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/struct.RequestedSize.html)." GtkRequestedSize
    @doc "A `GtkRequisition` represents the desired size of a widget. See\n[GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for\nmore information.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/struct.Requisition.html)." GtkRequisition
    @doc "An iterator for the contents of a `GtkTextBuffer`.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/struct.TextIter.html)." GtkTextIter
    @doc "The `GtkTreeIter` is the primary structure\nfor accessing a `GtkTreeModel`. Models are expected to put a unique\ninteger in the @stamp member, and put\nmodel-specific data in the three @user_data\nmembers.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/struct.TreeIter.html)." GtkTreeIter
    @doc "An opaque structure representing a path to a row in a model.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/struct.TreePath.html)." GtkTreePath
    @doc "A GtkTreeRowReference tracks model changes so that it always refers to the\nsame row (a `GtkTreePath` refers to a position, not a fixed row). Create a\nnew GtkTreeRowReference with gtk_tree_row_reference_new().\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/struct.TreeRowReference.html)." GtkTreeRowReference
    begin
        abstract type GtkATContext <: GObject end
        mutable struct GtkATContextLeaf <: GtkATContext
            handle::Ptr{GObject}
            function GtkATContextLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkATContextLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkATContextLeaf(args...; kwargs...)
            w = GtkATContext(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkATContext] = GtkATContextLeaf
        function GtkATContext(args...; kwargs...)
            GtkATContextLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkWidget <: GInitiallyUnowned end
        mutable struct GtkWidgetLeaf <: GtkWidget
            handle::Ptr{GObject}
            function GtkWidgetLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkWidgetLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkWidgetLeaf(args...; kwargs...)
            w = GtkWidget(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkWidget] = GtkWidgetLeaf
        function GtkWidget(args...; kwargs...)
            GtkWidgetLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkWindow <: GtkWidget end
        mutable struct GtkWindowLeaf <: GtkWindow
            handle::Ptr{GObject}
            function GtkWindowLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkWindowLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkWindowLeaf(args...; kwargs...)
            w = GtkWindow(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkWindow] = GtkWindowLeaf
        function GtkWindow(args...; kwargs...)
            GtkWindowLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkAboutDialog <: GtkWindow end
        mutable struct GtkAboutDialogLeaf <: GtkAboutDialog
            handle::Ptr{GObject}
            function GtkAboutDialogLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkAboutDialogLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkAboutDialogLeaf(args...; kwargs...)
            w = GtkAboutDialog(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkAboutDialog] = GtkAboutDialogLeaf
        function GtkAboutDialog(args...; kwargs...)
            GtkAboutDialogLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkActionBar <: GtkWidget end
        mutable struct GtkActionBarLeaf <: GtkActionBar
            handle::Ptr{GObject}
            function GtkActionBarLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkActionBarLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkActionBarLeaf(args...; kwargs...)
            w = GtkActionBar(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkActionBar] = GtkActionBarLeaf
        function GtkActionBar(args...; kwargs...)
            GtkActionBarLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkShortcutAction <: GObject end
        mutable struct GtkShortcutActionLeaf <: GtkShortcutAction
            handle::Ptr{GObject}
            function GtkShortcutActionLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkShortcutActionLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkShortcutActionLeaf(args...; kwargs...)
            w = GtkShortcutAction(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkShortcutAction] = GtkShortcutActionLeaf
        function GtkShortcutAction(args...; kwargs...)
            GtkShortcutActionLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkActivateAction <: GtkShortcutAction end
        mutable struct GtkActivateActionLeaf <: GtkActivateAction
            handle::Ptr{GObject}
            function GtkActivateActionLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkActivateActionLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkActivateActionLeaf(args...; kwargs...)
            w = GtkActivateAction(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkActivateAction] = GtkActivateActionLeaf
        function GtkActivateAction(args...; kwargs...)
            GtkActivateActionLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkAdjustment <: GInitiallyUnowned end
        mutable struct GtkAdjustmentLeaf <: GtkAdjustment
            handle::Ptr{GObject}
            function GtkAdjustmentLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkAdjustmentLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkAdjustmentLeaf(args...; kwargs...)
            w = GtkAdjustment(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkAdjustment] = GtkAdjustmentLeaf
        function GtkAdjustment(args...; kwargs...)
            GtkAdjustmentLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkShortcutTrigger <: GObject end
        mutable struct GtkShortcutTriggerLeaf <: GtkShortcutTrigger
            handle::Ptr{GObject}
            function GtkShortcutTriggerLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkShortcutTriggerLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkShortcutTriggerLeaf(args...; kwargs...)
            w = GtkShortcutTrigger(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkShortcutTrigger] = GtkShortcutTriggerLeaf
        function GtkShortcutTrigger(args...; kwargs...)
            GtkShortcutTriggerLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkAlternativeTrigger <: GtkShortcutTrigger end
        mutable struct GtkAlternativeTriggerLeaf <: GtkAlternativeTrigger
            handle::Ptr{GObject}
            function GtkAlternativeTriggerLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkAlternativeTriggerLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkAlternativeTriggerLeaf(args...; kwargs...)
            w = GtkAlternativeTrigger(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkAlternativeTrigger] = GtkAlternativeTriggerLeaf
        function GtkAlternativeTrigger(args...; kwargs...)
            GtkAlternativeTriggerLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkFilter <: GObject end
        mutable struct GtkFilterLeaf <: GtkFilter
            handle::Ptr{GObject}
            function GtkFilterLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkFilterLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkFilterLeaf(args...; kwargs...)
            w = GtkFilter(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkFilter] = GtkFilterLeaf
        function GtkFilter(args...; kwargs...)
            GtkFilterLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkMultiFilter <: GtkFilter end
        mutable struct GtkMultiFilterLeaf <: GtkMultiFilter
            handle::Ptr{GObject}
            function GtkMultiFilterLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkMultiFilterLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkMultiFilterLeaf(args...; kwargs...)
            w = GtkMultiFilter(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkMultiFilter] = GtkMultiFilterLeaf
        function GtkMultiFilter(args...; kwargs...)
            GtkMultiFilterLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkAnyFilter <: GtkMultiFilter end
        mutable struct GtkAnyFilterLeaf <: GtkAnyFilter
            handle::Ptr{GObject}
            function GtkAnyFilterLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkAnyFilterLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkAnyFilterLeaf(args...; kwargs...)
            w = GtkAnyFilter(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkAnyFilter] = GtkAnyFilterLeaf
        function GtkAnyFilter(args...; kwargs...)
            GtkAnyFilterLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkAppChooserButton <: GtkWidget end
        mutable struct GtkAppChooserButtonLeaf <: GtkAppChooserButton
            handle::Ptr{GObject}
            function GtkAppChooserButtonLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkAppChooserButtonLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkAppChooserButtonLeaf(args...; kwargs...)
            w = GtkAppChooserButton(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkAppChooserButton] = GtkAppChooserButtonLeaf
        function GtkAppChooserButton(args...; kwargs...)
            GtkAppChooserButtonLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkDialog <: GtkWindow end
        mutable struct GtkDialogLeaf <: GtkDialog
            handle::Ptr{GObject}
            function GtkDialogLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkDialogLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkDialogLeaf(args...; kwargs...)
            w = GtkDialog(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkDialog] = GtkDialogLeaf
        function GtkDialog(args...; kwargs...)
            GtkDialogLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkAppChooserDialog <: GtkDialog end
        mutable struct GtkAppChooserDialogLeaf <: GtkAppChooserDialog
            handle::Ptr{GObject}
            function GtkAppChooserDialogLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkAppChooserDialogLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkAppChooserDialogLeaf(args...; kwargs...)
            w = GtkAppChooserDialog(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkAppChooserDialog] = GtkAppChooserDialogLeaf
        function GtkAppChooserDialog(args...; kwargs...)
            GtkAppChooserDialogLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkAppChooserWidget <: GtkWidget end
        mutable struct GtkAppChooserWidgetLeaf <: GtkAppChooserWidget
            handle::Ptr{GObject}
            function GtkAppChooserWidgetLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkAppChooserWidgetLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkAppChooserWidgetLeaf(args...; kwargs...)
            w = GtkAppChooserWidget(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkAppChooserWidget] = GtkAppChooserWidgetLeaf
        function GtkAppChooserWidget(args...; kwargs...)
            GtkAppChooserWidgetLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkApplication <: GApplication end
        mutable struct GtkApplicationLeaf <: GtkApplication
            handle::Ptr{GObject}
            function GtkApplicationLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkApplicationLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkApplicationLeaf(args...; kwargs...)
            w = GtkApplication(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkApplication] = GtkApplicationLeaf
        function GtkApplication(args...; kwargs...)
            GtkApplicationLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkApplicationWindow <: GtkWindow end
        mutable struct GtkApplicationWindowLeaf <: GtkApplicationWindow
            handle::Ptr{GObject}
            function GtkApplicationWindowLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkApplicationWindowLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkApplicationWindowLeaf(args...; kwargs...)
            w = GtkApplicationWindow(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkApplicationWindow] = GtkApplicationWindowLeaf
        function GtkApplicationWindow(args...; kwargs...)
            GtkApplicationWindowLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkAspectFrame <: GtkWidget end
        mutable struct GtkAspectFrameLeaf <: GtkAspectFrame
            handle::Ptr{GObject}
            function GtkAspectFrameLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkAspectFrameLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkAspectFrameLeaf(args...; kwargs...)
            w = GtkAspectFrame(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkAspectFrame] = GtkAspectFrameLeaf
        function GtkAspectFrame(args...; kwargs...)
            GtkAspectFrameLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkAssistant <: GtkWindow end
        mutable struct GtkAssistantLeaf <: GtkAssistant
            handle::Ptr{GObject}
            function GtkAssistantLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkAssistantLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkAssistantLeaf(args...; kwargs...)
            w = GtkAssistant(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkAssistant] = GtkAssistantLeaf
        function GtkAssistant(args...; kwargs...)
            GtkAssistantLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkAssistantPage <: GObject end
        mutable struct GtkAssistantPageLeaf <: GtkAssistantPage
            handle::Ptr{GObject}
            function GtkAssistantPageLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkAssistantPageLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkAssistantPageLeaf(args...; kwargs...)
            w = GtkAssistantPage(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkAssistantPage] = GtkAssistantPageLeaf
        function GtkAssistantPage(args...; kwargs...)
            GtkAssistantPageLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkLayoutManager <: GObject end
        mutable struct GtkLayoutManagerLeaf <: GtkLayoutManager
            handle::Ptr{GObject}
            function GtkLayoutManagerLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkLayoutManagerLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkLayoutManagerLeaf(args...; kwargs...)
            w = GtkLayoutManager(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkLayoutManager] = GtkLayoutManagerLeaf
        function GtkLayoutManager(args...; kwargs...)
            GtkLayoutManagerLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkBinLayout <: GtkLayoutManager end
        mutable struct GtkBinLayoutLeaf <: GtkBinLayout
            handle::Ptr{GObject}
            function GtkBinLayoutLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkBinLayoutLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkBinLayoutLeaf(args...; kwargs...)
            w = GtkBinLayout(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkBinLayout] = GtkBinLayoutLeaf
        function GtkBinLayout(args...; kwargs...)
            GtkBinLayoutLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkBookmarkList <: GObject end
        mutable struct GtkBookmarkListLeaf <: GtkBookmarkList
            handle::Ptr{GObject}
            function GtkBookmarkListLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkBookmarkListLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkBookmarkListLeaf(args...; kwargs...)
            w = GtkBookmarkList(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkBookmarkList] = GtkBookmarkListLeaf
        function GtkBookmarkList(args...; kwargs...)
            GtkBookmarkListLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkBoolFilter <: GtkFilter end
        mutable struct GtkBoolFilterLeaf <: GtkBoolFilter
            handle::Ptr{GObject}
            function GtkBoolFilterLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkBoolFilterLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkBoolFilterLeaf(args...; kwargs...)
            w = GtkBoolFilter(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkBoolFilter] = GtkBoolFilterLeaf
        function GtkBoolFilter(args...; kwargs...)
            GtkBoolFilterLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkBox <: GtkWidget end
        mutable struct GtkBoxLeaf <: GtkBox
            handle::Ptr{GObject}
            function GtkBoxLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkBoxLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkBoxLeaf(args...; kwargs...)
            w = GtkBox(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkBox] = GtkBoxLeaf
        function GtkBox(args...; kwargs...)
            GtkBoxLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkBoxLayout <: GtkLayoutManager end
        mutable struct GtkBoxLayoutLeaf <: GtkBoxLayout
            handle::Ptr{GObject}
            function GtkBoxLayoutLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkBoxLayoutLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkBoxLayoutLeaf(args...; kwargs...)
            w = GtkBoxLayout(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkBoxLayout] = GtkBoxLayoutLeaf
        function GtkBoxLayout(args...; kwargs...)
            GtkBoxLayoutLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkBuilder <: GObject end
        mutable struct GtkBuilderLeaf <: GtkBuilder
            handle::Ptr{GObject}
            function GtkBuilderLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkBuilderLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkBuilderLeaf(args...; kwargs...)
            w = GtkBuilder(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkBuilder] = GtkBuilderLeaf
        function GtkBuilder(args...; kwargs...)
            GtkBuilderLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkBuilderCScope <: GObject end
        mutable struct GtkBuilderCScopeLeaf <: GtkBuilderCScope
            handle::Ptr{GObject}
            function GtkBuilderCScopeLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkBuilderCScopeLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkBuilderCScopeLeaf(args...; kwargs...)
            w = GtkBuilderCScope(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkBuilderCScope] = GtkBuilderCScopeLeaf
        function GtkBuilderCScope(args...; kwargs...)
            GtkBuilderCScopeLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkListItemFactory <: GObject end
        mutable struct GtkListItemFactoryLeaf <: GtkListItemFactory
            handle::Ptr{GObject}
            function GtkListItemFactoryLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkListItemFactoryLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkListItemFactoryLeaf(args...; kwargs...)
            w = GtkListItemFactory(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkListItemFactory] = GtkListItemFactoryLeaf
        function GtkListItemFactory(args...; kwargs...)
            GtkListItemFactoryLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkBuilderListItemFactory <: GtkListItemFactory end
        mutable struct GtkBuilderListItemFactoryLeaf <: GtkBuilderListItemFactory
            handle::Ptr{GObject}
            function GtkBuilderListItemFactoryLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkBuilderListItemFactoryLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkBuilderListItemFactoryLeaf(args...; kwargs...)
            w = GtkBuilderListItemFactory(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkBuilderListItemFactory] = GtkBuilderListItemFactoryLeaf
        function GtkBuilderListItemFactory(args...; kwargs...)
            GtkBuilderListItemFactoryLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkButton <: GtkWidget end
        mutable struct GtkButtonLeaf <: GtkButton
            handle::Ptr{GObject}
            function GtkButtonLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkButtonLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkButtonLeaf(args...; kwargs...)
            w = GtkButton(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkButton] = GtkButtonLeaf
        function GtkButton(args...; kwargs...)
            GtkButtonLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkCalendar <: GtkWidget end
        mutable struct GtkCalendarLeaf <: GtkCalendar
            handle::Ptr{GObject}
            function GtkCalendarLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkCalendarLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkCalendarLeaf(args...; kwargs...)
            w = GtkCalendar(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkCalendar] = GtkCalendarLeaf
        function GtkCalendar(args...; kwargs...)
            GtkCalendarLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkCallbackAction <: GtkShortcutAction end
        mutable struct GtkCallbackActionLeaf <: GtkCallbackAction
            handle::Ptr{GObject}
            function GtkCallbackActionLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkCallbackActionLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkCallbackActionLeaf(args...; kwargs...)
            w = GtkCallbackAction(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkCallbackAction] = GtkCallbackActionLeaf
        function GtkCallbackAction(args...; kwargs...)
            GtkCallbackActionLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkCellArea <: GInitiallyUnowned end
        mutable struct GtkCellAreaLeaf <: GtkCellArea
            handle::Ptr{GObject}
            function GtkCellAreaLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkCellAreaLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkCellAreaLeaf(args...; kwargs...)
            w = GtkCellArea(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkCellArea] = GtkCellAreaLeaf
        function GtkCellArea(args...; kwargs...)
            GtkCellAreaLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkCellAreaBox <: GtkCellArea end
        mutable struct GtkCellAreaBoxLeaf <: GtkCellAreaBox
            handle::Ptr{GObject}
            function GtkCellAreaBoxLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkCellAreaBoxLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkCellAreaBoxLeaf(args...; kwargs...)
            w = GtkCellAreaBox(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkCellAreaBox] = GtkCellAreaBoxLeaf
        function GtkCellAreaBox(args...; kwargs...)
            GtkCellAreaBoxLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkCellAreaContext <: GObject end
        mutable struct GtkCellAreaContextLeaf <: GtkCellAreaContext
            handle::Ptr{GObject}
            function GtkCellAreaContextLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkCellAreaContextLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkCellAreaContextLeaf(args...; kwargs...)
            w = GtkCellAreaContext(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkCellAreaContext] = GtkCellAreaContextLeaf
        function GtkCellAreaContext(args...; kwargs...)
            GtkCellAreaContextLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkCellRenderer <: GInitiallyUnowned end
        mutable struct GtkCellRendererLeaf <: GtkCellRenderer
            handle::Ptr{GObject}
            function GtkCellRendererLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkCellRendererLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkCellRendererLeaf(args...; kwargs...)
            w = GtkCellRenderer(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkCellRenderer] = GtkCellRendererLeaf
        function GtkCellRenderer(args...; kwargs...)
            GtkCellRendererLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkCellRendererText <: GtkCellRenderer end
        mutable struct GtkCellRendererTextLeaf <: GtkCellRendererText
            handle::Ptr{GObject}
            function GtkCellRendererTextLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkCellRendererTextLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkCellRendererTextLeaf(args...; kwargs...)
            w = GtkCellRendererText(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkCellRendererText] = GtkCellRendererTextLeaf
        function GtkCellRendererText(args...; kwargs...)
            GtkCellRendererTextLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkCellRendererAccel <: GtkCellRendererText end
        mutable struct GtkCellRendererAccelLeaf <: GtkCellRendererAccel
            handle::Ptr{GObject}
            function GtkCellRendererAccelLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkCellRendererAccelLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkCellRendererAccelLeaf(args...; kwargs...)
            w = GtkCellRendererAccel(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkCellRendererAccel] = GtkCellRendererAccelLeaf
        function GtkCellRendererAccel(args...; kwargs...)
            GtkCellRendererAccelLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkCellRendererCombo <: GtkCellRendererText end
        mutable struct GtkCellRendererComboLeaf <: GtkCellRendererCombo
            handle::Ptr{GObject}
            function GtkCellRendererComboLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkCellRendererComboLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkCellRendererComboLeaf(args...; kwargs...)
            w = GtkCellRendererCombo(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkCellRendererCombo] = GtkCellRendererComboLeaf
        function GtkCellRendererCombo(args...; kwargs...)
            GtkCellRendererComboLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkCellRendererPixbuf <: GtkCellRenderer end
        mutable struct GtkCellRendererPixbufLeaf <: GtkCellRendererPixbuf
            handle::Ptr{GObject}
            function GtkCellRendererPixbufLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkCellRendererPixbufLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkCellRendererPixbufLeaf(args...; kwargs...)
            w = GtkCellRendererPixbuf(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkCellRendererPixbuf] = GtkCellRendererPixbufLeaf
        function GtkCellRendererPixbuf(args...; kwargs...)
            GtkCellRendererPixbufLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkCellRendererProgress <: GtkCellRenderer end
        mutable struct GtkCellRendererProgressLeaf <: GtkCellRendererProgress
            handle::Ptr{GObject}
            function GtkCellRendererProgressLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkCellRendererProgressLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkCellRendererProgressLeaf(args...; kwargs...)
            w = GtkCellRendererProgress(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkCellRendererProgress] = GtkCellRendererProgressLeaf
        function GtkCellRendererProgress(args...; kwargs...)
            GtkCellRendererProgressLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkCellRendererSpin <: GtkCellRendererText end
        mutable struct GtkCellRendererSpinLeaf <: GtkCellRendererSpin
            handle::Ptr{GObject}
            function GtkCellRendererSpinLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkCellRendererSpinLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkCellRendererSpinLeaf(args...; kwargs...)
            w = GtkCellRendererSpin(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkCellRendererSpin] = GtkCellRendererSpinLeaf
        function GtkCellRendererSpin(args...; kwargs...)
            GtkCellRendererSpinLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkCellRendererSpinner <: GtkCellRenderer end
        mutable struct GtkCellRendererSpinnerLeaf <: GtkCellRendererSpinner
            handle::Ptr{GObject}
            function GtkCellRendererSpinnerLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkCellRendererSpinnerLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkCellRendererSpinnerLeaf(args...; kwargs...)
            w = GtkCellRendererSpinner(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkCellRendererSpinner] = GtkCellRendererSpinnerLeaf
        function GtkCellRendererSpinner(args...; kwargs...)
            GtkCellRendererSpinnerLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkCellRendererToggle <: GtkCellRenderer end
        mutable struct GtkCellRendererToggleLeaf <: GtkCellRendererToggle
            handle::Ptr{GObject}
            function GtkCellRendererToggleLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkCellRendererToggleLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkCellRendererToggleLeaf(args...; kwargs...)
            w = GtkCellRendererToggle(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkCellRendererToggle] = GtkCellRendererToggleLeaf
        function GtkCellRendererToggle(args...; kwargs...)
            GtkCellRendererToggleLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkCellView <: GtkWidget end
        mutable struct GtkCellViewLeaf <: GtkCellView
            handle::Ptr{GObject}
            function GtkCellViewLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkCellViewLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkCellViewLeaf(args...; kwargs...)
            w = GtkCellView(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkCellView] = GtkCellViewLeaf
        function GtkCellView(args...; kwargs...)
            GtkCellViewLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkCenterBox <: GtkWidget end
        mutable struct GtkCenterBoxLeaf <: GtkCenterBox
            handle::Ptr{GObject}
            function GtkCenterBoxLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkCenterBoxLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkCenterBoxLeaf(args...; kwargs...)
            w = GtkCenterBox(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkCenterBox] = GtkCenterBoxLeaf
        function GtkCenterBox(args...; kwargs...)
            GtkCenterBoxLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkCenterLayout <: GtkLayoutManager end
        mutable struct GtkCenterLayoutLeaf <: GtkCenterLayout
            handle::Ptr{GObject}
            function GtkCenterLayoutLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkCenterLayoutLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkCenterLayoutLeaf(args...; kwargs...)
            w = GtkCenterLayout(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkCenterLayout] = GtkCenterLayoutLeaf
        function GtkCenterLayout(args...; kwargs...)
            GtkCenterLayoutLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkCheckButton <: GtkWidget end
        mutable struct GtkCheckButtonLeaf <: GtkCheckButton
            handle::Ptr{GObject}
            function GtkCheckButtonLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkCheckButtonLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkCheckButtonLeaf(args...; kwargs...)
            w = GtkCheckButton(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkCheckButton] = GtkCheckButtonLeaf
        function GtkCheckButton(args...; kwargs...)
            GtkCheckButtonLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkColorButton <: GtkWidget end
        mutable struct GtkColorButtonLeaf <: GtkColorButton
            handle::Ptr{GObject}
            function GtkColorButtonLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkColorButtonLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkColorButtonLeaf(args...; kwargs...)
            w = GtkColorButton(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkColorButton] = GtkColorButtonLeaf
        function GtkColorButton(args...; kwargs...)
            GtkColorButtonLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkColorChooserDialog <: GtkDialog end
        mutable struct GtkColorChooserDialogLeaf <: GtkColorChooserDialog
            handle::Ptr{GObject}
            function GtkColorChooserDialogLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkColorChooserDialogLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkColorChooserDialogLeaf(args...; kwargs...)
            w = GtkColorChooserDialog(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkColorChooserDialog] = GtkColorChooserDialogLeaf
        function GtkColorChooserDialog(args...; kwargs...)
            GtkColorChooserDialogLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkColorChooserWidget <: GtkWidget end
        mutable struct GtkColorChooserWidgetLeaf <: GtkColorChooserWidget
            handle::Ptr{GObject}
            function GtkColorChooserWidgetLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkColorChooserWidgetLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkColorChooserWidgetLeaf(args...; kwargs...)
            w = GtkColorChooserWidget(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkColorChooserWidget] = GtkColorChooserWidgetLeaf
        function GtkColorChooserWidget(args...; kwargs...)
            GtkColorChooserWidgetLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkColumnView <: GtkWidget end
        mutable struct GtkColumnViewLeaf <: GtkColumnView
            handle::Ptr{GObject}
            function GtkColumnViewLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkColumnViewLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkColumnViewLeaf(args...; kwargs...)
            w = GtkColumnView(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkColumnView] = GtkColumnViewLeaf
        function GtkColumnView(args...; kwargs...)
            GtkColumnViewLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkColumnViewColumn <: GObject end
        mutable struct GtkColumnViewColumnLeaf <: GtkColumnViewColumn
            handle::Ptr{GObject}
            function GtkColumnViewColumnLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkColumnViewColumnLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkColumnViewColumnLeaf(args...; kwargs...)
            w = GtkColumnViewColumn(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkColumnViewColumn] = GtkColumnViewColumnLeaf
        function GtkColumnViewColumn(args...; kwargs...)
            GtkColumnViewColumnLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkComboBox <: GtkWidget end
        mutable struct GtkComboBoxLeaf <: GtkComboBox
            handle::Ptr{GObject}
            function GtkComboBoxLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkComboBoxLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkComboBoxLeaf(args...; kwargs...)
            w = GtkComboBox(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkComboBox] = GtkComboBoxLeaf
        function GtkComboBox(args...; kwargs...)
            GtkComboBoxLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkComboBoxText <: GtkComboBox end
        mutable struct GtkComboBoxTextLeaf <: GtkComboBoxText
            handle::Ptr{GObject}
            function GtkComboBoxTextLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkComboBoxTextLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkComboBoxTextLeaf(args...; kwargs...)
            w = GtkComboBoxText(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkComboBoxText] = GtkComboBoxTextLeaf
        function GtkComboBoxText(args...; kwargs...)
            GtkComboBoxTextLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkConstraint <: GObject end
        mutable struct GtkConstraintLeaf <: GtkConstraint
            handle::Ptr{GObject}
            function GtkConstraintLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkConstraintLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkConstraintLeaf(args...; kwargs...)
            w = GtkConstraint(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkConstraint] = GtkConstraintLeaf
        function GtkConstraint(args...; kwargs...)
            GtkConstraintLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkConstraintGuide <: GObject end
        mutable struct GtkConstraintGuideLeaf <: GtkConstraintGuide
            handle::Ptr{GObject}
            function GtkConstraintGuideLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkConstraintGuideLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkConstraintGuideLeaf(args...; kwargs...)
            w = GtkConstraintGuide(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkConstraintGuide] = GtkConstraintGuideLeaf
        function GtkConstraintGuide(args...; kwargs...)
            GtkConstraintGuideLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkConstraintLayout <: GtkLayoutManager end
        mutable struct GtkConstraintLayoutLeaf <: GtkConstraintLayout
            handle::Ptr{GObject}
            function GtkConstraintLayoutLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkConstraintLayoutLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkConstraintLayoutLeaf(args...; kwargs...)
            w = GtkConstraintLayout(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkConstraintLayout] = GtkConstraintLayoutLeaf
        function GtkConstraintLayout(args...; kwargs...)
            GtkConstraintLayoutLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkLayoutChild <: GObject end
        mutable struct GtkLayoutChildLeaf <: GtkLayoutChild
            handle::Ptr{GObject}
            function GtkLayoutChildLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkLayoutChildLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkLayoutChildLeaf(args...; kwargs...)
            w = GtkLayoutChild(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkLayoutChild] = GtkLayoutChildLeaf
        function GtkLayoutChild(args...; kwargs...)
            GtkLayoutChildLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkConstraintLayoutChild <: GtkLayoutChild end
        mutable struct GtkConstraintLayoutChildLeaf <: GtkConstraintLayoutChild
            handle::Ptr{GObject}
            function GtkConstraintLayoutChildLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkConstraintLayoutChildLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkConstraintLayoutChildLeaf(args...; kwargs...)
            w = GtkConstraintLayoutChild(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkConstraintLayoutChild] = GtkConstraintLayoutChildLeaf
        function GtkConstraintLayoutChild(args...; kwargs...)
            GtkConstraintLayoutChildLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkCssProvider <: GObject end
        mutable struct GtkCssProviderLeaf <: GtkCssProvider
            handle::Ptr{GObject}
            function GtkCssProviderLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkCssProviderLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkCssProviderLeaf(args...; kwargs...)
            w = GtkCssProvider(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkCssProvider] = GtkCssProviderLeaf
        function GtkCssProvider(args...; kwargs...)
            GtkCssProviderLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkCustomFilter <: GtkFilter end
        mutable struct GtkCustomFilterLeaf <: GtkCustomFilter
            handle::Ptr{GObject}
            function GtkCustomFilterLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkCustomFilterLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkCustomFilterLeaf(args...; kwargs...)
            w = GtkCustomFilter(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkCustomFilter] = GtkCustomFilterLeaf
        function GtkCustomFilter(args...; kwargs...)
            GtkCustomFilterLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkCustomLayout <: GtkLayoutManager end
        mutable struct GtkCustomLayoutLeaf <: GtkCustomLayout
            handle::Ptr{GObject}
            function GtkCustomLayoutLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkCustomLayoutLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkCustomLayoutLeaf(args...; kwargs...)
            w = GtkCustomLayout(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkCustomLayout] = GtkCustomLayoutLeaf
        function GtkCustomLayout(args...; kwargs...)
            GtkCustomLayoutLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkSorter <: GObject end
        mutable struct GtkSorterLeaf <: GtkSorter
            handle::Ptr{GObject}
            function GtkSorterLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkSorterLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkSorterLeaf(args...; kwargs...)
            w = GtkSorter(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkSorter] = GtkSorterLeaf
        function GtkSorter(args...; kwargs...)
            GtkSorterLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkCustomSorter <: GtkSorter end
        mutable struct GtkCustomSorterLeaf <: GtkCustomSorter
            handle::Ptr{GObject}
            function GtkCustomSorterLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkCustomSorterLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkCustomSorterLeaf(args...; kwargs...)
            w = GtkCustomSorter(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkCustomSorter] = GtkCustomSorterLeaf
        function GtkCustomSorter(args...; kwargs...)
            GtkCustomSorterLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkDirectoryList <: GObject end
        mutable struct GtkDirectoryListLeaf <: GtkDirectoryList
            handle::Ptr{GObject}
            function GtkDirectoryListLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkDirectoryListLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkDirectoryListLeaf(args...; kwargs...)
            w = GtkDirectoryList(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkDirectoryList] = GtkDirectoryListLeaf
        function GtkDirectoryList(args...; kwargs...)
            GtkDirectoryListLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkDragIcon <: GtkWidget end
        mutable struct GtkDragIconLeaf <: GtkDragIcon
            handle::Ptr{GObject}
            function GtkDragIconLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkDragIconLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkDragIconLeaf(args...; kwargs...)
            w = GtkDragIcon(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkDragIcon] = GtkDragIconLeaf
        function GtkDragIcon(args...; kwargs...)
            GtkDragIconLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkEventController <: GObject end
        mutable struct GtkEventControllerLeaf <: GtkEventController
            handle::Ptr{GObject}
            function GtkEventControllerLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkEventControllerLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkEventControllerLeaf(args...; kwargs...)
            w = GtkEventController(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkEventController] = GtkEventControllerLeaf
        function GtkEventController(args...; kwargs...)
            GtkEventControllerLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkGesture <: GtkEventController end
        mutable struct GtkGestureLeaf <: GtkGesture
            handle::Ptr{GObject}
            function GtkGestureLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkGestureLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkGestureLeaf(args...; kwargs...)
            w = GtkGesture(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkGesture] = GtkGestureLeaf
        function GtkGesture(args...; kwargs...)
            GtkGestureLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkGestureSingle <: GtkGesture end
        mutable struct GtkGestureSingleLeaf <: GtkGestureSingle
            handle::Ptr{GObject}
            function GtkGestureSingleLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkGestureSingleLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkGestureSingleLeaf(args...; kwargs...)
            w = GtkGestureSingle(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkGestureSingle] = GtkGestureSingleLeaf
        function GtkGestureSingle(args...; kwargs...)
            GtkGestureSingleLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkDragSource <: GtkGestureSingle end
        mutable struct GtkDragSourceLeaf <: GtkDragSource
            handle::Ptr{GObject}
            function GtkDragSourceLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkDragSourceLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkDragSourceLeaf(args...; kwargs...)
            w = GtkDragSource(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkDragSource] = GtkDragSourceLeaf
        function GtkDragSource(args...; kwargs...)
            GtkDragSourceLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkDrawingArea <: GtkWidget end
        mutable struct GtkDrawingAreaLeaf <: GtkDrawingArea
            handle::Ptr{GObject}
            function GtkDrawingAreaLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkDrawingAreaLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkDrawingAreaLeaf(args...; kwargs...)
            w = GtkDrawingArea(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkDrawingArea] = GtkDrawingAreaLeaf
        function GtkDrawingArea(args...; kwargs...)
            GtkDrawingAreaLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkDropControllerMotion <: GtkEventController end
        mutable struct GtkDropControllerMotionLeaf <: GtkDropControllerMotion
            handle::Ptr{GObject}
            function GtkDropControllerMotionLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkDropControllerMotionLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkDropControllerMotionLeaf(args...; kwargs...)
            w = GtkDropControllerMotion(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkDropControllerMotion] = GtkDropControllerMotionLeaf
        function GtkDropControllerMotion(args...; kwargs...)
            GtkDropControllerMotionLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkDropDown <: GtkWidget end
        mutable struct GtkDropDownLeaf <: GtkDropDown
            handle::Ptr{GObject}
            function GtkDropDownLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkDropDownLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkDropDownLeaf(args...; kwargs...)
            w = GtkDropDown(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkDropDown] = GtkDropDownLeaf
        function GtkDropDown(args...; kwargs...)
            GtkDropDownLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkDropTarget <: GtkEventController end
        mutable struct GtkDropTargetLeaf <: GtkDropTarget
            handle::Ptr{GObject}
            function GtkDropTargetLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkDropTargetLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkDropTargetLeaf(args...; kwargs...)
            w = GtkDropTarget(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkDropTarget] = GtkDropTargetLeaf
        function GtkDropTarget(args...; kwargs...)
            GtkDropTargetLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkDropTargetAsync <: GtkEventController end
        mutable struct GtkDropTargetAsyncLeaf <: GtkDropTargetAsync
            handle::Ptr{GObject}
            function GtkDropTargetAsyncLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkDropTargetAsyncLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkDropTargetAsyncLeaf(args...; kwargs...)
            w = GtkDropTargetAsync(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkDropTargetAsync] = GtkDropTargetAsyncLeaf
        function GtkDropTargetAsync(args...; kwargs...)
            GtkDropTargetAsyncLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkEditableLabel <: GtkWidget end
        mutable struct GtkEditableLabelLeaf <: GtkEditableLabel
            handle::Ptr{GObject}
            function GtkEditableLabelLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkEditableLabelLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkEditableLabelLeaf(args...; kwargs...)
            w = GtkEditableLabel(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkEditableLabel] = GtkEditableLabelLeaf
        function GtkEditableLabel(args...; kwargs...)
            GtkEditableLabelLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkPopover <: GtkWidget end
        mutable struct GtkPopoverLeaf <: GtkPopover
            handle::Ptr{GObject}
            function GtkPopoverLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkPopoverLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkPopoverLeaf(args...; kwargs...)
            w = GtkPopover(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkPopover] = GtkPopoverLeaf
        function GtkPopover(args...; kwargs...)
            GtkPopoverLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkEmojiChooser <: GtkPopover end
        mutable struct GtkEmojiChooserLeaf <: GtkEmojiChooser
            handle::Ptr{GObject}
            function GtkEmojiChooserLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkEmojiChooserLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkEmojiChooserLeaf(args...; kwargs...)
            w = GtkEmojiChooser(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkEmojiChooser] = GtkEmojiChooserLeaf
        function GtkEmojiChooser(args...; kwargs...)
            GtkEmojiChooserLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkEntry <: GtkWidget end
        mutable struct GtkEntryLeaf <: GtkEntry
            handle::Ptr{GObject}
            function GtkEntryLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkEntryLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkEntryLeaf(args...; kwargs...)
            w = GtkEntry(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkEntry] = GtkEntryLeaf
        function GtkEntry(args...; kwargs...)
            GtkEntryLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkEntryBuffer <: GObject end
        mutable struct GtkEntryBufferLeaf <: GtkEntryBuffer
            handle::Ptr{GObject}
            function GtkEntryBufferLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkEntryBufferLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkEntryBufferLeaf(args...; kwargs...)
            w = GtkEntryBuffer(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkEntryBuffer] = GtkEntryBufferLeaf
        function GtkEntryBuffer(args...; kwargs...)
            GtkEntryBufferLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkEntryCompletion <: GObject end
        mutable struct GtkEntryCompletionLeaf <: GtkEntryCompletion
            handle::Ptr{GObject}
            function GtkEntryCompletionLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkEntryCompletionLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkEntryCompletionLeaf(args...; kwargs...)
            w = GtkEntryCompletion(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkEntryCompletion] = GtkEntryCompletionLeaf
        function GtkEntryCompletion(args...; kwargs...)
            GtkEntryCompletionLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkEventControllerFocus <: GtkEventController end
        mutable struct GtkEventControllerFocusLeaf <: GtkEventControllerFocus
            handle::Ptr{GObject}
            function GtkEventControllerFocusLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkEventControllerFocusLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkEventControllerFocusLeaf(args...; kwargs...)
            w = GtkEventControllerFocus(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkEventControllerFocus] = GtkEventControllerFocusLeaf
        function GtkEventControllerFocus(args...; kwargs...)
            GtkEventControllerFocusLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkEventControllerKey <: GtkEventController end
        mutable struct GtkEventControllerKeyLeaf <: GtkEventControllerKey
            handle::Ptr{GObject}
            function GtkEventControllerKeyLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkEventControllerKeyLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkEventControllerKeyLeaf(args...; kwargs...)
            w = GtkEventControllerKey(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkEventControllerKey] = GtkEventControllerKeyLeaf
        function GtkEventControllerKey(args...; kwargs...)
            GtkEventControllerKeyLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkEventControllerLegacy <: GtkEventController end
        mutable struct GtkEventControllerLegacyLeaf <: GtkEventControllerLegacy
            handle::Ptr{GObject}
            function GtkEventControllerLegacyLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkEventControllerLegacyLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkEventControllerLegacyLeaf(args...; kwargs...)
            w = GtkEventControllerLegacy(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkEventControllerLegacy] = GtkEventControllerLegacyLeaf
        function GtkEventControllerLegacy(args...; kwargs...)
            GtkEventControllerLegacyLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkEventControllerMotion <: GtkEventController end
        mutable struct GtkEventControllerMotionLeaf <: GtkEventControllerMotion
            handle::Ptr{GObject}
            function GtkEventControllerMotionLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkEventControllerMotionLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkEventControllerMotionLeaf(args...; kwargs...)
            w = GtkEventControllerMotion(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkEventControllerMotion] = GtkEventControllerMotionLeaf
        function GtkEventControllerMotion(args...; kwargs...)
            GtkEventControllerMotionLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkEventControllerScroll <: GtkEventController end
        mutable struct GtkEventControllerScrollLeaf <: GtkEventControllerScroll
            handle::Ptr{GObject}
            function GtkEventControllerScrollLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkEventControllerScrollLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkEventControllerScrollLeaf(args...; kwargs...)
            w = GtkEventControllerScroll(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkEventControllerScroll] = GtkEventControllerScrollLeaf
        function GtkEventControllerScroll(args...; kwargs...)
            GtkEventControllerScrollLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkEveryFilter <: GtkMultiFilter end
        mutable struct GtkEveryFilterLeaf <: GtkEveryFilter
            handle::Ptr{GObject}
            function GtkEveryFilterLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkEveryFilterLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkEveryFilterLeaf(args...; kwargs...)
            w = GtkEveryFilter(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkEveryFilter] = GtkEveryFilterLeaf
        function GtkEveryFilter(args...; kwargs...)
            GtkEveryFilterLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkExpander <: GtkWidget end
        mutable struct GtkExpanderLeaf <: GtkExpander
            handle::Ptr{GObject}
            function GtkExpanderLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkExpanderLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkExpanderLeaf(args...; kwargs...)
            w = GtkExpander(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkExpander] = GtkExpanderLeaf
        function GtkExpander(args...; kwargs...)
            GtkExpanderLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkExpression end
        Base.convert(::Type{GtkExpression}, ptr::Ptr{GtkExpression}) = begin
                GtkExpressionLeaf(ptr)
            end
        Base.unsafe_convert(::Type{Ptr{GtkExpression}}, o::GtkExpression) = begin
                o.handle
            end
    end
    begin
        mutable struct GtkExpressionLeaf <: GtkExpression
            handle::Ptr{GtkExpression}
        end
    end
    begin
        abstract type GtkFileChooserDialog <: GtkDialog end
        mutable struct GtkFileChooserDialogLeaf <: GtkFileChooserDialog
            handle::Ptr{GObject}
            function GtkFileChooserDialogLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkFileChooserDialogLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkFileChooserDialogLeaf(args...; kwargs...)
            w = GtkFileChooserDialog(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkFileChooserDialog] = GtkFileChooserDialogLeaf
        function GtkFileChooserDialog(args...; kwargs...)
            GtkFileChooserDialogLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkNativeDialog <: GObject end
        mutable struct GtkNativeDialogLeaf <: GtkNativeDialog
            handle::Ptr{GObject}
            function GtkNativeDialogLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkNativeDialogLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkNativeDialogLeaf(args...; kwargs...)
            w = GtkNativeDialog(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkNativeDialog] = GtkNativeDialogLeaf
        function GtkNativeDialog(args...; kwargs...)
            GtkNativeDialogLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkFileChooserNative <: GtkNativeDialog end
        mutable struct GtkFileChooserNativeLeaf <: GtkFileChooserNative
            handle::Ptr{GObject}
            function GtkFileChooserNativeLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkFileChooserNativeLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkFileChooserNativeLeaf(args...; kwargs...)
            w = GtkFileChooserNative(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkFileChooserNative] = GtkFileChooserNativeLeaf
        function GtkFileChooserNative(args...; kwargs...)
            GtkFileChooserNativeLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkFileChooserWidget <: GtkWidget end
        mutable struct GtkFileChooserWidgetLeaf <: GtkFileChooserWidget
            handle::Ptr{GObject}
            function GtkFileChooserWidgetLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkFileChooserWidgetLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkFileChooserWidgetLeaf(args...; kwargs...)
            w = GtkFileChooserWidget(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkFileChooserWidget] = GtkFileChooserWidgetLeaf
        function GtkFileChooserWidget(args...; kwargs...)
            GtkFileChooserWidgetLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkFileFilter <: GtkFilter end
        mutable struct GtkFileFilterLeaf <: GtkFileFilter
            handle::Ptr{GObject}
            function GtkFileFilterLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkFileFilterLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkFileFilterLeaf(args...; kwargs...)
            w = GtkFileFilter(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkFileFilter] = GtkFileFilterLeaf
        function GtkFileFilter(args...; kwargs...)
            GtkFileFilterLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkFilterListModel <: GObject end
        mutable struct GtkFilterListModelLeaf <: GtkFilterListModel
            handle::Ptr{GObject}
            function GtkFilterListModelLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkFilterListModelLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkFilterListModelLeaf(args...; kwargs...)
            w = GtkFilterListModel(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkFilterListModel] = GtkFilterListModelLeaf
        function GtkFilterListModel(args...; kwargs...)
            GtkFilterListModelLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkFixed <: GtkWidget end
        mutable struct GtkFixedLeaf <: GtkFixed
            handle::Ptr{GObject}
            function GtkFixedLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkFixedLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkFixedLeaf(args...; kwargs...)
            w = GtkFixed(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkFixed] = GtkFixedLeaf
        function GtkFixed(args...; kwargs...)
            GtkFixedLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkFixedLayout <: GtkLayoutManager end
        mutable struct GtkFixedLayoutLeaf <: GtkFixedLayout
            handle::Ptr{GObject}
            function GtkFixedLayoutLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkFixedLayoutLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkFixedLayoutLeaf(args...; kwargs...)
            w = GtkFixedLayout(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkFixedLayout] = GtkFixedLayoutLeaf
        function GtkFixedLayout(args...; kwargs...)
            GtkFixedLayoutLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkFixedLayoutChild <: GtkLayoutChild end
        mutable struct GtkFixedLayoutChildLeaf <: GtkFixedLayoutChild
            handle::Ptr{GObject}
            function GtkFixedLayoutChildLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkFixedLayoutChildLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkFixedLayoutChildLeaf(args...; kwargs...)
            w = GtkFixedLayoutChild(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkFixedLayoutChild] = GtkFixedLayoutChildLeaf
        function GtkFixedLayoutChild(args...; kwargs...)
            GtkFixedLayoutChildLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkFlattenListModel <: GObject end
        mutable struct GtkFlattenListModelLeaf <: GtkFlattenListModel
            handle::Ptr{GObject}
            function GtkFlattenListModelLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkFlattenListModelLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkFlattenListModelLeaf(args...; kwargs...)
            w = GtkFlattenListModel(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkFlattenListModel] = GtkFlattenListModelLeaf
        function GtkFlattenListModel(args...; kwargs...)
            GtkFlattenListModelLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkFlowBox <: GtkWidget end
        mutable struct GtkFlowBoxLeaf <: GtkFlowBox
            handle::Ptr{GObject}
            function GtkFlowBoxLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkFlowBoxLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkFlowBoxLeaf(args...; kwargs...)
            w = GtkFlowBox(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkFlowBox] = GtkFlowBoxLeaf
        function GtkFlowBox(args...; kwargs...)
            GtkFlowBoxLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkFlowBoxChild <: GtkWidget end
        mutable struct GtkFlowBoxChildLeaf <: GtkFlowBoxChild
            handle::Ptr{GObject}
            function GtkFlowBoxChildLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkFlowBoxChildLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkFlowBoxChildLeaf(args...; kwargs...)
            w = GtkFlowBoxChild(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkFlowBoxChild] = GtkFlowBoxChildLeaf
        function GtkFlowBoxChild(args...; kwargs...)
            GtkFlowBoxChildLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkFontButton <: GtkWidget end
        mutable struct GtkFontButtonLeaf <: GtkFontButton
            handle::Ptr{GObject}
            function GtkFontButtonLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkFontButtonLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkFontButtonLeaf(args...; kwargs...)
            w = GtkFontButton(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkFontButton] = GtkFontButtonLeaf
        function GtkFontButton(args...; kwargs...)
            GtkFontButtonLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkFontChooserDialog <: GtkDialog end
        mutable struct GtkFontChooserDialogLeaf <: GtkFontChooserDialog
            handle::Ptr{GObject}
            function GtkFontChooserDialogLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkFontChooserDialogLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkFontChooserDialogLeaf(args...; kwargs...)
            w = GtkFontChooserDialog(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkFontChooserDialog] = GtkFontChooserDialogLeaf
        function GtkFontChooserDialog(args...; kwargs...)
            GtkFontChooserDialogLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkFontChooserWidget <: GtkWidget end
        mutable struct GtkFontChooserWidgetLeaf <: GtkFontChooserWidget
            handle::Ptr{GObject}
            function GtkFontChooserWidgetLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkFontChooserWidgetLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkFontChooserWidgetLeaf(args...; kwargs...)
            w = GtkFontChooserWidget(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkFontChooserWidget] = GtkFontChooserWidgetLeaf
        function GtkFontChooserWidget(args...; kwargs...)
            GtkFontChooserWidgetLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkFrame <: GtkWidget end
        mutable struct GtkFrameLeaf <: GtkFrame
            handle::Ptr{GObject}
            function GtkFrameLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkFrameLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkFrameLeaf(args...; kwargs...)
            w = GtkFrame(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkFrame] = GtkFrameLeaf
        function GtkFrame(args...; kwargs...)
            GtkFrameLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkGLArea <: GtkWidget end
        mutable struct GtkGLAreaLeaf <: GtkGLArea
            handle::Ptr{GObject}
            function GtkGLAreaLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkGLAreaLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkGLAreaLeaf(args...; kwargs...)
            w = GtkGLArea(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkGLArea] = GtkGLAreaLeaf
        function GtkGLArea(args...; kwargs...)
            GtkGLAreaLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkGestureClick <: GtkGestureSingle end
        mutable struct GtkGestureClickLeaf <: GtkGestureClick
            handle::Ptr{GObject}
            function GtkGestureClickLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkGestureClickLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkGestureClickLeaf(args...; kwargs...)
            w = GtkGestureClick(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkGestureClick] = GtkGestureClickLeaf
        function GtkGestureClick(args...; kwargs...)
            GtkGestureClickLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkGestureDrag <: GtkGestureSingle end
        mutable struct GtkGestureDragLeaf <: GtkGestureDrag
            handle::Ptr{GObject}
            function GtkGestureDragLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkGestureDragLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkGestureDragLeaf(args...; kwargs...)
            w = GtkGestureDrag(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkGestureDrag] = GtkGestureDragLeaf
        function GtkGestureDrag(args...; kwargs...)
            GtkGestureDragLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkGestureLongPress <: GtkGestureSingle end
        mutable struct GtkGestureLongPressLeaf <: GtkGestureLongPress
            handle::Ptr{GObject}
            function GtkGestureLongPressLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkGestureLongPressLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkGestureLongPressLeaf(args...; kwargs...)
            w = GtkGestureLongPress(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkGestureLongPress] = GtkGestureLongPressLeaf
        function GtkGestureLongPress(args...; kwargs...)
            GtkGestureLongPressLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkGesturePan <: GtkGestureDrag end
        mutable struct GtkGesturePanLeaf <: GtkGesturePan
            handle::Ptr{GObject}
            function GtkGesturePanLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkGesturePanLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkGesturePanLeaf(args...; kwargs...)
            w = GtkGesturePan(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkGesturePan] = GtkGesturePanLeaf
        function GtkGesturePan(args...; kwargs...)
            GtkGesturePanLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkGestureRotate <: GtkGesture end
        mutable struct GtkGestureRotateLeaf <: GtkGestureRotate
            handle::Ptr{GObject}
            function GtkGestureRotateLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkGestureRotateLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkGestureRotateLeaf(args...; kwargs...)
            w = GtkGestureRotate(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkGestureRotate] = GtkGestureRotateLeaf
        function GtkGestureRotate(args...; kwargs...)
            GtkGestureRotateLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkGestureStylus <: GtkGestureSingle end
        mutable struct GtkGestureStylusLeaf <: GtkGestureStylus
            handle::Ptr{GObject}
            function GtkGestureStylusLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkGestureStylusLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkGestureStylusLeaf(args...; kwargs...)
            w = GtkGestureStylus(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkGestureStylus] = GtkGestureStylusLeaf
        function GtkGestureStylus(args...; kwargs...)
            GtkGestureStylusLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkGestureSwipe <: GtkGestureSingle end
        mutable struct GtkGestureSwipeLeaf <: GtkGestureSwipe
            handle::Ptr{GObject}
            function GtkGestureSwipeLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkGestureSwipeLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkGestureSwipeLeaf(args...; kwargs...)
            w = GtkGestureSwipe(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkGestureSwipe] = GtkGestureSwipeLeaf
        function GtkGestureSwipe(args...; kwargs...)
            GtkGestureSwipeLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkGestureZoom <: GtkGesture end
        mutable struct GtkGestureZoomLeaf <: GtkGestureZoom
            handle::Ptr{GObject}
            function GtkGestureZoomLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkGestureZoomLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkGestureZoomLeaf(args...; kwargs...)
            w = GtkGestureZoom(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkGestureZoom] = GtkGestureZoomLeaf
        function GtkGestureZoom(args...; kwargs...)
            GtkGestureZoomLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkGrid <: GtkWidget end
        mutable struct GtkGridLeaf <: GtkGrid
            handle::Ptr{GObject}
            function GtkGridLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkGridLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkGridLeaf(args...; kwargs...)
            w = GtkGrid(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkGrid] = GtkGridLeaf
        function GtkGrid(args...; kwargs...)
            GtkGridLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkGridLayout <: GtkLayoutManager end
        mutable struct GtkGridLayoutLeaf <: GtkGridLayout
            handle::Ptr{GObject}
            function GtkGridLayoutLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkGridLayoutLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkGridLayoutLeaf(args...; kwargs...)
            w = GtkGridLayout(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkGridLayout] = GtkGridLayoutLeaf
        function GtkGridLayout(args...; kwargs...)
            GtkGridLayoutLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkGridLayoutChild <: GtkLayoutChild end
        mutable struct GtkGridLayoutChildLeaf <: GtkGridLayoutChild
            handle::Ptr{GObject}
            function GtkGridLayoutChildLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkGridLayoutChildLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkGridLayoutChildLeaf(args...; kwargs...)
            w = GtkGridLayoutChild(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkGridLayoutChild] = GtkGridLayoutChildLeaf
        function GtkGridLayoutChild(args...; kwargs...)
            GtkGridLayoutChildLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkListBase <: GtkWidget end
        mutable struct GtkListBaseLeaf <: GtkListBase
            handle::Ptr{GObject}
            function GtkListBaseLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkListBaseLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkListBaseLeaf(args...; kwargs...)
            w = GtkListBase(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkListBase] = GtkListBaseLeaf
        function GtkListBase(args...; kwargs...)
            GtkListBaseLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkGridView <: GtkListBase end
        mutable struct GtkGridViewLeaf <: GtkGridView
            handle::Ptr{GObject}
            function GtkGridViewLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkGridViewLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkGridViewLeaf(args...; kwargs...)
            w = GtkGridView(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkGridView] = GtkGridViewLeaf
        function GtkGridView(args...; kwargs...)
            GtkGridViewLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkHeaderBar <: GtkWidget end
        mutable struct GtkHeaderBarLeaf <: GtkHeaderBar
            handle::Ptr{GObject}
            function GtkHeaderBarLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkHeaderBarLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkHeaderBarLeaf(args...; kwargs...)
            w = GtkHeaderBar(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkHeaderBar] = GtkHeaderBarLeaf
        function GtkHeaderBar(args...; kwargs...)
            GtkHeaderBarLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkIMContext <: GObject end
        mutable struct GtkIMContextLeaf <: GtkIMContext
            handle::Ptr{GObject}
            function GtkIMContextLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkIMContextLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkIMContextLeaf(args...; kwargs...)
            w = GtkIMContext(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkIMContext] = GtkIMContextLeaf
        function GtkIMContext(args...; kwargs...)
            GtkIMContextLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkIMContextSimple <: GtkIMContext end
        mutable struct GtkIMContextSimpleLeaf <: GtkIMContextSimple
            handle::Ptr{GObject}
            function GtkIMContextSimpleLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkIMContextSimpleLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkIMContextSimpleLeaf(args...; kwargs...)
            w = GtkIMContextSimple(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkIMContextSimple] = GtkIMContextSimpleLeaf
        function GtkIMContextSimple(args...; kwargs...)
            GtkIMContextSimpleLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkIMMulticontext <: GtkIMContext end
        mutable struct GtkIMMulticontextLeaf <: GtkIMMulticontext
            handle::Ptr{GObject}
            function GtkIMMulticontextLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkIMMulticontextLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkIMMulticontextLeaf(args...; kwargs...)
            w = GtkIMMulticontext(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkIMMulticontext] = GtkIMMulticontextLeaf
        function GtkIMMulticontext(args...; kwargs...)
            GtkIMMulticontextLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkIconPaintable <: GObject end
        mutable struct GtkIconPaintableLeaf <: GtkIconPaintable
            handle::Ptr{GObject}
            function GtkIconPaintableLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkIconPaintableLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkIconPaintableLeaf(args...; kwargs...)
            w = GtkIconPaintable(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkIconPaintable] = GtkIconPaintableLeaf
        function GtkIconPaintable(args...; kwargs...)
            GtkIconPaintableLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkIconTheme <: GObject end
        mutable struct GtkIconThemeLeaf <: GtkIconTheme
            handle::Ptr{GObject}
            function GtkIconThemeLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkIconThemeLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkIconThemeLeaf(args...; kwargs...)
            w = GtkIconTheme(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkIconTheme] = GtkIconThemeLeaf
        function GtkIconTheme(args...; kwargs...)
            GtkIconThemeLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkIconView <: GtkWidget end
        mutable struct GtkIconViewLeaf <: GtkIconView
            handle::Ptr{GObject}
            function GtkIconViewLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkIconViewLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkIconViewLeaf(args...; kwargs...)
            w = GtkIconView(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkIconView] = GtkIconViewLeaf
        function GtkIconView(args...; kwargs...)
            GtkIconViewLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkImage <: GtkWidget end
        mutable struct GtkImageLeaf <: GtkImage
            handle::Ptr{GObject}
            function GtkImageLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkImageLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkImageLeaf(args...; kwargs...)
            w = GtkImage(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkImage] = GtkImageLeaf
        function GtkImage(args...; kwargs...)
            GtkImageLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkInfoBar <: GtkWidget end
        mutable struct GtkInfoBarLeaf <: GtkInfoBar
            handle::Ptr{GObject}
            function GtkInfoBarLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkInfoBarLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkInfoBarLeaf(args...; kwargs...)
            w = GtkInfoBar(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkInfoBar] = GtkInfoBarLeaf
        function GtkInfoBar(args...; kwargs...)
            GtkInfoBarLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkInscription <: GtkWidget end
        mutable struct GtkInscriptionLeaf <: GtkInscription
            handle::Ptr{GObject}
            function GtkInscriptionLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkInscriptionLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkInscriptionLeaf(args...; kwargs...)
            w = GtkInscription(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkInscription] = GtkInscriptionLeaf
        function GtkInscription(args...; kwargs...)
            GtkInscriptionLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkKeyvalTrigger <: GtkShortcutTrigger end
        mutable struct GtkKeyvalTriggerLeaf <: GtkKeyvalTrigger
            handle::Ptr{GObject}
            function GtkKeyvalTriggerLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkKeyvalTriggerLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkKeyvalTriggerLeaf(args...; kwargs...)
            w = GtkKeyvalTrigger(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkKeyvalTrigger] = GtkKeyvalTriggerLeaf
        function GtkKeyvalTrigger(args...; kwargs...)
            GtkKeyvalTriggerLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkLabel <: GtkWidget end
        mutable struct GtkLabelLeaf <: GtkLabel
            handle::Ptr{GObject}
            function GtkLabelLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkLabelLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkLabelLeaf(args...; kwargs...)
            w = GtkLabel(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkLabel] = GtkLabelLeaf
        function GtkLabel(args...; kwargs...)
            GtkLabelLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkLevelBar <: GtkWidget end
        mutable struct GtkLevelBarLeaf <: GtkLevelBar
            handle::Ptr{GObject}
            function GtkLevelBarLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkLevelBarLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkLevelBarLeaf(args...; kwargs...)
            w = GtkLevelBar(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkLevelBar] = GtkLevelBarLeaf
        function GtkLevelBar(args...; kwargs...)
            GtkLevelBarLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkLinkButton <: GtkButton end
        mutable struct GtkLinkButtonLeaf <: GtkLinkButton
            handle::Ptr{GObject}
            function GtkLinkButtonLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkLinkButtonLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkLinkButtonLeaf(args...; kwargs...)
            w = GtkLinkButton(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkLinkButton] = GtkLinkButtonLeaf
        function GtkLinkButton(args...; kwargs...)
            GtkLinkButtonLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkListBox <: GtkWidget end
        mutable struct GtkListBoxLeaf <: GtkListBox
            handle::Ptr{GObject}
            function GtkListBoxLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkListBoxLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkListBoxLeaf(args...; kwargs...)
            w = GtkListBox(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkListBox] = GtkListBoxLeaf
        function GtkListBox(args...; kwargs...)
            GtkListBoxLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkListBoxRow <: GtkWidget end
        mutable struct GtkListBoxRowLeaf <: GtkListBoxRow
            handle::Ptr{GObject}
            function GtkListBoxRowLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkListBoxRowLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkListBoxRowLeaf(args...; kwargs...)
            w = GtkListBoxRow(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkListBoxRow] = GtkListBoxRowLeaf
        function GtkListBoxRow(args...; kwargs...)
            GtkListBoxRowLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkListItem <: GObject end
        mutable struct GtkListItemLeaf <: GtkListItem
            handle::Ptr{GObject}
            function GtkListItemLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkListItemLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkListItemLeaf(args...; kwargs...)
            w = GtkListItem(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkListItem] = GtkListItemLeaf
        function GtkListItem(args...; kwargs...)
            GtkListItemLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkListStore <: GObject end
        mutable struct GtkListStoreLeaf <: GtkListStore
            handle::Ptr{GObject}
            function GtkListStoreLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkListStoreLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkListStoreLeaf(args...; kwargs...)
            w = GtkListStore(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkListStore] = GtkListStoreLeaf
        function GtkListStore(args...; kwargs...)
            GtkListStoreLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkListView <: GtkListBase end
        mutable struct GtkListViewLeaf <: GtkListView
            handle::Ptr{GObject}
            function GtkListViewLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkListViewLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkListViewLeaf(args...; kwargs...)
            w = GtkListView(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkListView] = GtkListViewLeaf
        function GtkListView(args...; kwargs...)
            GtkListViewLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkLockButton <: GtkButton end
        mutable struct GtkLockButtonLeaf <: GtkLockButton
            handle::Ptr{GObject}
            function GtkLockButtonLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkLockButtonLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkLockButtonLeaf(args...; kwargs...)
            w = GtkLockButton(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkLockButton] = GtkLockButtonLeaf
        function GtkLockButton(args...; kwargs...)
            GtkLockButtonLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkMapListModel <: GObject end
        mutable struct GtkMapListModelLeaf <: GtkMapListModel
            handle::Ptr{GObject}
            function GtkMapListModelLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkMapListModelLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkMapListModelLeaf(args...; kwargs...)
            w = GtkMapListModel(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkMapListModel] = GtkMapListModelLeaf
        function GtkMapListModel(args...; kwargs...)
            GtkMapListModelLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkMediaControls <: GtkWidget end
        mutable struct GtkMediaControlsLeaf <: GtkMediaControls
            handle::Ptr{GObject}
            function GtkMediaControlsLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkMediaControlsLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkMediaControlsLeaf(args...; kwargs...)
            w = GtkMediaControls(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkMediaControls] = GtkMediaControlsLeaf
        function GtkMediaControls(args...; kwargs...)
            GtkMediaControlsLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkMediaStream <: GObject end
        mutable struct GtkMediaStreamLeaf <: GtkMediaStream
            handle::Ptr{GObject}
            function GtkMediaStreamLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkMediaStreamLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkMediaStreamLeaf(args...; kwargs...)
            w = GtkMediaStream(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkMediaStream] = GtkMediaStreamLeaf
        function GtkMediaStream(args...; kwargs...)
            GtkMediaStreamLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkMediaFile <: GtkMediaStream end
        mutable struct GtkMediaFileLeaf <: GtkMediaFile
            handle::Ptr{GObject}
            function GtkMediaFileLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkMediaFileLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkMediaFileLeaf(args...; kwargs...)
            w = GtkMediaFile(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkMediaFile] = GtkMediaFileLeaf
        function GtkMediaFile(args...; kwargs...)
            GtkMediaFileLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkMenuButton <: GtkWidget end
        mutable struct GtkMenuButtonLeaf <: GtkMenuButton
            handle::Ptr{GObject}
            function GtkMenuButtonLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkMenuButtonLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkMenuButtonLeaf(args...; kwargs...)
            w = GtkMenuButton(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkMenuButton] = GtkMenuButtonLeaf
        function GtkMenuButton(args...; kwargs...)
            GtkMenuButtonLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkMessageDialog <: GtkDialog end
        mutable struct GtkMessageDialogLeaf <: GtkMessageDialog
            handle::Ptr{GObject}
            function GtkMessageDialogLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkMessageDialogLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkMessageDialogLeaf(args...; kwargs...)
            w = GtkMessageDialog(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkMessageDialog] = GtkMessageDialogLeaf
        function GtkMessageDialog(args...; kwargs...)
            GtkMessageDialogLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkMnemonicAction <: GtkShortcutAction end
        mutable struct GtkMnemonicActionLeaf <: GtkMnemonicAction
            handle::Ptr{GObject}
            function GtkMnemonicActionLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkMnemonicActionLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkMnemonicActionLeaf(args...; kwargs...)
            w = GtkMnemonicAction(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkMnemonicAction] = GtkMnemonicActionLeaf
        function GtkMnemonicAction(args...; kwargs...)
            GtkMnemonicActionLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkMnemonicTrigger <: GtkShortcutTrigger end
        mutable struct GtkMnemonicTriggerLeaf <: GtkMnemonicTrigger
            handle::Ptr{GObject}
            function GtkMnemonicTriggerLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkMnemonicTriggerLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkMnemonicTriggerLeaf(args...; kwargs...)
            w = GtkMnemonicTrigger(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkMnemonicTrigger] = GtkMnemonicTriggerLeaf
        function GtkMnemonicTrigger(args...; kwargs...)
            GtkMnemonicTriggerLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkMountOperation <: GMountOperation end
        mutable struct GtkMountOperationLeaf <: GtkMountOperation
            handle::Ptr{GObject}
            function GtkMountOperationLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkMountOperationLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkMountOperationLeaf(args...; kwargs...)
            w = GtkMountOperation(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkMountOperation] = GtkMountOperationLeaf
        function GtkMountOperation(args...; kwargs...)
            GtkMountOperationLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkMultiSelection <: GObject end
        mutable struct GtkMultiSelectionLeaf <: GtkMultiSelection
            handle::Ptr{GObject}
            function GtkMultiSelectionLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkMultiSelectionLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkMultiSelectionLeaf(args...; kwargs...)
            w = GtkMultiSelection(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkMultiSelection] = GtkMultiSelectionLeaf
        function GtkMultiSelection(args...; kwargs...)
            GtkMultiSelectionLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkMultiSorter <: GtkSorter end
        mutable struct GtkMultiSorterLeaf <: GtkMultiSorter
            handle::Ptr{GObject}
            function GtkMultiSorterLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkMultiSorterLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkMultiSorterLeaf(args...; kwargs...)
            w = GtkMultiSorter(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkMultiSorter] = GtkMultiSorterLeaf
        function GtkMultiSorter(args...; kwargs...)
            GtkMultiSorterLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkNamedAction <: GtkShortcutAction end
        mutable struct GtkNamedActionLeaf <: GtkNamedAction
            handle::Ptr{GObject}
            function GtkNamedActionLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkNamedActionLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkNamedActionLeaf(args...; kwargs...)
            w = GtkNamedAction(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkNamedAction] = GtkNamedActionLeaf
        function GtkNamedAction(args...; kwargs...)
            GtkNamedActionLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkNeverTrigger <: GtkShortcutTrigger end
        mutable struct GtkNeverTriggerLeaf <: GtkNeverTrigger
            handle::Ptr{GObject}
            function GtkNeverTriggerLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkNeverTriggerLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkNeverTriggerLeaf(args...; kwargs...)
            w = GtkNeverTrigger(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkNeverTrigger] = GtkNeverTriggerLeaf
        function GtkNeverTrigger(args...; kwargs...)
            GtkNeverTriggerLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkNoSelection <: GObject end
        mutable struct GtkNoSelectionLeaf <: GtkNoSelection
            handle::Ptr{GObject}
            function GtkNoSelectionLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkNoSelectionLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkNoSelectionLeaf(args...; kwargs...)
            w = GtkNoSelection(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkNoSelection] = GtkNoSelectionLeaf
        function GtkNoSelection(args...; kwargs...)
            GtkNoSelectionLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkNotebook <: GtkWidget end
        mutable struct GtkNotebookLeaf <: GtkNotebook
            handle::Ptr{GObject}
            function GtkNotebookLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkNotebookLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkNotebookLeaf(args...; kwargs...)
            w = GtkNotebook(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkNotebook] = GtkNotebookLeaf
        function GtkNotebook(args...; kwargs...)
            GtkNotebookLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkNotebookPage <: GObject end
        mutable struct GtkNotebookPageLeaf <: GtkNotebookPage
            handle::Ptr{GObject}
            function GtkNotebookPageLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkNotebookPageLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkNotebookPageLeaf(args...; kwargs...)
            w = GtkNotebookPage(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkNotebookPage] = GtkNotebookPageLeaf
        function GtkNotebookPage(args...; kwargs...)
            GtkNotebookPageLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkNothingAction <: GtkShortcutAction end
        mutable struct GtkNothingActionLeaf <: GtkNothingAction
            handle::Ptr{GObject}
            function GtkNothingActionLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkNothingActionLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkNothingActionLeaf(args...; kwargs...)
            w = GtkNothingAction(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkNothingAction] = GtkNothingActionLeaf
        function GtkNothingAction(args...; kwargs...)
            GtkNothingActionLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkNumericSorter <: GtkSorter end
        mutable struct GtkNumericSorterLeaf <: GtkNumericSorter
            handle::Ptr{GObject}
            function GtkNumericSorterLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkNumericSorterLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkNumericSorterLeaf(args...; kwargs...)
            w = GtkNumericSorter(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkNumericSorter] = GtkNumericSorterLeaf
        function GtkNumericSorter(args...; kwargs...)
            GtkNumericSorterLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkOverlay <: GtkWidget end
        mutable struct GtkOverlayLeaf <: GtkOverlay
            handle::Ptr{GObject}
            function GtkOverlayLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkOverlayLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkOverlayLeaf(args...; kwargs...)
            w = GtkOverlay(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkOverlay] = GtkOverlayLeaf
        function GtkOverlay(args...; kwargs...)
            GtkOverlayLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkOverlayLayout <: GtkLayoutManager end
        mutable struct GtkOverlayLayoutLeaf <: GtkOverlayLayout
            handle::Ptr{GObject}
            function GtkOverlayLayoutLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkOverlayLayoutLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkOverlayLayoutLeaf(args...; kwargs...)
            w = GtkOverlayLayout(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkOverlayLayout] = GtkOverlayLayoutLeaf
        function GtkOverlayLayout(args...; kwargs...)
            GtkOverlayLayoutLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkOverlayLayoutChild <: GtkLayoutChild end
        mutable struct GtkOverlayLayoutChildLeaf <: GtkOverlayLayoutChild
            handle::Ptr{GObject}
            function GtkOverlayLayoutChildLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkOverlayLayoutChildLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkOverlayLayoutChildLeaf(args...; kwargs...)
            w = GtkOverlayLayoutChild(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkOverlayLayoutChild] = GtkOverlayLayoutChildLeaf
        function GtkOverlayLayoutChild(args...; kwargs...)
            GtkOverlayLayoutChildLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkPadController <: GtkEventController end
        mutable struct GtkPadControllerLeaf <: GtkPadController
            handle::Ptr{GObject}
            function GtkPadControllerLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkPadControllerLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkPadControllerLeaf(args...; kwargs...)
            w = GtkPadController(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkPadController] = GtkPadControllerLeaf
        function GtkPadController(args...; kwargs...)
            GtkPadControllerLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkPageSetup <: GObject end
        mutable struct GtkPageSetupLeaf <: GtkPageSetup
            handle::Ptr{GObject}
            function GtkPageSetupLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkPageSetupLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkPageSetupLeaf(args...; kwargs...)
            w = GtkPageSetup(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkPageSetup] = GtkPageSetupLeaf
        function GtkPageSetup(args...; kwargs...)
            GtkPageSetupLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkPaned <: GtkWidget end
        mutable struct GtkPanedLeaf <: GtkPaned
            handle::Ptr{GObject}
            function GtkPanedLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkPanedLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkPanedLeaf(args...; kwargs...)
            w = GtkPaned(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkPaned] = GtkPanedLeaf
        function GtkPaned(args...; kwargs...)
            GtkPanedLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkPasswordEntry <: GtkWidget end
        mutable struct GtkPasswordEntryLeaf <: GtkPasswordEntry
            handle::Ptr{GObject}
            function GtkPasswordEntryLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkPasswordEntryLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkPasswordEntryLeaf(args...; kwargs...)
            w = GtkPasswordEntry(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkPasswordEntry] = GtkPasswordEntryLeaf
        function GtkPasswordEntry(args...; kwargs...)
            GtkPasswordEntryLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkPasswordEntryBuffer <: GtkEntryBuffer end
        mutable struct GtkPasswordEntryBufferLeaf <: GtkPasswordEntryBuffer
            handle::Ptr{GObject}
            function GtkPasswordEntryBufferLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkPasswordEntryBufferLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkPasswordEntryBufferLeaf(args...; kwargs...)
            w = GtkPasswordEntryBuffer(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkPasswordEntryBuffer] = GtkPasswordEntryBufferLeaf
        function GtkPasswordEntryBuffer(args...; kwargs...)
            GtkPasswordEntryBufferLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkPicture <: GtkWidget end
        mutable struct GtkPictureLeaf <: GtkPicture
            handle::Ptr{GObject}
            function GtkPictureLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkPictureLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkPictureLeaf(args...; kwargs...)
            w = GtkPicture(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkPicture] = GtkPictureLeaf
        function GtkPicture(args...; kwargs...)
            GtkPictureLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkPopoverMenu <: GtkPopover end
        mutable struct GtkPopoverMenuLeaf <: GtkPopoverMenu
            handle::Ptr{GObject}
            function GtkPopoverMenuLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkPopoverMenuLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkPopoverMenuLeaf(args...; kwargs...)
            w = GtkPopoverMenu(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkPopoverMenu] = GtkPopoverMenuLeaf
        function GtkPopoverMenu(args...; kwargs...)
            GtkPopoverMenuLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkPopoverMenuBar <: GtkWidget end
        mutable struct GtkPopoverMenuBarLeaf <: GtkPopoverMenuBar
            handle::Ptr{GObject}
            function GtkPopoverMenuBarLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkPopoverMenuBarLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkPopoverMenuBarLeaf(args...; kwargs...)
            w = GtkPopoverMenuBar(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkPopoverMenuBar] = GtkPopoverMenuBarLeaf
        function GtkPopoverMenuBar(args...; kwargs...)
            GtkPopoverMenuBarLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkPrintContext <: GObject end
        mutable struct GtkPrintContextLeaf <: GtkPrintContext
            handle::Ptr{GObject}
            function GtkPrintContextLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkPrintContextLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkPrintContextLeaf(args...; kwargs...)
            w = GtkPrintContext(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkPrintContext] = GtkPrintContextLeaf
        function GtkPrintContext(args...; kwargs...)
            GtkPrintContextLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkPrintJob <: GObject end
        mutable struct GtkPrintJobLeaf <: GtkPrintJob
            handle::Ptr{GObject}
            function GtkPrintJobLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkPrintJobLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkPrintJobLeaf(args...; kwargs...)
            w = GtkPrintJob(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkPrintJob] = GtkPrintJobLeaf
        function GtkPrintJob(args...; kwargs...)
            GtkPrintJobLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkPrintOperation <: GObject end
        mutable struct GtkPrintOperationLeaf <: GtkPrintOperation
            handle::Ptr{GObject}
            function GtkPrintOperationLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkPrintOperationLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkPrintOperationLeaf(args...; kwargs...)
            w = GtkPrintOperation(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkPrintOperation] = GtkPrintOperationLeaf
        function GtkPrintOperation(args...; kwargs...)
            GtkPrintOperationLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkPrintSettings <: GObject end
        mutable struct GtkPrintSettingsLeaf <: GtkPrintSettings
            handle::Ptr{GObject}
            function GtkPrintSettingsLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkPrintSettingsLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkPrintSettingsLeaf(args...; kwargs...)
            w = GtkPrintSettings(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkPrintSettings] = GtkPrintSettingsLeaf
        function GtkPrintSettings(args...; kwargs...)
            GtkPrintSettingsLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkPrinter <: GObject end
        mutable struct GtkPrinterLeaf <: GtkPrinter
            handle::Ptr{GObject}
            function GtkPrinterLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkPrinterLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkPrinterLeaf(args...; kwargs...)
            w = GtkPrinter(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkPrinter] = GtkPrinterLeaf
        function GtkPrinter(args...; kwargs...)
            GtkPrinterLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkProgressBar <: GtkWidget end
        mutable struct GtkProgressBarLeaf <: GtkProgressBar
            handle::Ptr{GObject}
            function GtkProgressBarLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkProgressBarLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkProgressBarLeaf(args...; kwargs...)
            w = GtkProgressBar(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkProgressBar] = GtkProgressBarLeaf
        function GtkProgressBar(args...; kwargs...)
            GtkProgressBarLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkRange <: GtkWidget end
        mutable struct GtkRangeLeaf <: GtkRange
            handle::Ptr{GObject}
            function GtkRangeLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkRangeLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkRangeLeaf(args...; kwargs...)
            w = GtkRange(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkRange] = GtkRangeLeaf
        function GtkRange(args...; kwargs...)
            GtkRangeLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkRecentManager <: GObject end
        mutable struct GtkRecentManagerLeaf <: GtkRecentManager
            handle::Ptr{GObject}
            function GtkRecentManagerLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkRecentManagerLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkRecentManagerLeaf(args...; kwargs...)
            w = GtkRecentManager(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkRecentManager] = GtkRecentManagerLeaf
        function GtkRecentManager(args...; kwargs...)
            GtkRecentManagerLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkRevealer <: GtkWidget end
        mutable struct GtkRevealerLeaf <: GtkRevealer
            handle::Ptr{GObject}
            function GtkRevealerLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkRevealerLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkRevealerLeaf(args...; kwargs...)
            w = GtkRevealer(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkRevealer] = GtkRevealerLeaf
        function GtkRevealer(args...; kwargs...)
            GtkRevealerLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkScale <: GtkRange end
        mutable struct GtkScaleLeaf <: GtkScale
            handle::Ptr{GObject}
            function GtkScaleLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkScaleLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkScaleLeaf(args...; kwargs...)
            w = GtkScale(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkScale] = GtkScaleLeaf
        function GtkScale(args...; kwargs...)
            GtkScaleLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkScaleButton <: GtkWidget end
        mutable struct GtkScaleButtonLeaf <: GtkScaleButton
            handle::Ptr{GObject}
            function GtkScaleButtonLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkScaleButtonLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkScaleButtonLeaf(args...; kwargs...)
            w = GtkScaleButton(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkScaleButton] = GtkScaleButtonLeaf
        function GtkScaleButton(args...; kwargs...)
            GtkScaleButtonLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkScrollbar <: GtkWidget end
        mutable struct GtkScrollbarLeaf <: GtkScrollbar
            handle::Ptr{GObject}
            function GtkScrollbarLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkScrollbarLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkScrollbarLeaf(args...; kwargs...)
            w = GtkScrollbar(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkScrollbar] = GtkScrollbarLeaf
        function GtkScrollbar(args...; kwargs...)
            GtkScrollbarLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkScrolledWindow <: GtkWidget end
        mutable struct GtkScrolledWindowLeaf <: GtkScrolledWindow
            handle::Ptr{GObject}
            function GtkScrolledWindowLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkScrolledWindowLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkScrolledWindowLeaf(args...; kwargs...)
            w = GtkScrolledWindow(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkScrolledWindow] = GtkScrolledWindowLeaf
        function GtkScrolledWindow(args...; kwargs...)
            GtkScrolledWindowLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkSearchBar <: GtkWidget end
        mutable struct GtkSearchBarLeaf <: GtkSearchBar
            handle::Ptr{GObject}
            function GtkSearchBarLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkSearchBarLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkSearchBarLeaf(args...; kwargs...)
            w = GtkSearchBar(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkSearchBar] = GtkSearchBarLeaf
        function GtkSearchBar(args...; kwargs...)
            GtkSearchBarLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkSearchEntry <: GtkWidget end
        mutable struct GtkSearchEntryLeaf <: GtkSearchEntry
            handle::Ptr{GObject}
            function GtkSearchEntryLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkSearchEntryLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkSearchEntryLeaf(args...; kwargs...)
            w = GtkSearchEntry(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkSearchEntry] = GtkSearchEntryLeaf
        function GtkSearchEntry(args...; kwargs...)
            GtkSearchEntryLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkSelectionFilterModel <: GObject end
        mutable struct GtkSelectionFilterModelLeaf <: GtkSelectionFilterModel
            handle::Ptr{GObject}
            function GtkSelectionFilterModelLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkSelectionFilterModelLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkSelectionFilterModelLeaf(args...; kwargs...)
            w = GtkSelectionFilterModel(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkSelectionFilterModel] = GtkSelectionFilterModelLeaf
        function GtkSelectionFilterModel(args...; kwargs...)
            GtkSelectionFilterModelLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkSeparator <: GtkWidget end
        mutable struct GtkSeparatorLeaf <: GtkSeparator
            handle::Ptr{GObject}
            function GtkSeparatorLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkSeparatorLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkSeparatorLeaf(args...; kwargs...)
            w = GtkSeparator(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkSeparator] = GtkSeparatorLeaf
        function GtkSeparator(args...; kwargs...)
            GtkSeparatorLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkSettings <: GObject end
        mutable struct GtkSettingsLeaf <: GtkSettings
            handle::Ptr{GObject}
            function GtkSettingsLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkSettingsLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkSettingsLeaf(args...; kwargs...)
            w = GtkSettings(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkSettings] = GtkSettingsLeaf
        function GtkSettings(args...; kwargs...)
            GtkSettingsLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkShortcut <: GObject end
        mutable struct GtkShortcutLeaf <: GtkShortcut
            handle::Ptr{GObject}
            function GtkShortcutLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkShortcutLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkShortcutLeaf(args...; kwargs...)
            w = GtkShortcut(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkShortcut] = GtkShortcutLeaf
        function GtkShortcut(args...; kwargs...)
            GtkShortcutLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkShortcutController <: GtkEventController end
        mutable struct GtkShortcutControllerLeaf <: GtkShortcutController
            handle::Ptr{GObject}
            function GtkShortcutControllerLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkShortcutControllerLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkShortcutControllerLeaf(args...; kwargs...)
            w = GtkShortcutController(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkShortcutController] = GtkShortcutControllerLeaf
        function GtkShortcutController(args...; kwargs...)
            GtkShortcutControllerLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkShortcutLabel <: GtkWidget end
        mutable struct GtkShortcutLabelLeaf <: GtkShortcutLabel
            handle::Ptr{GObject}
            function GtkShortcutLabelLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkShortcutLabelLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkShortcutLabelLeaf(args...; kwargs...)
            w = GtkShortcutLabel(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkShortcutLabel] = GtkShortcutLabelLeaf
        function GtkShortcutLabel(args...; kwargs...)
            GtkShortcutLabelLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkShortcutsGroup <: GtkBox end
        mutable struct GtkShortcutsGroupLeaf <: GtkShortcutsGroup
            handle::Ptr{GObject}
            function GtkShortcutsGroupLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkShortcutsGroupLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkShortcutsGroupLeaf(args...; kwargs...)
            w = GtkShortcutsGroup(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkShortcutsGroup] = GtkShortcutsGroupLeaf
        function GtkShortcutsGroup(args...; kwargs...)
            GtkShortcutsGroupLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkShortcutsSection <: GtkBox end
        mutable struct GtkShortcutsSectionLeaf <: GtkShortcutsSection
            handle::Ptr{GObject}
            function GtkShortcutsSectionLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkShortcutsSectionLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkShortcutsSectionLeaf(args...; kwargs...)
            w = GtkShortcutsSection(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkShortcutsSection] = GtkShortcutsSectionLeaf
        function GtkShortcutsSection(args...; kwargs...)
            GtkShortcutsSectionLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkShortcutsShortcut <: GtkWidget end
        mutable struct GtkShortcutsShortcutLeaf <: GtkShortcutsShortcut
            handle::Ptr{GObject}
            function GtkShortcutsShortcutLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkShortcutsShortcutLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkShortcutsShortcutLeaf(args...; kwargs...)
            w = GtkShortcutsShortcut(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkShortcutsShortcut] = GtkShortcutsShortcutLeaf
        function GtkShortcutsShortcut(args...; kwargs...)
            GtkShortcutsShortcutLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkShortcutsWindow <: GtkWindow end
        mutable struct GtkShortcutsWindowLeaf <: GtkShortcutsWindow
            handle::Ptr{GObject}
            function GtkShortcutsWindowLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkShortcutsWindowLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkShortcutsWindowLeaf(args...; kwargs...)
            w = GtkShortcutsWindow(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkShortcutsWindow] = GtkShortcutsWindowLeaf
        function GtkShortcutsWindow(args...; kwargs...)
            GtkShortcutsWindowLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkSignalAction <: GtkShortcutAction end
        mutable struct GtkSignalActionLeaf <: GtkSignalAction
            handle::Ptr{GObject}
            function GtkSignalActionLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkSignalActionLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkSignalActionLeaf(args...; kwargs...)
            w = GtkSignalAction(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkSignalAction] = GtkSignalActionLeaf
        function GtkSignalAction(args...; kwargs...)
            GtkSignalActionLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkSignalListItemFactory <: GtkListItemFactory end
        mutable struct GtkSignalListItemFactoryLeaf <: GtkSignalListItemFactory
            handle::Ptr{GObject}
            function GtkSignalListItemFactoryLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkSignalListItemFactoryLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkSignalListItemFactoryLeaf(args...; kwargs...)
            w = GtkSignalListItemFactory(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkSignalListItemFactory] = GtkSignalListItemFactoryLeaf
        function GtkSignalListItemFactory(args...; kwargs...)
            GtkSignalListItemFactoryLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkSingleSelection <: GObject end
        mutable struct GtkSingleSelectionLeaf <: GtkSingleSelection
            handle::Ptr{GObject}
            function GtkSingleSelectionLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkSingleSelectionLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkSingleSelectionLeaf(args...; kwargs...)
            w = GtkSingleSelection(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkSingleSelection] = GtkSingleSelectionLeaf
        function GtkSingleSelection(args...; kwargs...)
            GtkSingleSelectionLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkSizeGroup <: GObject end
        mutable struct GtkSizeGroupLeaf <: GtkSizeGroup
            handle::Ptr{GObject}
            function GtkSizeGroupLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkSizeGroupLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkSizeGroupLeaf(args...; kwargs...)
            w = GtkSizeGroup(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkSizeGroup] = GtkSizeGroupLeaf
        function GtkSizeGroup(args...; kwargs...)
            GtkSizeGroupLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkSliceListModel <: GObject end
        mutable struct GtkSliceListModelLeaf <: GtkSliceListModel
            handle::Ptr{GObject}
            function GtkSliceListModelLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkSliceListModelLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkSliceListModelLeaf(args...; kwargs...)
            w = GtkSliceListModel(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkSliceListModel] = GtkSliceListModelLeaf
        function GtkSliceListModel(args...; kwargs...)
            GtkSliceListModelLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkSnapshot <: GdkSnapshot end
        mutable struct GtkSnapshotLeaf <: GtkSnapshot
            handle::Ptr{GObject}
            function GtkSnapshotLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkSnapshotLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkSnapshotLeaf(args...; kwargs...)
            w = GtkSnapshot(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkSnapshot] = GtkSnapshotLeaf
        function GtkSnapshot(args...; kwargs...)
            GtkSnapshotLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkSortListModel <: GObject end
        mutable struct GtkSortListModelLeaf <: GtkSortListModel
            handle::Ptr{GObject}
            function GtkSortListModelLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkSortListModelLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkSortListModelLeaf(args...; kwargs...)
            w = GtkSortListModel(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkSortListModel] = GtkSortListModelLeaf
        function GtkSortListModel(args...; kwargs...)
            GtkSortListModelLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkSpinButton <: GtkWidget end
        mutable struct GtkSpinButtonLeaf <: GtkSpinButton
            handle::Ptr{GObject}
            function GtkSpinButtonLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkSpinButtonLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkSpinButtonLeaf(args...; kwargs...)
            w = GtkSpinButton(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkSpinButton] = GtkSpinButtonLeaf
        function GtkSpinButton(args...; kwargs...)
            GtkSpinButtonLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkSpinner <: GtkWidget end
        mutable struct GtkSpinnerLeaf <: GtkSpinner
            handle::Ptr{GObject}
            function GtkSpinnerLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkSpinnerLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkSpinnerLeaf(args...; kwargs...)
            w = GtkSpinner(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkSpinner] = GtkSpinnerLeaf
        function GtkSpinner(args...; kwargs...)
            GtkSpinnerLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkStack <: GtkWidget end
        mutable struct GtkStackLeaf <: GtkStack
            handle::Ptr{GObject}
            function GtkStackLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkStackLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkStackLeaf(args...; kwargs...)
            w = GtkStack(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkStack] = GtkStackLeaf
        function GtkStack(args...; kwargs...)
            GtkStackLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkStackPage <: GObject end
        mutable struct GtkStackPageLeaf <: GtkStackPage
            handle::Ptr{GObject}
            function GtkStackPageLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkStackPageLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkStackPageLeaf(args...; kwargs...)
            w = GtkStackPage(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkStackPage] = GtkStackPageLeaf
        function GtkStackPage(args...; kwargs...)
            GtkStackPageLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkStackSidebar <: GtkWidget end
        mutable struct GtkStackSidebarLeaf <: GtkStackSidebar
            handle::Ptr{GObject}
            function GtkStackSidebarLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkStackSidebarLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkStackSidebarLeaf(args...; kwargs...)
            w = GtkStackSidebar(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkStackSidebar] = GtkStackSidebarLeaf
        function GtkStackSidebar(args...; kwargs...)
            GtkStackSidebarLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkStackSwitcher <: GtkWidget end
        mutable struct GtkStackSwitcherLeaf <: GtkStackSwitcher
            handle::Ptr{GObject}
            function GtkStackSwitcherLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkStackSwitcherLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkStackSwitcherLeaf(args...; kwargs...)
            w = GtkStackSwitcher(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkStackSwitcher] = GtkStackSwitcherLeaf
        function GtkStackSwitcher(args...; kwargs...)
            GtkStackSwitcherLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkStatusbar <: GtkWidget end
        mutable struct GtkStatusbarLeaf <: GtkStatusbar
            handle::Ptr{GObject}
            function GtkStatusbarLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkStatusbarLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkStatusbarLeaf(args...; kwargs...)
            w = GtkStatusbar(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkStatusbar] = GtkStatusbarLeaf
        function GtkStatusbar(args...; kwargs...)
            GtkStatusbarLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkStringFilter <: GtkFilter end
        mutable struct GtkStringFilterLeaf <: GtkStringFilter
            handle::Ptr{GObject}
            function GtkStringFilterLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkStringFilterLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkStringFilterLeaf(args...; kwargs...)
            w = GtkStringFilter(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkStringFilter] = GtkStringFilterLeaf
        function GtkStringFilter(args...; kwargs...)
            GtkStringFilterLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkStringList <: GObject end
        mutable struct GtkStringListLeaf <: GtkStringList
            handle::Ptr{GObject}
            function GtkStringListLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkStringListLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkStringListLeaf(args...; kwargs...)
            w = GtkStringList(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkStringList] = GtkStringListLeaf
        function GtkStringList(args...; kwargs...)
            GtkStringListLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkStringObject <: GObject end
        mutable struct GtkStringObjectLeaf <: GtkStringObject
            handle::Ptr{GObject}
            function GtkStringObjectLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkStringObjectLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkStringObjectLeaf(args...; kwargs...)
            w = GtkStringObject(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkStringObject] = GtkStringObjectLeaf
        function GtkStringObject(args...; kwargs...)
            GtkStringObjectLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkStringSorter <: GtkSorter end
        mutable struct GtkStringSorterLeaf <: GtkStringSorter
            handle::Ptr{GObject}
            function GtkStringSorterLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkStringSorterLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkStringSorterLeaf(args...; kwargs...)
            w = GtkStringSorter(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkStringSorter] = GtkStringSorterLeaf
        function GtkStringSorter(args...; kwargs...)
            GtkStringSorterLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkStyleContext <: GObject end
        mutable struct GtkStyleContextLeaf <: GtkStyleContext
            handle::Ptr{GObject}
            function GtkStyleContextLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkStyleContextLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkStyleContextLeaf(args...; kwargs...)
            w = GtkStyleContext(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkStyleContext] = GtkStyleContextLeaf
        function GtkStyleContext(args...; kwargs...)
            GtkStyleContextLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkSwitch <: GtkWidget end
        mutable struct GtkSwitchLeaf <: GtkSwitch
            handle::Ptr{GObject}
            function GtkSwitchLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkSwitchLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkSwitchLeaf(args...; kwargs...)
            w = GtkSwitch(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkSwitch] = GtkSwitchLeaf
        function GtkSwitch(args...; kwargs...)
            GtkSwitchLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkText <: GtkWidget end
        mutable struct GtkTextLeaf <: GtkText
            handle::Ptr{GObject}
            function GtkTextLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkTextLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkTextLeaf(args...; kwargs...)
            w = GtkText(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkText] = GtkTextLeaf
        function GtkText(args...; kwargs...)
            GtkTextLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkTextBuffer <: GObject end
        mutable struct GtkTextBufferLeaf <: GtkTextBuffer
            handle::Ptr{GObject}
            function GtkTextBufferLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkTextBufferLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkTextBufferLeaf(args...; kwargs...)
            w = GtkTextBuffer(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkTextBuffer] = GtkTextBufferLeaf
        function GtkTextBuffer(args...; kwargs...)
            GtkTextBufferLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkTextChildAnchor <: GObject end
        mutable struct GtkTextChildAnchorLeaf <: GtkTextChildAnchor
            handle::Ptr{GObject}
            function GtkTextChildAnchorLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkTextChildAnchorLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkTextChildAnchorLeaf(args...; kwargs...)
            w = GtkTextChildAnchor(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkTextChildAnchor] = GtkTextChildAnchorLeaf
        function GtkTextChildAnchor(args...; kwargs...)
            GtkTextChildAnchorLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkTextMark <: GObject end
        mutable struct GtkTextMarkLeaf <: GtkTextMark
            handle::Ptr{GObject}
            function GtkTextMarkLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkTextMarkLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkTextMarkLeaf(args...; kwargs...)
            w = GtkTextMark(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkTextMark] = GtkTextMarkLeaf
        function GtkTextMark(args...; kwargs...)
            GtkTextMarkLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkTextTag <: GObject end
        mutable struct GtkTextTagLeaf <: GtkTextTag
            handle::Ptr{GObject}
            function GtkTextTagLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkTextTagLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkTextTagLeaf(args...; kwargs...)
            w = GtkTextTag(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkTextTag] = GtkTextTagLeaf
        function GtkTextTag(args...; kwargs...)
            GtkTextTagLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkTextTagTable <: GObject end
        mutable struct GtkTextTagTableLeaf <: GtkTextTagTable
            handle::Ptr{GObject}
            function GtkTextTagTableLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkTextTagTableLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkTextTagTableLeaf(args...; kwargs...)
            w = GtkTextTagTable(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkTextTagTable] = GtkTextTagTableLeaf
        function GtkTextTagTable(args...; kwargs...)
            GtkTextTagTableLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkTextView <: GtkWidget end
        mutable struct GtkTextViewLeaf <: GtkTextView
            handle::Ptr{GObject}
            function GtkTextViewLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkTextViewLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkTextViewLeaf(args...; kwargs...)
            w = GtkTextView(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkTextView] = GtkTextViewLeaf
        function GtkTextView(args...; kwargs...)
            GtkTextViewLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkToggleButton <: GtkButton end
        mutable struct GtkToggleButtonLeaf <: GtkToggleButton
            handle::Ptr{GObject}
            function GtkToggleButtonLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkToggleButtonLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkToggleButtonLeaf(args...; kwargs...)
            w = GtkToggleButton(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkToggleButton] = GtkToggleButtonLeaf
        function GtkToggleButton(args...; kwargs...)
            GtkToggleButtonLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkTooltip <: GObject end
        mutable struct GtkTooltipLeaf <: GtkTooltip
            handle::Ptr{GObject}
            function GtkTooltipLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkTooltipLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkTooltipLeaf(args...; kwargs...)
            w = GtkTooltip(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkTooltip] = GtkTooltipLeaf
        function GtkTooltip(args...; kwargs...)
            GtkTooltipLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkTreeExpander <: GtkWidget end
        mutable struct GtkTreeExpanderLeaf <: GtkTreeExpander
            handle::Ptr{GObject}
            function GtkTreeExpanderLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkTreeExpanderLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkTreeExpanderLeaf(args...; kwargs...)
            w = GtkTreeExpander(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkTreeExpander] = GtkTreeExpanderLeaf
        function GtkTreeExpander(args...; kwargs...)
            GtkTreeExpanderLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkTreeListModel <: GObject end
        mutable struct GtkTreeListModelLeaf <: GtkTreeListModel
            handle::Ptr{GObject}
            function GtkTreeListModelLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkTreeListModelLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkTreeListModelLeaf(args...; kwargs...)
            w = GtkTreeListModel(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkTreeListModel] = GtkTreeListModelLeaf
        function GtkTreeListModel(args...; kwargs...)
            GtkTreeListModelLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkTreeListRow <: GObject end
        mutable struct GtkTreeListRowLeaf <: GtkTreeListRow
            handle::Ptr{GObject}
            function GtkTreeListRowLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkTreeListRowLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkTreeListRowLeaf(args...; kwargs...)
            w = GtkTreeListRow(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkTreeListRow] = GtkTreeListRowLeaf
        function GtkTreeListRow(args...; kwargs...)
            GtkTreeListRowLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkTreeListRowSorter <: GtkSorter end
        mutable struct GtkTreeListRowSorterLeaf <: GtkTreeListRowSorter
            handle::Ptr{GObject}
            function GtkTreeListRowSorterLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkTreeListRowSorterLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkTreeListRowSorterLeaf(args...; kwargs...)
            w = GtkTreeListRowSorter(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkTreeListRowSorter] = GtkTreeListRowSorterLeaf
        function GtkTreeListRowSorter(args...; kwargs...)
            GtkTreeListRowSorterLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkTreeModelFilter <: GObject end
        mutable struct GtkTreeModelFilterLeaf <: GtkTreeModelFilter
            handle::Ptr{GObject}
            function GtkTreeModelFilterLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkTreeModelFilterLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkTreeModelFilterLeaf(args...; kwargs...)
            w = GtkTreeModelFilter(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkTreeModelFilter] = GtkTreeModelFilterLeaf
        function GtkTreeModelFilter(args...; kwargs...)
            GtkTreeModelFilterLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkTreeModelSort <: GObject end
        mutable struct GtkTreeModelSortLeaf <: GtkTreeModelSort
            handle::Ptr{GObject}
            function GtkTreeModelSortLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkTreeModelSortLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkTreeModelSortLeaf(args...; kwargs...)
            w = GtkTreeModelSort(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkTreeModelSort] = GtkTreeModelSortLeaf
        function GtkTreeModelSort(args...; kwargs...)
            GtkTreeModelSortLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkTreeSelection <: GObject end
        mutable struct GtkTreeSelectionLeaf <: GtkTreeSelection
            handle::Ptr{GObject}
            function GtkTreeSelectionLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkTreeSelectionLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkTreeSelectionLeaf(args...; kwargs...)
            w = GtkTreeSelection(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkTreeSelection] = GtkTreeSelectionLeaf
        function GtkTreeSelection(args...; kwargs...)
            GtkTreeSelectionLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkTreeStore <: GObject end
        mutable struct GtkTreeStoreLeaf <: GtkTreeStore
            handle::Ptr{GObject}
            function GtkTreeStoreLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkTreeStoreLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkTreeStoreLeaf(args...; kwargs...)
            w = GtkTreeStore(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkTreeStore] = GtkTreeStoreLeaf
        function GtkTreeStore(args...; kwargs...)
            GtkTreeStoreLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkTreeView <: GtkWidget end
        mutable struct GtkTreeViewLeaf <: GtkTreeView
            handle::Ptr{GObject}
            function GtkTreeViewLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkTreeViewLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkTreeViewLeaf(args...; kwargs...)
            w = GtkTreeView(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkTreeView] = GtkTreeViewLeaf
        function GtkTreeView(args...; kwargs...)
            GtkTreeViewLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkTreeViewColumn <: GInitiallyUnowned end
        mutable struct GtkTreeViewColumnLeaf <: GtkTreeViewColumn
            handle::Ptr{GObject}
            function GtkTreeViewColumnLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkTreeViewColumnLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkTreeViewColumnLeaf(args...; kwargs...)
            w = GtkTreeViewColumn(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkTreeViewColumn] = GtkTreeViewColumnLeaf
        function GtkTreeViewColumn(args...; kwargs...)
            GtkTreeViewColumnLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkVideo <: GtkWidget end
        mutable struct GtkVideoLeaf <: GtkVideo
            handle::Ptr{GObject}
            function GtkVideoLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkVideoLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkVideoLeaf(args...; kwargs...)
            w = GtkVideo(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkVideo] = GtkVideoLeaf
        function GtkVideo(args...; kwargs...)
            GtkVideoLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkViewport <: GtkWidget end
        mutable struct GtkViewportLeaf <: GtkViewport
            handle::Ptr{GObject}
            function GtkViewportLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkViewportLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkViewportLeaf(args...; kwargs...)
            w = GtkViewport(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkViewport] = GtkViewportLeaf
        function GtkViewport(args...; kwargs...)
            GtkViewportLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkVolumeButton <: GtkScaleButton end
        mutable struct GtkVolumeButtonLeaf <: GtkVolumeButton
            handle::Ptr{GObject}
            function GtkVolumeButtonLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkVolumeButtonLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkVolumeButtonLeaf(args...; kwargs...)
            w = GtkVolumeButton(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkVolumeButton] = GtkVolumeButtonLeaf
        function GtkVolumeButton(args...; kwargs...)
            GtkVolumeButtonLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkWidgetPaintable <: GObject end
        mutable struct GtkWidgetPaintableLeaf <: GtkWidgetPaintable
            handle::Ptr{GObject}
            function GtkWidgetPaintableLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkWidgetPaintableLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkWidgetPaintableLeaf(args...; kwargs...)
            w = GtkWidgetPaintable(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkWidgetPaintable] = GtkWidgetPaintableLeaf
        function GtkWidgetPaintable(args...; kwargs...)
            GtkWidgetPaintableLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkWindowControls <: GtkWidget end
        mutable struct GtkWindowControlsLeaf <: GtkWindowControls
            handle::Ptr{GObject}
            function GtkWindowControlsLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkWindowControlsLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkWindowControlsLeaf(args...; kwargs...)
            w = GtkWindowControls(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkWindowControls] = GtkWindowControlsLeaf
        function GtkWindowControls(args...; kwargs...)
            GtkWindowControlsLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkWindowGroup <: GObject end
        mutable struct GtkWindowGroupLeaf <: GtkWindowGroup
            handle::Ptr{GObject}
            function GtkWindowGroupLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkWindowGroupLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkWindowGroupLeaf(args...; kwargs...)
            w = GtkWindowGroup(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkWindowGroup] = GtkWindowGroupLeaf
        function GtkWindowGroup(args...; kwargs...)
            GtkWindowGroupLeaf(args...; kwargs...)
        end
    end
    begin
        abstract type GtkWindowHandle <: GtkWidget end
        mutable struct GtkWindowHandleLeaf <: GtkWindowHandle
            handle::Ptr{GObject}
            function GtkWindowHandleLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GtkWindowHandleLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        local kwargs
        function GtkWindowHandleLeaf(args...; kwargs...)
            w = GtkWindowHandle(args...)
            setproperties!(w; kwargs...)
            w
        end
        gtype_wrapper_cache[:GtkWindowHandle] = GtkWindowHandleLeaf
        function GtkWindowHandle(args...; kwargs...)
            GtkWindowHandleLeaf(args...; kwargs...)
        end
    end
    @doc "`GtkATContext` is an abstract class provided by GTK to communicate to\nplatform-specific assistive technologies API.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.ATContext.html)." GtkATContext
    @doc "The `GtkAboutDialog` offers a simple way to display information about\na program.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.AboutDialog.html)." GtkAboutDialog
    @doc "`GtkActionBar` is designed to present contextual actions.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.ActionBar.html)." GtkActionBar
    @doc "A `GtkShortcutAction` that calls gtk_widget_activate().\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.ActivateAction.html)." GtkActivateAction
    @doc "`GtkAdjustment` is a model for a numeric value.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.Adjustment.html)." GtkAdjustment
    @doc "A `GtkShortcutTrigger` that combines two triggers.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.AlternativeTrigger.html)." GtkAlternativeTrigger
    @doc "`GtkAnyFilter` matches an item when at least one of its filters matches.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.AnyFilter.html)." GtkAnyFilter
    @doc "The `GtkAppChooserButton` lets the user select an application.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.AppChooserButton.html)." GtkAppChooserButton
    @doc "`GtkAppChooserDialog` shows a `GtkAppChooserWidget` inside a `GtkDialog`.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.AppChooserDialog.html)." GtkAppChooserDialog
    @doc "`GtkAppChooserWidget` is a widget for selecting applications.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.AppChooserWidget.html)." GtkAppChooserWidget
    @doc "`GtkApplication` is a high-level API for writing applications.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.Application.html)." GtkApplication
    @doc "`GtkApplicationWindow` is a `GtkWindow` subclass that integrates with\n`GtkApplication`.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.ApplicationWindow.html)." GtkApplicationWindow
    @doc "`GtkAspectFrame` preserves the aspect ratio of its child.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.AspectFrame.html)." GtkAspectFrame
    @doc "`GtkAssistant` is used to represent a complex as a series of steps.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.Assistant.html)." GtkAssistant
    @doc "`GtkAssistantPage` is an auxiliary object used by `GtkAssistant.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.AssistantPage.html)." GtkAssistantPage
    @doc "`GtkBinLayout` is a `GtkLayoutManager` subclass useful for create \"bins\" of\nwidgets.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.BinLayout.html)." GtkBinLayout
    @doc "`GtkBookmarkList` is a list model that wraps `GBookmarkFile`.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.BookmarkList.html)." GtkBookmarkList
    @doc "`GtkBoolFilter` evaluates a boolean `GtkExpression`\nto determine whether to include items.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.BoolFilter.html)." GtkBoolFilter
    @doc "The `GtkBox` widget arranges child widgets into a single row or column.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.Box.html)." GtkBox
    @doc "`GtkBoxLayout` is a layout manager that arranges children in a single\nrow or column.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.BoxLayout.html)." GtkBoxLayout
    @doc "A `GtkBuilder` reads XML descriptions of a user interface and\ninstantiates the described objects.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.Builder.html)." GtkBuilder
    @doc "A `GtkBuilderScope` implementation for the C language.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.BuilderCScope.html)." GtkBuilderCScope
    @doc "`GtkBuilderListItemFactory` is a `GtkListItemFactory` that creates\nwidgets by instantiating `GtkBuilder` UI templates.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.BuilderListItemFactory.html)." GtkBuilderListItemFactory
    @doc "The `GtkButton` widget is generally used to trigger a callback function that is\ncalled when the button is pressed.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.Button.html)." GtkButton
    @doc "`GtkCalendar` is a widget that displays a Gregorian calendar, one month\nat a time.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.Calendar.html)." GtkCalendar
    @doc "A `GtkShortcutAction` that invokes a callback.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.CallbackAction.html)." GtkCallbackAction
    @doc "An abstract class for laying out `GtkCellRenderer`s\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.CellArea.html)." GtkCellArea
    @doc "A cell area that renders GtkCellRenderers into a row or a column\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.CellAreaBox.html)." GtkCellAreaBox
    @doc "Stores geometrical information for a series of rows in a GtkCellArea\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.CellAreaContext.html)." GtkCellAreaContext
    @doc "An object for rendering a single cell\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.CellRenderer.html)." GtkCellRenderer
    @doc "Renders a keyboard accelerator in a cell\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.CellRendererAccel.html)." GtkCellRendererAccel
    @doc "Renders a combobox in a cell\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.CellRendererCombo.html)." GtkCellRendererCombo
    @doc "Renders a pixbuf in a cell\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.CellRendererPixbuf.html)." GtkCellRendererPixbuf
    @doc "Renders numbers as progress bars\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.CellRendererProgress.html)." GtkCellRendererProgress
    @doc "Renders a spin button in a cell\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.CellRendererSpin.html)." GtkCellRendererSpin
    @doc "Renders a spinning animation in a cell\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.CellRendererSpinner.html)." GtkCellRendererSpinner
    @doc "Renders text in a cell\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.CellRendererText.html)." GtkCellRendererText
    @doc "Renders a toggle button in a cell\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.CellRendererToggle.html)." GtkCellRendererToggle
    @doc "A widget displaying a single row of a GtkTreeModel\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.CellView.html)." GtkCellView
    @doc "`GtkCenterBox` arranges three children in a row, keeping the middle child\ncentered as well as possible.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.CenterBox.html)." GtkCenterBox
    @doc "`GtkCenterLayout` is a layout manager that manages up to three children.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.CenterLayout.html)." GtkCenterLayout
    @doc "A `GtkCheckButton` places a label next to an indicator.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.CheckButton.html)." GtkCheckButton
    @doc "The `GtkColorButton` allows to open a color chooser dialog to change\nthe color.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.ColorButton.html)." GtkColorButton
    @doc "A dialog for choosing a color.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.ColorChooserDialog.html)." GtkColorChooserDialog
    @doc "The `GtkColorChooserWidget` widget lets the user select a color.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.ColorChooserWidget.html)." GtkColorChooserWidget
    @doc "`GtkColumnView` presents a large dynamic list of items using multiple columns\nwith headers.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.ColumnView.html)." GtkColumnView
    @doc "`GtkColumnViewColumn` represents the columns being added to `GtkColumnView`.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.ColumnViewColumn.html)." GtkColumnViewColumn
    @doc "A `GtkComboBox` is a widget that allows the user to choose from a list of\nvalid choices.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.ComboBox.html)." GtkComboBox
    @doc "A `GtkComboBoxText` is a simple variant of `GtkComboBox` for text-only\nuse cases.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.ComboBoxText.html)." GtkComboBoxText
    @doc "`GtkConstraint` describes a constraint between attributes of two widgets,\n expressed as a linear equation.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.Constraint.html)." GtkConstraint
    @doc "A `GtkConstraintGuide` is an invisible layout element in a\n`GtkConstraintLayout`.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.ConstraintGuide.html)." GtkConstraintGuide
    @doc "A layout manager using constraints to describe relations between widgets.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.ConstraintLayout.html)." GtkConstraintLayout
    @doc "`GtkLayoutChild` subclass for children in a `GtkConstraintLayout`.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.ConstraintLayoutChild.html)." GtkConstraintLayoutChild
    @doc "`GtkCssProvider` is an object implementing the `GtkStyleProvider` interface\nfor CSS.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.CssProvider.html)." GtkCssProvider
    @doc "`GtkCustomFilter` determines whether to include items with a callback.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.CustomFilter.html)." GtkCustomFilter
    @doc "`GtkCustomLayout` uses closures for size negotiation.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.CustomLayout.html)." GtkCustomLayout
    @doc "`GtkCustomSorter` is a `GtkSorter` implementation that sorts via a callback\nfunction.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.CustomSorter.html)." GtkCustomSorter
    @doc "Dialogs are a convenient way to prompt the user for a small amount\nof input.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.Dialog.html)." GtkDialog
    @doc "`GtkDirectoryList` is a list model that wraps g_file_enumerate_children_async().\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.DirectoryList.html)." GtkDirectoryList
    @doc "`GtkDragIcon` is a `GtkRoot` implementation for drag icons.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.DragIcon.html)." GtkDragIcon
    @doc "`GtkDragSource` is an event controller to initiate Drag-And-Drop operations.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.DragSource.html)." GtkDragSource
    @doc "`GtkDrawingArea` is a widget that allows drawing with cairo.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.DrawingArea.html)." GtkDrawingArea
    @doc "`GtkDropControllerMotion` is an event controller tracking\nthe pointer during Drag-and-Drop operations.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.DropControllerMotion.html)." GtkDropControllerMotion
    @doc "`GtkDropDown` is a widget that allows the user to choose an item\nfrom a list of options.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.DropDown.html)." GtkDropDown
    @doc "`GtkDropTarget` is an event controller to receive Drag-and-Drop operations.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.DropTarget.html)." GtkDropTarget
    @doc "`GtkDropTargetAsync` is an event controller to receive Drag-and-Drop\noperations, asynchronously.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.DropTargetAsync.html)." GtkDropTargetAsync
    @doc "A `GtkEditableLabel` is a label that allows users to\nedit the text by switching to an “edit mode”.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.EditableLabel.html)." GtkEditableLabel
    @doc "The `GtkEmojiChooser` is used by text widgets such as `GtkEntry` or\n`GtkTextView` to let users insert Emoji characters.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.EmojiChooser.html)." GtkEmojiChooser
    @doc "`GtkEntry` is a single line text entry widget.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.Entry.html)." GtkEntry
    @doc "A `GtkEntryBuffer` hold the text displayed in a `GtkText` widget.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.EntryBuffer.html)." GtkEntryBuffer
    @doc "`GtkEntryCompletion` is an auxiliary object to provide completion functionality\nfor `GtkEntry`.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.EntryCompletion.html)." GtkEntryCompletion
    @doc "`GtkEventController` is the base class for event controllers.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.EventController.html)." GtkEventController
    @doc "`GtkEventControllerFocus` is an event controller to keep track of\nkeyboard focus.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.EventControllerFocus.html)." GtkEventControllerFocus
    @doc "`GtkEventControllerKey` is an event controller that provides access\nto key events.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.EventControllerKey.html)." GtkEventControllerKey
    @doc "`GtkEventControllerLegacy` is an event controller that provides raw\naccess to the event stream.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.EventControllerLegacy.html)." GtkEventControllerLegacy
    @doc "`GtkEventControllerMotion` is an event controller tracking the pointer\nposition.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.EventControllerMotion.html)." GtkEventControllerMotion
    @doc "`GtkEventControllerScroll` is an event controller that handles scroll\nevents.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.EventControllerScroll.html)." GtkEventControllerScroll
    @doc "`GtkEveryFilter` matches an item when each of its filters matches.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.EveryFilter.html)." GtkEveryFilter
    @doc "`GtkExpander` allows the user to reveal its child by clicking\non an expander triangle.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.Expander.html)." GtkExpander
    @doc "`GtkExpression` provides a way to describe references to values.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.Expression.html)." GtkExpression
    @doc "`GtkFileChooserDialog` is a dialog suitable for use with\n“File Open” or “File Save” commands.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.FileChooserDialog.html)." GtkFileChooserDialog
    @doc "`GtkFileChooserNative` is an abstraction of a dialog suitable\nfor use with “File Open” or “File Save as” commands.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.FileChooserNative.html)." GtkFileChooserNative
    @doc "`GtkFileChooserWidget` is a widget for choosing files.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.FileChooserWidget.html)." GtkFileChooserWidget
    @doc "`GtkFileFilter` filters files by name or mime type.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.FileFilter.html)." GtkFileFilter
    @doc "A `GtkFilter` object describes the filtering to be performed by a\n[class@Gtk.FilterListModel].\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.Filter.html)." GtkFilter
    @doc "`GtkFilterListModel` is a list model that filters the elements of\nthe underlying model according to a `GtkFilter`.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.FilterListModel.html)." GtkFilterListModel
    @doc "`GtkFixed` places its child widgets at fixed positions and with fixed sizes.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.Fixed.html)." GtkFixed
    @doc "`GtkFixedLayout` is a layout manager which can place child widgets\nat fixed positions.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.FixedLayout.html)." GtkFixedLayout
    @doc "`GtkLayoutChild` subclass for children in a `GtkFixedLayout`.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.FixedLayoutChild.html)." GtkFixedLayoutChild
    @doc "`GtkFlattenListModel` is a list model that concatenates other list models.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.FlattenListModel.html)." GtkFlattenListModel
    @doc "A `GtkFlowBox` puts child widgets in reflowing grid.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.FlowBox.html)." GtkFlowBox
    @doc "`GtkFlowBoxChild` is the kind of widget that can be added to a `GtkFlowBox`.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.FlowBoxChild.html)." GtkFlowBoxChild
    @doc "The `GtkFontButton` allows to open a font chooser dialog to change\nthe font.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.FontButton.html)." GtkFontButton
    @doc "The `GtkFontChooserDialog` widget is a dialog for selecting a font.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.FontChooserDialog.html)." GtkFontChooserDialog
    @doc "The `GtkFontChooserWidget` widget lets the user select a font.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.FontChooserWidget.html)." GtkFontChooserWidget
    @doc "`GtkFrame` is a widget that surrounds its child with a decorative\nframe and an optional label.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.Frame.html)." GtkFrame
    @doc "`GtkGLArea` is a widget that allows drawing with OpenGL.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.GLArea.html)." GtkGLArea
    @doc "`GtkGesture` is the base class for gesture recognition.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.Gesture.html)." GtkGesture
    @doc "`GtkGestureClick` is a `GtkGesture` implementation for clicks.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.GestureClick.html)." GtkGestureClick
    @doc "`GtkGestureDrag` is a `GtkGesture` implementation for drags.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.GestureDrag.html)." GtkGestureDrag
    @doc "`GtkGestureLongPress` is a `GtkGesture` for long presses.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.GestureLongPress.html)." GtkGestureLongPress
    @doc "`GtkGesturePan` is a `GtkGesture` for pan gestures.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.GesturePan.html)." GtkGesturePan
    @doc "`GtkGestureRotate` is a `GtkGesture` for 2-finger rotations.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.GestureRotate.html)." GtkGestureRotate
    @doc "`GtkGestureSingle` is a `GtkGestures` subclass optimized for singe-touch\nand mouse gestures.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.GestureSingle.html)." GtkGestureSingle
    @doc "`GtkGestureStylus` is a `GtkGesture` specific to stylus input.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.GestureStylus.html)." GtkGestureStylus
    @doc "`GtkGestureSwipe` is a `GtkGesture` for swipe gestures.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.GestureSwipe.html)." GtkGestureSwipe
    @doc "`GtkGestureZoom` is a `GtkGesture` for 2-finger pinch/zoom gestures.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.GestureZoom.html)." GtkGestureZoom
    @doc "`GtkGrid` is a container which arranges its child widgets in\nrows and columns.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.Grid.html)." GtkGrid
    @doc "`GtkGridLayout` is a layout manager which arranges child widgets in\nrows and columns.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.GridLayout.html)." GtkGridLayout
    @doc "`GtkLayoutChild` subclass for children in a `GtkGridLayout`.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.GridLayoutChild.html)." GtkGridLayoutChild
    @doc "`GtkGridView` presents a large dynamic grid of items.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.GridView.html)." GtkGridView
    @doc "`GtkHeaderBar` is a widget for creating custom title bars for windows.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.HeaderBar.html)." GtkHeaderBar
    @doc "`GtkIMContext` defines the interface for GTK input methods.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.IMContext.html)." GtkIMContext
    @doc "`GtkIMContextSimple` is an input method supporting table-based input methods.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.IMContextSimple.html)." GtkIMContextSimple
    @doc "`GtkIMMulticontext` is an input method context supporting multiple,\nswitchable input methods.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.IMMulticontext.html)." GtkIMMulticontext
    @doc "Contains information found when looking up an icon in `GtkIconTheme`.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.IconPaintable.html)." GtkIconPaintable
    @doc "`GtkIconTheme` provides a facility for loading themed icons.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.IconTheme.html)." GtkIconTheme
    @doc "`GtkIconView` is a widget which displays data in a grid of icons.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.IconView.html)." GtkIconView
    @doc "The `GtkImage` widget displays an image.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.Image.html)." GtkImage
    @doc "`GtkInfoBar` can be show messages to the user without a dialog.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.InfoBar.html)." GtkInfoBar
    @doc "`GtkInscription` is a widget to show text in a predefined area.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.Inscription.html)." GtkInscription
    @doc "A `GtkShortcutTrigger` that triggers when a specific keyval and modifiers are pressed.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.KeyvalTrigger.html)." GtkKeyvalTrigger
    @doc "The `GtkLabel` widget displays a small amount of text.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.Label.html)." GtkLabel
    @doc "`GtkLayoutChild` is the base class for objects that are meant to hold\nlayout properties.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.LayoutChild.html)." GtkLayoutChild
    @doc "Layout managers are delegate classes that handle the preferred size\nand the allocation of a widget.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.LayoutManager.html)." GtkLayoutManager
    @doc "`GtkLevelBar` is a widget that can be used as a level indicator.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.LevelBar.html)." GtkLevelBar
    @doc "A `GtkLinkButton` is a button with a hyperlink.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.LinkButton.html)." GtkLinkButton
    @doc "`GtkListBase` is the abstract base class for GTK's list widgets.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.ListBase.html)." GtkListBase
    @doc "`GtkListBox` is a vertical list.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.ListBox.html)." GtkListBox
    @doc "`GtkListBoxRow` is the kind of widget that can be added to a `GtkListBox`.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.ListBoxRow.html)." GtkListBoxRow
    @doc "`GtkListItem` is used by list widgets to represent items in a `GListModel`.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.ListItem.html)." GtkListItem
    @doc "A `GtkListItemFactory` creates widgets for the items taken from a `GListModel`.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.ListItemFactory.html)." GtkListItemFactory
    @doc "A list-like data structure that can be used with the [class@Gtk.TreeView].\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.ListStore.html)." GtkListStore
    @doc "`GtkListView` presents a large dynamic list of items.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.ListView.html)." GtkListView
    @doc "`GtkLockButton` is a widget to obtain and revoke authorizations\nneeded to operate the controls.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.LockButton.html)." GtkLockButton
    @doc "A `GtkMapListModel` maps the items in a list model to different items.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.MapListModel.html)." GtkMapListModel
    @doc "`GtkMediaControls` is a widget to show controls for a video.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.MediaControls.html)." GtkMediaControls
    @doc "`GtkMediaFile` implements `GtkMediaStream` for files.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.MediaFile.html)." GtkMediaFile
    @doc "`GtkMediaStream` is the integration point for media playback inside GTK.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.MediaStream.html)." GtkMediaStream
    @doc "The `GtkMenuButton` widget is used to display a popup when clicked.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.MenuButton.html)." GtkMenuButton
    @doc "`GtkMessageDialog` presents a dialog with some message text.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.MessageDialog.html)." GtkMessageDialog
    @doc "A `GtkShortcutAction` that calls gtk_widget_mnemonic_activate().\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.MnemonicAction.html)." GtkMnemonicAction
    @doc "A `GtkShortcutTrigger` that triggers when a specific mnemonic is pressed.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.MnemonicTrigger.html)." GtkMnemonicTrigger
    @doc "`GtkMountOperation` is an implementation of `GMountOperation`.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.MountOperation.html)." GtkMountOperation
    @doc "`GtkMultiFilter` is the base class for filters that combine multiple filters.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.MultiFilter.html)." GtkMultiFilter
    @doc "`GtkMultiSelection` is a `GtkSelectionModel` that allows selecting multiple\nelements.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.MultiSelection.html)." GtkMultiSelection
    @doc "`GtkMultiSorter` combines multiple sorters by trying them\nin turn.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.MultiSorter.html)." GtkMultiSorter
    @doc "A `GtkShortcutAction` that activates an action by name.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.NamedAction.html)." GtkNamedAction
    @doc "Native dialogs are platform dialogs that don't use `GtkDialog`.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.NativeDialog.html)." GtkNativeDialog
    @doc "A `GtkShortcutTrigger` that never triggers.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.NeverTrigger.html)." GtkNeverTrigger
    @doc "`GtkNoSelection` is a `GtkSelectionModel` that does not allow selecting\nanything.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.NoSelection.html)." GtkNoSelection
    @doc "`GtkNotebook` is a container whose children are pages switched\nbetween using tabs.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.Notebook.html)." GtkNotebook
    @doc "`GtkNotebookPage` is an auxiliary object used by `GtkNotebook`.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.NotebookPage.html)." GtkNotebookPage
    @doc "A `GtkShortcutAction` that does nothing.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.NothingAction.html)." GtkNothingAction
    @doc "`GtkNumericSorter` is a `GtkSorter` that compares numbers.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.NumericSorter.html)." GtkNumericSorter
    @doc "`GtkOverlay` is a container which contains a single main child, on top\nof which it can place “overlay” widgets.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.Overlay.html)." GtkOverlay
    @doc "`GtkOverlayLayout` is the layout manager used by `GtkOverlay`.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.OverlayLayout.html)." GtkOverlayLayout
    @doc "`GtkLayoutChild` subclass for children in a `GtkOverlayLayout`.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.OverlayLayoutChild.html)." GtkOverlayLayoutChild
    @doc "`GtkPadController` is an event controller for the pads found in drawing\ntablets.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.PadController.html)." GtkPadController
    @doc "A `GtkPageSetup` object stores the page size, orientation and margins.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.PageSetup.html)." GtkPageSetup
    @doc "A widget with two panes, arranged either horizontally or vertically.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.Paned.html)." GtkPaned
    @doc "`GtkPasswordEntry` is an entry that has been tailored for entering secrets.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.PasswordEntry.html)." GtkPasswordEntry
    @doc "A `GtkEntryBuffer` that locks the underlying memory to prevent it\nfrom being swapped to disk.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.PasswordEntryBuffer.html)." GtkPasswordEntryBuffer
    @doc "The `GtkPicture` widget displays a `GdkPaintable`.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.Picture.html)." GtkPicture
    @doc "`GtkPopover` is a bubble-like context popup.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.Popover.html)." GtkPopover
    @doc "`GtkPopoverMenu` is a subclass of `GtkPopover` that implements menu\nbehavior.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.PopoverMenu.html)." GtkPopoverMenu
    @doc "`GtkPopoverMenuBar` presents a horizontal bar of items that pop\nup popover menus when clicked.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.PopoverMenuBar.html)." GtkPopoverMenuBar
    @doc "A `GtkPrintContext` encapsulates context information that is required when\ndrawing pages for printing.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.PrintContext.html)." GtkPrintContext
    @doc "A `GtkPrintJob` object represents a job that is sent to a printer.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.PrintJob.html)." GtkPrintJob
    @doc "`GtkPrintOperation` is the high-level, portable printing API.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.PrintOperation.html)." GtkPrintOperation
    @doc "A `GtkPrintSettings` object represents the settings of a print dialog in\na system-independent way.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.PrintSettings.html)." GtkPrintSettings
    @doc "A `GtkPrinter` object represents a printer.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.Printer.html)." GtkPrinter
    @doc "`GtkProgressBar` is typically used to display the progress of a long\nrunning operation.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.ProgressBar.html)." GtkProgressBar
    @doc "`GtkRange` is the common base class for widgets which visualize an\nadjustment.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.Range.html)." GtkRange
    @doc "`GtkRecentManager` manages and looks up recently used files.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.RecentManager.html)." GtkRecentManager
    @doc "A `GtkRevealer` animates the transition of its child from invisible to visible.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.Revealer.html)." GtkRevealer
    @doc "A `GtkScale` is a slider control used to select a numeric value.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.Scale.html)." GtkScale
    @doc "`GtkScaleButton` provides a button which pops up a scale widget.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.ScaleButton.html)." GtkScaleButton
    @doc "The `GtkScrollbar` widget is a horizontal or vertical scrollbar.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.Scrollbar.html)." GtkScrollbar
    @doc "`GtkScrolledWindow` is a container that makes its child scrollable.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.ScrolledWindow.html)." GtkScrolledWindow
    @doc "`GtkSearchBar` is a container made to have a search entry.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.SearchBar.html)." GtkSearchBar
    @doc "`GtkSearchEntry` is an entry widget that has been tailored for use\nas a search entry.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.SearchEntry.html)." GtkSearchEntry
    @doc "`GtkSelectionFilterModel` is a list model that presents the selection from\na `GtkSelectionModel`.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.SelectionFilterModel.html)." GtkSelectionFilterModel
    @doc "`GtkSeparator` is a horizontal or vertical separator widget.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.Separator.html)." GtkSeparator
    @doc "`GtkSettings` provides a mechanism to share global settings between\napplications.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.Settings.html)." GtkSettings
    @doc "A `GtkShortcut` describes a keyboard shortcut.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.Shortcut.html)." GtkShortcut
    @doc "`GtkShortcutAction` encodes an action that can be triggered by a\nkeyboard shortcut.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.ShortcutAction.html)." GtkShortcutAction
    @doc "`GtkShortcutController` is an event controller that manages shortcuts.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.ShortcutController.html)." GtkShortcutController
    @doc "`GtkShortcutLabel` displays a single keyboard shortcut or gesture.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.ShortcutLabel.html)." GtkShortcutLabel
    @doc "`GtkShortcutTrigger` tracks how a `GtkShortcut` should be activated.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.ShortcutTrigger.html)." GtkShortcutTrigger
    @doc "A `GtkShortcutsGroup` represents a group of related keyboard shortcuts\nor gestures.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.ShortcutsGroup.html)." GtkShortcutsGroup
    @doc "A `GtkShortcutsSection` collects all the keyboard shortcuts and gestures\nfor a major application mode.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.ShortcutsSection.html)." GtkShortcutsSection
    @doc "A `GtkShortcutsShortcut` represents a single keyboard shortcut or gesture\nwith a short text.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.ShortcutsShortcut.html)." GtkShortcutsShortcut
    @doc "A `GtkShortcutsWindow` shows information about the keyboard shortcuts\nand gestures of an application.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.ShortcutsWindow.html)." GtkShortcutsWindow
    @doc "A `GtkShortcut`Action that emits a signal.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.SignalAction.html)." GtkSignalAction
    @doc "`GtkSignalListItemFactory` is a `GtkListItemFactory` that emits signals\nto to manage listitems.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.SignalListItemFactory.html)." GtkSignalListItemFactory
    @doc "`GtkSingleSelection` is a `GtkSelectionModel` that allows selecting a single\nitem.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.SingleSelection.html)." GtkSingleSelection
    @doc "`GtkSizeGroup` groups widgets together so they all request the same size.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.SizeGroup.html)." GtkSizeGroup
    @doc "`GtkSliceListModel` is a list model that presents a slice of another model.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.SliceListModel.html)." GtkSliceListModel
    @doc "`GtkSnapshot` assists in creating [class@Gsk.RenderNode]s for widgets.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.Snapshot.html)." GtkSnapshot
    @doc "A `GListModel` that sorts the elements of an underlying model\naccording to a `GtkSorter`.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.SortListModel.html)." GtkSortListModel
    @doc "`GtkSorter` is an object to describe sorting criteria.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.Sorter.html)." GtkSorter
    @doc "A `GtkSpinButton` is an ideal way to allow the user to set the\nvalue of some attribute.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.SpinButton.html)." GtkSpinButton
    @doc "A `GtkSpinner` widget displays an icon-size spinning animation.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.Spinner.html)." GtkSpinner
    @doc "`GtkStack` is a container which only shows one of its children\nat a time.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.Stack.html)." GtkStack
    @doc "`GtkStackPage` is an auxiliary class used by `GtkStack`.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.StackPage.html)." GtkStackPage
    @doc "A `GtkStackSidebar` uses a sidebar to switch between `GtkStack` pages.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.StackSidebar.html)." GtkStackSidebar
    @doc "The `GtkStackSwitcher` shows a row of buttons to switch between `GtkStack`\npages.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.StackSwitcher.html)." GtkStackSwitcher
    @doc "A `GtkStatusbar` widget is usually placed along the bottom of an application's\nmain [class@Gtk.Window].\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.Statusbar.html)." GtkStatusbar
    @doc "`GtkStringFilter` determines whether to include items by comparing\nstrings to a fixed search term.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.StringFilter.html)." GtkStringFilter
    @doc "`GtkStringList` is a list model that wraps an array of strings.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.StringList.html)." GtkStringList
    @doc "`GtkStringObject` is the type of items in a `GtkStringList`.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.StringObject.html)." GtkStringObject
    @doc "`GtkStringSorter` is a `GtkSorter` that compares strings.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.StringSorter.html)." GtkStringSorter
    @doc "`GtkStyleContext` stores styling information affecting a widget.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.StyleContext.html)." GtkStyleContext
    @doc "`GtkSwitch` is a \"light switch\" that has two states: on or off.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.Switch.html)." GtkSwitch
    @doc "The `GtkText` widget is a single-line text entry widget.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.Text.html)." GtkText
    @doc "Stores text and attributes for display in a `GtkTextView`.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.TextBuffer.html)." GtkTextBuffer
    @doc "A `GtkTextChildAnchor` is a spot in a `GtkTextBuffer` where child widgets can\nbe “anchored”.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.TextChildAnchor.html)." GtkTextChildAnchor
    @doc "A `GtkTextMark` is a position in a `GtkTextbuffer` that is preserved\nacross modifications.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.TextMark.html)." GtkTextMark
    @doc "A tag that can be applied to text contained in a `GtkTextBuffer`.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.TextTag.html)." GtkTextTag
    @doc "The collection of tags in a `GtkTextBuffer`\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.TextTagTable.html)." GtkTextTagTable
    @doc "A widget that displays the contents of a [class@Gtk.TextBuffer].\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.TextView.html)." GtkTextView
    @doc "A `GtkToggleButton` is a button which remains “pressed-in” when\nclicked.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.ToggleButton.html)." GtkToggleButton
    @doc "`GtkTooltip` is an object representing a widget tooltip.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.Tooltip.html)." GtkTooltip
    @doc "`GtkTreeExpander` is a widget that provides an expander for a list.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.TreeExpander.html)." GtkTreeExpander
    @doc "`GtkTreeListModel` is a list model that can create child models on demand.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.TreeListModel.html)." GtkTreeListModel
    @doc "`GtkTreeListRow` is used by `GtkTreeListModel` to represent items.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.TreeListRow.html)." GtkTreeListRow
    @doc "`GtkTreeListRowSorter` is a special-purpose sorter that will apply a given\nsorter to the levels in a tree.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.TreeListRowSorter.html)." GtkTreeListRowSorter
    @doc "A `GtkTreeModel` which hides parts of an underlying tree model\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.TreeModelFilter.html)." GtkTreeModelFilter
    @doc "A GtkTreeModel which makes an underlying tree model sortable\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.TreeModelSort.html)." GtkTreeModelSort
    @doc "The selection object for GtkTreeView\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.TreeSelection.html)." GtkTreeSelection
    @doc "A tree-like data structure that can be used with the GtkTreeView\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.TreeStore.html)." GtkTreeStore
    @doc "A widget for displaying both trees and lists\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.TreeView.html)." GtkTreeView
    @doc "A visible column in a [class@Gtk.TreeView] widget\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.TreeViewColumn.html)." GtkTreeViewColumn
    @doc "`GtkVideo` is a widget to show a `GtkMediaStream` with media controls.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.Video.html)." GtkVideo
    @doc "`GtkViewport` implements scrollability for widgets that lack their\nown scrolling capabilities.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.Viewport.html)." GtkViewport
    @doc "`GtkVolumeButton` is a `GtkScaleButton` subclass tailored for\nvolume control.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.VolumeButton.html)." GtkVolumeButton
    @doc "The base class for all widgets.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.Widget.html)." GtkWidget
    @doc "`GtkWidgetPaintable` is a `GdkPaintable` that displays the contents\nof a widget.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.WidgetPaintable.html)." GtkWidgetPaintable
    @doc "A `GtkWindow` is a toplevel window which can contain other widgets.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.Window.html)." GtkWindow
    @doc "`GtkWindowControls` shows window frame controls.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.WindowControls.html)." GtkWindowControls
    @doc "`GtkWindowGroup` makes group of windows behave like separate applications.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.WindowGroup.html)." GtkWindowGroup
    @doc "`GtkWindowHandle` is a titlebar area widget.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/gtk4/class.WindowHandle.html)." GtkWindowHandle
    begin
        struct GtkAccessible <: GInterface
            handle::Ptr{GObject}
            gc::Any
            GtkAccessible(x::GObject) = begin
                    new(unsafe_convert(Ptr{GObject}, x), x)
                end
        end
    end
    begin
        struct GtkActionable <: GInterface
            handle::Ptr{GObject}
            gc::Any
            GtkActionable(x::GObject) = begin
                    new(unsafe_convert(Ptr{GObject}, x), x)
                end
        end
    end
    begin
        struct GtkAppChooser <: GInterface
            handle::Ptr{GObject}
            gc::Any
            GtkAppChooser(x::GObject) = begin
                    new(unsafe_convert(Ptr{GObject}, x), x)
                end
        end
    end
    begin
        struct GtkBuildable <: GInterface
            handle::Ptr{GObject}
            gc::Any
            GtkBuildable(x::GObject) = begin
                    new(unsafe_convert(Ptr{GObject}, x), x)
                end
        end
    end
    begin
        struct GtkBuilderScope <: GInterface
            handle::Ptr{GObject}
            gc::Any
            GtkBuilderScope(x::GObject) = begin
                    new(unsafe_convert(Ptr{GObject}, x), x)
                end
        end
    end
    begin
        struct GtkCellEditable <: GInterface
            handle::Ptr{GObject}
            gc::Any
            GtkCellEditable(x::GObject) = begin
                    new(unsafe_convert(Ptr{GObject}, x), x)
                end
        end
    end
    begin
        struct GtkCellLayout <: GInterface
            handle::Ptr{GObject}
            gc::Any
            GtkCellLayout(x::GObject) = begin
                    new(unsafe_convert(Ptr{GObject}, x), x)
                end
        end
    end
    begin
        struct GtkColorChooser <: GInterface
            handle::Ptr{GObject}
            gc::Any
            GtkColorChooser(x::GObject) = begin
                    new(unsafe_convert(Ptr{GObject}, x), x)
                end
        end
    end
    begin
        struct GtkConstraintTarget <: GInterface
            handle::Ptr{GObject}
            gc::Any
            GtkConstraintTarget(x::GObject) = begin
                    new(unsafe_convert(Ptr{GObject}, x), x)
                end
        end
    end
    begin
        struct GtkEditable <: GInterface
            handle::Ptr{GObject}
            gc::Any
            GtkEditable(x::GObject) = begin
                    new(unsafe_convert(Ptr{GObject}, x), x)
                end
        end
    end
    begin
        struct GtkFileChooser <: GInterface
            handle::Ptr{GObject}
            gc::Any
            GtkFileChooser(x::GObject) = begin
                    new(unsafe_convert(Ptr{GObject}, x), x)
                end
        end
    end
    begin
        struct GtkFontChooser <: GInterface
            handle::Ptr{GObject}
            gc::Any
            GtkFontChooser(x::GObject) = begin
                    new(unsafe_convert(Ptr{GObject}, x), x)
                end
        end
    end
    begin
        struct GtkNative <: GInterface
            handle::Ptr{GObject}
            gc::Any
            GtkNative(x::GObject) = begin
                    new(unsafe_convert(Ptr{GObject}, x), x)
                end
        end
    end
    begin
        struct GtkOrientable <: GInterface
            handle::Ptr{GObject}
            gc::Any
            GtkOrientable(x::GObject) = begin
                    new(unsafe_convert(Ptr{GObject}, x), x)
                end
        end
    end
    begin
        struct GtkPrintOperationPreview <: GInterface
            handle::Ptr{GObject}
            gc::Any
            GtkPrintOperationPreview(x::GObject) = begin
                    new(unsafe_convert(Ptr{GObject}, x), x)
                end
        end
    end
    begin
        struct GtkRoot <: GInterface
            handle::Ptr{GObject}
            gc::Any
            GtkRoot(x::GObject) = begin
                    new(unsafe_convert(Ptr{GObject}, x), x)
                end
        end
    end
    begin
        struct GtkScrollable <: GInterface
            handle::Ptr{GObject}
            gc::Any
            GtkScrollable(x::GObject) = begin
                    new(unsafe_convert(Ptr{GObject}, x), x)
                end
        end
    end
    begin
        struct GtkSelectionModel <: GInterface
            handle::Ptr{GObject}
            gc::Any
            GtkSelectionModel(x::GObject) = begin
                    new(unsafe_convert(Ptr{GObject}, x), x)
                end
        end
    end
    begin
        struct GtkShortcutManager <: GInterface
            handle::Ptr{GObject}
            gc::Any
            GtkShortcutManager(x::GObject) = begin
                    new(unsafe_convert(Ptr{GObject}, x), x)
                end
        end
    end
    begin
        struct GtkStyleProvider <: GInterface
            handle::Ptr{GObject}
            gc::Any
            GtkStyleProvider(x::GObject) = begin
                    new(unsafe_convert(Ptr{GObject}, x), x)
                end
        end
    end
    begin
        struct GtkSymbolicPaintable <: GInterface
            handle::Ptr{GObject}
            gc::Any
            GtkSymbolicPaintable(x::GObject) = begin
                    new(unsafe_convert(Ptr{GObject}, x), x)
                end
        end
    end
    begin
        struct GtkTreeDragDest <: GInterface
            handle::Ptr{GObject}
            gc::Any
            GtkTreeDragDest(x::GObject) = begin
                    new(unsafe_convert(Ptr{GObject}, x), x)
                end
        end
    end
    begin
        struct GtkTreeDragSource <: GInterface
            handle::Ptr{GObject}
            gc::Any
            GtkTreeDragSource(x::GObject) = begin
                    new(unsafe_convert(Ptr{GObject}, x), x)
                end
        end
    end
    begin
        struct GtkTreeModel <: GInterface
            handle::Ptr{GObject}
            gc::Any
            GtkTreeModel(x::GObject) = begin
                    new(unsafe_convert(Ptr{GObject}, x), x)
                end
        end
    end
    begin
        struct GtkTreeSortable <: GInterface
            handle::Ptr{GObject}
            gc::Any
            GtkTreeSortable(x::GObject) = begin
                    new(unsafe_convert(Ptr{GObject}, x), x)
                end
        end
    end
    export GtkBitset, GtkBitsetIter, _GtkBitsetIter, GtkBorder, _GtkBorder, GtkBuildableParseContext, GtkBuildableParser, _GtkBuildableParser, GtkCssLocation, _GtkCssLocation, GtkCssSection, GtkCssStyleChange, GtkExpressionWatch, GtkPadActionEntry, _GtkPadActionEntry, GtkPaperSize, GtkPrintBackend, GtkRecentData, _GtkRecentData, GtkRecentInfo, GtkRequestedSize, _GtkRequestedSize, GtkRequisition, _GtkRequisition, GtkTextIter, _GtkTextIter, GtkTreeIter, _GtkTreeIter, GtkTreePath, GtkTreeRowReference, GtkATContext, GtkAboutDialog, GtkActionBar, GtkActivateAction, GtkAdjustment, GtkAlternativeTrigger, GtkAnyFilter, GtkAppChooserButton, GtkAppChooserDialog, GtkAppChooserWidget, GtkApplication, GtkApplicationWindow, GtkAspectFrame, GtkAssistant, GtkAssistantPage, GtkBinLayout, GtkBookmarkList, GtkBoolFilter, GtkBox, GtkBoxLayout, GtkBuilder, GtkBuilderCScope, GtkBuilderListItemFactory, GtkButton, GtkCalendar, GtkCallbackAction, GtkCellArea, GtkCellAreaBox, GtkCellAreaContext, GtkCellRenderer, GtkCellRendererAccel, GtkCellRendererCombo, GtkCellRendererPixbuf, GtkCellRendererProgress, GtkCellRendererSpin, GtkCellRendererSpinner, GtkCellRendererText, GtkCellRendererToggle, GtkCellView, GtkCenterBox, GtkCenterLayout, GtkCheckButton, GtkColorButton, GtkColorChooserDialog, GtkColorChooserWidget, GtkColumnView, GtkColumnViewColumn, GtkComboBox, GtkComboBoxText, GtkConstraint, GtkConstraintGuide, GtkConstraintLayout, GtkConstraintLayoutChild, GtkCssProvider, GtkCustomFilter, GtkCustomLayout, GtkCustomSorter, GtkDialog, GtkDirectoryList, GtkDragIcon, GtkDragSource, GtkDrawingArea, GtkDropControllerMotion, GtkDropDown, GtkDropTarget, GtkDropTargetAsync, GtkEditableLabel, GtkEmojiChooser, GtkEntry, GtkEntryBuffer, GtkEntryCompletion, GtkEventController, GtkEventControllerFocus, GtkEventControllerKey, GtkEventControllerLegacy, GtkEventControllerMotion, GtkEventControllerScroll, GtkEveryFilter, GtkExpander, GtkExpression, GtkFileChooserDialog, GtkFileChooserNative, GtkFileChooserWidget, GtkFileFilter, GtkFilter, GtkFilterListModel, GtkFixed, GtkFixedLayout, GtkFixedLayoutChild, GtkFlattenListModel, GtkFlowBox, GtkFlowBoxChild, GtkFontButton, GtkFontChooserDialog, GtkFontChooserWidget, GtkFrame, GtkGLArea, GtkGesture, GtkGestureClick, GtkGestureDrag, GtkGestureLongPress, GtkGesturePan, GtkGestureRotate, GtkGestureSingle, GtkGestureStylus, GtkGestureSwipe, GtkGestureZoom, GtkGrid, GtkGridLayout, GtkGridLayoutChild, GtkGridView, GtkHeaderBar, GtkIMContext, GtkIMContextSimple, GtkIMMulticontext, GtkIconPaintable, GtkIconTheme, GtkIconView, GtkImage, GtkInfoBar, GtkInscription, GtkKeyvalTrigger, GtkLabel, GtkLayoutChild, GtkLayoutManager, GtkLevelBar, GtkLinkButton, GtkListBase, GtkListBox, GtkListBoxRow, GtkListItem, GtkListItemFactory, GtkListStore, GtkListView, GtkLockButton, GtkMapListModel, GtkMediaControls, GtkMediaFile, GtkMediaStream, GtkMenuButton, GtkMessageDialog, GtkMnemonicAction, GtkMnemonicTrigger, GtkMountOperation, GtkMultiFilter, GtkMultiSelection, GtkMultiSorter, GtkNamedAction, GtkNativeDialog, GtkNeverTrigger, GtkNoSelection, GtkNotebook, GtkNotebookPage, GtkNothingAction, GtkNumericSorter, GtkOverlay, GtkOverlayLayout, GtkOverlayLayoutChild, GtkPadController, GtkPageSetup, GtkPaned, GtkPasswordEntry, GtkPasswordEntryBuffer, GtkPicture, GtkPopover, GtkPopoverMenu, GtkPopoverMenuBar, GtkPrintContext, GtkPrintJob, GtkPrintOperation, GtkPrintSettings, GtkPrinter, GtkProgressBar, GtkRange, GtkRecentManager, GtkRevealer, GtkScale, GtkScaleButton, GtkScrollbar, GtkScrolledWindow, GtkSearchBar, GtkSearchEntry, GtkSelectionFilterModel, GtkSeparator, GtkSettings, GtkShortcut, GtkShortcutAction, GtkShortcutController, GtkShortcutLabel, GtkShortcutTrigger, GtkShortcutsGroup, GtkShortcutsSection, GtkShortcutsShortcut, GtkShortcutsWindow, GtkSignalAction, GtkSignalListItemFactory, GtkSingleSelection, GtkSizeGroup, GtkSliceListModel, GtkSnapshot, GtkSortListModel, GtkSorter, GtkSpinButton, GtkSpinner, GtkStack, GtkStackPage, GtkStackSidebar, GtkStackSwitcher, GtkStatusbar, GtkStringFilter, GtkStringList, GtkStringObject, GtkStringSorter, GtkStyleContext, GtkSwitch, GtkText, GtkTextBuffer, GtkTextChildAnchor, GtkTextMark, GtkTextTag, GtkTextTagTable, GtkTextView, GtkToggleButton, GtkTooltip, GtkTreeExpander, GtkTreeListModel, GtkTreeListRow, GtkTreeListRowSorter, GtkTreeModelFilter, GtkTreeModelSort, GtkTreeSelection, GtkTreeStore, GtkTreeView, GtkTreeViewColumn, GtkVideo, GtkViewport, GtkVolumeButton, GtkWidget, GtkWidgetPaintable, GtkWindow, GtkWindowControls, GtkWindowGroup, GtkWindowHandle, GtkAccessible, GtkActionable, GtkAppChooser, GtkBuildable, GtkBuilderScope, GtkCellEditable, GtkCellLayout, GtkColorChooser, GtkConstraintTarget, GtkEditable, GtkFileChooser, GtkFontChooser, GtkNative, GtkOrientable, GtkPrintOperationPreview, GtkRoot, GtkScrollable, GtkSelectionModel, GtkShortcutManager, GtkStyleProvider, GtkSymbolicPaintable, GtkTreeDragDest, GtkTreeDragSource, GtkTreeModel, GtkTreeSortable
end))
end
