begin
    mutable struct GtkAccessibleList <: GBoxed
        handle::Ptr{GtkAccessibleList}
        (GLib.g_type(::Type{T}) where T <: GtkAccessibleList) = ccall(("gtk_accessible_list_get_type", libgtk4), GType, ())
        function GtkAccessibleList(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, GtkAccessibleList)
    end
    const GtkAccessibleListLike = GtkAccessibleList
    struct _GtkAccessibleTextRange
        start::UInt64
        length::UInt64
    end
    mutable struct GtkAccessibleTextRange
        handle::Ptr{_GtkAccessibleTextRange}
    end
    unsafe_convert(::Type{Ptr{_GtkAccessibleTextRange}}, box::GtkAccessibleTextRange) = convert(Ptr{_GtkAccessibleTextRange}, box.handle)
    convert(::Type{GtkAccessibleTextRange}, p::Ptr{_GtkAccessibleTextRange}, owns = false) = GtkAccessibleTextRange(p, owns)
    const GtkAccessibleTextRangeLike = Union{Ref{_GtkAccessibleTextRange}, GtkAccessibleTextRange}
    convert(::Type{GtkAccessibleTextRangeLike}, p, owns) = convert(GtkAccessibleTextRange, p, owns)
    mutable struct GtkBitset <: GBoxed
        handle::Ptr{GtkBitset}
        (GLib.g_type(::Type{T}) where T <: GtkBitset) = ccall(("gtk_bitset_get_type", libgtk4), GType, ())
        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
    const GtkBitsetLike = GtkBitset
    mutable struct GtkBitsetIter <: GBoxed
        handle::Ptr{GtkBitsetIter}
        (GLib.g_type(::Type{T}) where T <: GtkBitsetIter) = ccall(("gtk_bitset_iter_get_type", libgtk4), GType, ())
        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
    const GtkBitsetIterLike = GtkBitsetIter
    const _GtkBitsetIter = GtkBitsetIter
    struct _GtkBorder
        left::Int16
        right::Int16
        top::Int16
        bottom::Int16
    end
    mutable struct GtkBorder <: GBoxed
        handle::Ptr{_GtkBorder}
        (GLib.g_type(::Type{T}) where T <: GtkBorder) = ccall(("gtk_border_get_type", libgtk4), GType, ())
        function GtkBorder(ref::Ptr{T}, own::Bool = false) where T <: Union{GBoxed, _GtkBorder}
            x = new(ref)
            if own
                finalizer(x) do x
                    GLib.delboxed
                    x
                end
            end
            x
        end
        push!(gboxed_types, GtkBorder)
    end
    unsafe_convert(::Type{Ptr{_GtkBorder}}, box::GtkBorder) = convert(Ptr{_GtkBorder}, box.handle)
    convert(::Type{GtkBorder}, p::Ptr{_GtkBorder}, owns = false) = GtkBorder(p, owns)
    const GtkBorderLike = Union{Ref{_GtkBorder}, GtkBorder}
    convert(::Type{GtkBorderLike}, p, owns) = convert(GtkBorder, p, owns)
    mutable struct GtkBuildableParseContext
        handle::Ptr{GtkBuildableParseContext}
    end
    const GtkBuildableParseContextLike = GtkBuildableParseContext
    mutable struct GtkBuildableParser
        handle::Ptr{GtkBuildableParser}
    end
    const GtkBuildableParserLike = GtkBuildableParser
    const _GtkBuildableParser = GtkBuildableParser
    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) = convert(Ptr{_GtkCssLocation}, box.handle)
    convert(::Type{GtkCssLocation}, p::Ptr{_GtkCssLocation}, owns = false) = GtkCssLocation(p, owns)
    const GtkCssLocationLike = Union{Ref{_GtkCssLocation}, GtkCssLocation}
    convert(::Type{GtkCssLocationLike}, p, owns) = convert(GtkCssLocation, p, owns)
    mutable struct GtkCssSection <: GBoxed
        handle::Ptr{GtkCssSection}
        (GLib.g_type(::Type{T}) where T <: GtkCssSection) = ccall(("gtk_css_section_get_type", libgtk4), GType, ())
        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
    const GtkCssSectionLike = GtkCssSection
    mutable struct GtkCssStyleChange
        handle::Ptr{GtkCssStyleChange}
    end
    const GtkCssStyleChangeLike = GtkCssStyleChange
    mutable struct GtkExpressionWatch <: GBoxed
        handle::Ptr{GtkExpressionWatch}
        (GLib.g_type(::Type{T}) where T <: GtkExpressionWatch) = ccall(("gtk_expression_watch_get_type", libgtk4), GType, ())
        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
    const GtkExpressionWatchLike = GtkExpressionWatch
    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) = convert(Ptr{_GtkPadActionEntry}, box.handle)
    convert(::Type{GtkPadActionEntry}, p::Ptr{_GtkPadActionEntry}, owns = false) = GtkPadActionEntry(p, owns)
    const GtkPadActionEntryLike = Union{Ref{_GtkPadActionEntry}, GtkPadActionEntry}
    convert(::Type{GtkPadActionEntryLike}, p, owns) = convert(GtkPadActionEntry, p, owns)
    mutable struct GtkPaperSize <: GBoxed
        handle::Ptr{GtkPaperSize}
        (GLib.g_type(::Type{T}) where T <: GtkPaperSize) = ccall(("gtk_paper_size_get_type", libgtk4), GType, ())
        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
    const GtkPaperSizeLike = GtkPaperSize
    mutable struct GtkPrintBackend
        handle::Ptr{GtkPrintBackend}
    end
    const GtkPrintBackendLike = GtkPrintBackend
    mutable struct GtkPrintSetup <: GBoxed
        handle::Ptr{GtkPrintSetup}
        (GLib.g_type(::Type{T}) where T <: GtkPrintSetup) = ccall(("gtk_print_setup_get_type", libgtk4), GType, ())
        function GtkPrintSetup(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, GtkPrintSetup)
    end
    const GtkPrintSetupLike = GtkPrintSetup
    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) = convert(Ptr{_GtkRecentData}, box.handle)
    convert(::Type{GtkRecentData}, p::Ptr{_GtkRecentData}, owns = false) = GtkRecentData(p, owns)
    const GtkRecentDataLike = Union{Ref{_GtkRecentData}, GtkRecentData}
    convert(::Type{GtkRecentDataLike}, p, owns) = convert(GtkRecentData, p, owns)
    mutable struct GtkRecentInfo <: GBoxed
        handle::Ptr{GtkRecentInfo}
        (GLib.g_type(::Type{T}) where T <: GtkRecentInfo) = ccall(("gtk_recent_info_get_type", libgtk4), GType, ())
        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
    const GtkRecentInfoLike = GtkRecentInfo
    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) = convert(Ptr{_GtkRequestedSize}, box.handle)
    convert(::Type{GtkRequestedSize}, p::Ptr{_GtkRequestedSize}, owns = false) = GtkRequestedSize(p, owns)
    const GtkRequestedSizeLike = Union{Ref{_GtkRequestedSize}, GtkRequestedSize}
    convert(::Type{GtkRequestedSizeLike}, p, owns) = convert(GtkRequestedSize, p, owns)
    struct _GtkRequisition
        width::Int32
        height::Int32
    end
    mutable struct GtkRequisition <: GBoxed
        handle::Ptr{_GtkRequisition}
        (GLib.g_type(::Type{T}) where T <: GtkRequisition) = ccall(("gtk_requisition_get_type", libgtk4), GType, ())
        function GtkRequisition(ref::Ptr{T}, own::Bool = false) where T <: Union{GBoxed, _GtkRequisition}
            x = new(ref)
            if own
                finalizer(x) do x
                    GLib.delboxed
                    x
                end
            end
            x
        end
        push!(gboxed_types, GtkRequisition)
    end
    unsafe_convert(::Type{Ptr{_GtkRequisition}}, box::GtkRequisition) = convert(Ptr{_GtkRequisition}, box.handle)
    convert(::Type{GtkRequisition}, p::Ptr{_GtkRequisition}, owns = false) = GtkRequisition(p, owns)
    const GtkRequisitionLike = Union{Ref{_GtkRequisition}, GtkRequisition}
    convert(::Type{GtkRequisitionLike}, p, owns) = convert(GtkRequisition, p, owns)
    mutable struct GtkScrollInfo <: GBoxed
        handle::Ptr{GtkScrollInfo}
        (GLib.g_type(::Type{T}) where T <: GtkScrollInfo) = ccall(("gtk_scroll_info_get_type", libgtk4), GType, ())
        function GtkScrollInfo(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, GtkScrollInfo)
    end
    const GtkScrollInfoLike = GtkScrollInfo
    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}
        (GLib.g_type(::Type{T}) where T <: GtkTextIter) = ccall(("gtk_text_iter_get_type", libgtk4), GType, ())
        function GtkTextIter(ref::Ptr{T}, own::Bool = false) where T <: Union{GBoxed, _GtkTextIter}
            x = new(ref)
            if own
                finalizer(x) do x
                    GLib.delboxed
                    x
                end
            end
            x
        end
        push!(gboxed_types, GtkTextIter)
    end
    unsafe_convert(::Type{Ptr{_GtkTextIter}}, box::GtkTextIter) = convert(Ptr{_GtkTextIter}, box.handle)
    convert(::Type{GtkTextIter}, p::Ptr{_GtkTextIter}, owns = false) = GtkTextIter(p, owns)
    const GtkTextIterLike = Union{Ref{_GtkTextIter}, GtkTextIter}
    convert(::Type{GtkTextIterLike}, p, owns) = convert(GtkTextIter, p, owns)
    struct _GtkTreeIter
        stamp::Int32
        user_data::Ptr{Nothing}
        user_data2::Ptr{Nothing}
        user_data3::Ptr{Nothing}
    end
    mutable struct GtkTreeIter <: GBoxed
        handle::Ptr{_GtkTreeIter}
        (GLib.g_type(::Type{T}) where T <: GtkTreeIter) = ccall(("gtk_tree_iter_get_type", libgtk4), GType, ())
        function GtkTreeIter(ref::Ptr{T}, own::Bool = false) where T <: Union{GBoxed, _GtkTreeIter}
            x = new(ref)
            if own
                finalizer(x) do x
                    GLib.delboxed
                    x
                end
            end
            x
        end
        push!(gboxed_types, GtkTreeIter)
    end
    unsafe_convert(::Type{Ptr{_GtkTreeIter}}, box::GtkTreeIter) = convert(Ptr{_GtkTreeIter}, box.handle)
    convert(::Type{GtkTreeIter}, p::Ptr{_GtkTreeIter}, owns = false) = GtkTreeIter(p, owns)
    const GtkTreeIterLike = Union{Ref{_GtkTreeIter}, GtkTreeIter}
    convert(::Type{GtkTreeIterLike}, p, owns) = convert(GtkTreeIter, p, owns)
    mutable struct GtkTreePath <: GBoxed
        handle::Ptr{GtkTreePath}
        (GLib.g_type(::Type{T}) where T <: GtkTreePath) = ccall(("gtk_tree_path_get_type", libgtk4), GType, ())
        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
    const GtkTreePathLike = GtkTreePath
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/struct.AccessibleList.html)." GtkAccessibleList
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/struct.AccessibleTextRange.html)." GtkAccessibleTextRange
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/struct.Bitset.html)." GtkBitset
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/struct.BitsetIter.html)." GtkBitsetIter
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/struct.Border.html)." GtkBorder
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/struct.BuildableParseContext.html)." GtkBuildableParseContext
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/struct.BuildableParser.html)." GtkBuildableParser
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/struct.CssLocation.html)." GtkCssLocation
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/struct.CssSection.html)." GtkCssSection
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/struct.CssStyleChange.html)." GtkCssStyleChange
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/struct.ExpressionWatch.html)." GtkExpressionWatch
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/struct.PadActionEntry.html)." GtkPadActionEntry
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/struct.PaperSize.html)." GtkPaperSize
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/struct.PrintBackend.html)." GtkPrintBackend
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/struct.PrintSetup.html)." GtkPrintSetup
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/struct.RecentData.html)." GtkRecentData
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/struct.RecentInfo.html)." GtkRecentInfo
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/struct.RequestedSize.html)." GtkRequestedSize
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/struct.Requisition.html)." GtkRequisition
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/struct.ScrollInfo.html)." GtkScrollInfo
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/struct.TextIter.html)." GtkTextIter
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/struct.TreeIter.html)." GtkTreeIter
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/struct.TreePath.html)." GtkTreePath
    GLib.@Giface GtkAccessible libgtk4 gtk_accessible_get_type
    GLib.@Giface GtkAccessibleRange libgtk4 gtk_accessible_range_get_type
    GLib.@Giface GtkAccessibleText libgtk4 gtk_accessible_text_get_type
    GLib.@Giface GtkActionable libgtk4 gtk_actionable_get_type
    GLib.@Giface GtkAppChooser libgtk4 gtk_app_chooser_get_type
    GLib.@Giface GtkBuildable libgtk4 gtk_buildable_get_type
    GLib.@Giface GtkBuilderScope libgtk4 gtk_builder_scope_get_type
    GLib.@Giface GtkCellEditable libgtk4 gtk_cell_editable_get_type
    GLib.@Giface GtkCellLayout libgtk4 gtk_cell_layout_get_type
    GLib.@Giface GtkColorChooser libgtk4 gtk_color_chooser_get_type
    GLib.@Giface GtkConstraintTarget libgtk4 gtk_constraint_target_get_type
    GLib.@Giface GtkEditable libgtk4 gtk_editable_get_type
    GLib.@Giface GtkFileChooser libgtk4 gtk_file_chooser_get_type
    GLib.@Giface GtkFontChooser libgtk4 gtk_font_chooser_get_type
    GLib.@Giface GtkNative libgtk4 gtk_native_get_type
    GLib.@Giface GtkOrientable libgtk4 gtk_orientable_get_type
    GLib.@Giface GtkPrintOperationPreview libgtk4 gtk_print_operation_preview_get_type
    GLib.@Giface GtkRoot libgtk4 gtk_root_get_type
    GLib.@Giface GtkScrollable libgtk4 gtk_scrollable_get_type
    GLib.@Giface GtkSectionModel libgtk4 gtk_section_model_get_type
    GLib.@Giface GtkSelectionModel libgtk4 gtk_selection_model_get_type
    GLib.@Giface GtkShortcutManager libgtk4 gtk_shortcut_manager_get_type
    GLib.@Giface GtkStyleProvider libgtk4 gtk_style_provider_get_type
    GLib.@Giface GtkSymbolicPaintable libgtk4 gtk_symbolic_paintable_get_type
    GLib.@Giface GtkTreeDragDest libgtk4 gtk_tree_drag_dest_get_type
    GLib.@Giface GtkTreeDragSource libgtk4 gtk_tree_drag_source_get_type
    GLib.@Giface GtkTreeModel libgtk4 gtk_tree_model_get_type
    GLib.@Giface GtkTreeSortable libgtk4 gtk_tree_sortable_get_type
    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
    gtype_wrapper_cache[:GtkATContext] = GtkATContextLeaf
    (GLib.g_type(::Type{T}) where T <: GtkATContext) = ccall(("gtk_at_context_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkATContext})
        vcat([:state_change], signalnames(supertype(GtkATContext)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :state_change => (:Nothing, Any[]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkATContext
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkATContext
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkWidget] = GtkWidgetLeaf
    (GLib.g_type(::Type{T}) where T <: GtkWidget) = ccall(("gtk_widget_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkWidget})
        vcat([:destroy, :direction_changed, :hide, :keynav_failed, :map, :mnemonic_activate, :move_focus, :query_tooltip, :realize, :show, :state_flags_changed, :unmap, :unrealize], signalnames(supertype(GtkWidget)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :state_flags_changed => (:Nothing, [:UInt32]), :map => (:Nothing, Any[]), :unrealize => (:Nothing, Any[]), :show => (:Nothing, Any[]), :unmap => (:Nothing, Any[]), :hide => (:Nothing, Any[]), :query_tooltip => (:Cint, Any[:Int32, :Int32, :Cint, :(Ptr{GObject})]), :move_focus => (:Nothing, [:UInt32]), :mnemonic_activate => (:Cint, [:Cint]), :direction_changed => (:Nothing, [:UInt32]), :destroy => (:Nothing, Any[]), :keynav_failed => (:Cint, [:UInt32]), :realize => (:Nothing, Any[]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkWidget
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkWidget
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkWindow] = GtkWindowLeaf
    (GLib.g_type(::Type{T}) where T <: GtkWindow) = ccall(("gtk_window_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkWindow})
        vcat([:activate_default, :activate_focus, :close_request, :enable_debugging, :keys_changed], signalnames(supertype(GtkWindow)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :state_flags_changed => (:Nothing, [:UInt32]), :map => (:Nothing, Any[]), :keys_changed => (:Nothing, Any[]), :close_request => (:Cint, Any[]), :enable_debugging => (:Cint, [:Cint]), :unrealize => (:Nothing, Any[]), :activate_focus => (:Nothing, Any[]), :show => (:Nothing, Any[]), :unmap => (:Nothing, Any[]), :hide => (:Nothing, Any[]), :query_tooltip => (:Cint, Any[:Int32, :Int32, :Cint, :(Ptr{GObject})]), :activate_default => (:Nothing, Any[]), :move_focus => (:Nothing, [:UInt32]), :mnemonic_activate => (:Cint, [:Cint]), :direction_changed => (:Nothing, [:UInt32]), :destroy => (:Nothing, Any[]), :keynav_failed => (:Cint, [:UInt32]), :realize => (:Nothing, Any[]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkWindow
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkWindow
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkAboutDialog] = GtkAboutDialogLeaf
    (GLib.g_type(::Type{T}) where T <: GtkAboutDialog) = ccall(("gtk_about_dialog_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkAboutDialog})
        vcat([:activate_link], signalnames(supertype(GtkAboutDialog)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :state_flags_changed => (:Nothing, [:UInt32]), :map => (:Nothing, Any[]), :activate_link => (:Cint, [:Cstring]), :keys_changed => (:Nothing, Any[]), :close_request => (:Cint, Any[]), :enable_debugging => (:Cint, [:Cint]), :unrealize => (:Nothing, Any[]), :activate_focus => (:Nothing, Any[]), :show => (:Nothing, Any[]), :unmap => (:Nothing, Any[]), :hide => (:Nothing, Any[]), :query_tooltip => (:Cint, Any[:Int32, :Int32, :Cint, :(Ptr{GObject})]), :activate_default => (:Nothing, Any[]), :move_focus => (:Nothing, [:UInt32]), :mnemonic_activate => (:Cint, [:Cint]), :direction_changed => (:Nothing, [:UInt32]), :destroy => (:Nothing, Any[]), :keynav_failed => (:Cint, [:UInt32]), :realize => (:Nothing, Any[]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkAboutDialog
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkAboutDialog
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkActionBar] = GtkActionBarLeaf
    (GLib.g_type(::Type{T}) where T <: GtkActionBar) = ccall(("gtk_action_bar_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkActionBar})
        signalnames(supertype(GtkActionBar))
    end
    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
    gtype_wrapper_cache[:GtkShortcutAction] = GtkShortcutActionLeaf
    (GLib.g_type(::Type{T}) where T <: GtkShortcutAction) = ccall(("gtk_shortcut_action_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkShortcutAction})
        signalnames(supertype(GtkShortcutAction))
    end
    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
    gtype_wrapper_cache[:GtkActivateAction] = GtkActivateActionLeaf
    (GLib.g_type(::Type{T}) where T <: GtkActivateAction) = ccall(("gtk_activate_action_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkActivateAction})
        signalnames(supertype(GtkActivateAction))
    end
    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
    gtype_wrapper_cache[:GtkAdjustment] = GtkAdjustmentLeaf
    (GLib.g_type(::Type{T}) where T <: GtkAdjustment) = ccall(("gtk_adjustment_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkAdjustment})
        vcat([:changed, :value_changed], signalnames(supertype(GtkAdjustment)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :changed => (:Nothing, Any[]), :value_changed => (:Nothing, Any[]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkAdjustment
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkAdjustment
            Tuple(eval.((d[name])[2]))
        end
    end
    abstract type GtkAlertDialog <: GObject end
    mutable struct GtkAlertDialogLeaf <: GtkAlertDialog
        handle::Ptr{GObject}
        function GtkAlertDialogLeaf(handle::Ptr{GObject}, owns = false)
            if handle == C_NULL
                error("Cannot construct GtkAlertDialogLeaf with a NULL pointer")
            end
            GLib.gobject_maybe_sink(handle, owns)
            return gobject_ref(new(handle))
        end
    end
    gtype_wrapper_cache[:GtkAlertDialog] = GtkAlertDialogLeaf
    (GLib.g_type(::Type{T}) where T <: GtkAlertDialog) = ccall(("gtk_alert_dialog_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkAlertDialog})
        signalnames(supertype(GtkAlertDialog))
    end
    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
    gtype_wrapper_cache[:GtkShortcutTrigger] = GtkShortcutTriggerLeaf
    (GLib.g_type(::Type{T}) where T <: GtkShortcutTrigger) = ccall(("gtk_shortcut_trigger_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkShortcutTrigger})
        signalnames(supertype(GtkShortcutTrigger))
    end
    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
    gtype_wrapper_cache[:GtkAlternativeTrigger] = GtkAlternativeTriggerLeaf
    (GLib.g_type(::Type{T}) where T <: GtkAlternativeTrigger) = ccall(("gtk_alternative_trigger_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkAlternativeTrigger})
        signalnames(supertype(GtkAlternativeTrigger))
    end
    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
    gtype_wrapper_cache[:GtkFilter] = GtkFilterLeaf
    (GLib.g_type(::Type{T}) where T <: GtkFilter) = ccall(("gtk_filter_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkFilter})
        vcat([:changed], signalnames(supertype(GtkFilter)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :changed => (:Nothing, [:UInt32]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkFilter
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkFilter
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkMultiFilter] = GtkMultiFilterLeaf
    (GLib.g_type(::Type{T}) where T <: GtkMultiFilter) = ccall(("gtk_multi_filter_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkMultiFilter})
        vcat([:items_changed], signalnames(supertype(GtkMultiFilter)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :changed => (:Nothing, [:UInt32]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkMultiFilter
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkMultiFilter
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkAnyFilter] = GtkAnyFilterLeaf
    (GLib.g_type(::Type{T}) where T <: GtkAnyFilter) = ccall(("gtk_any_filter_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkAnyFilter})
        vcat([:items_changed], signalnames(supertype(GtkAnyFilter)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :changed => (:Nothing, [:UInt32]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkAnyFilter
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkAnyFilter
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkAppChooserButton] = GtkAppChooserButtonLeaf
    (GLib.g_type(::Type{T}) where T <: GtkAppChooserButton) = ccall(("gtk_app_chooser_button_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkAppChooserButton})
        vcat([:activate, :changed, :custom_item_activated], signalnames(supertype(GtkAppChooserButton)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :state_flags_changed => (:Nothing, [:UInt32]), :map => (:Nothing, Any[]), :changed => (:Nothing, Any[]), :custom_item_activated => (:Nothing, [:Cstring]), :unrealize => (:Nothing, Any[]), :show => (:Nothing, Any[]), :unmap => (:Nothing, Any[]), :hide => (:Nothing, Any[]), :query_tooltip => (:Cint, Any[:Int32, :Int32, :Cint, :(Ptr{GObject})]), :move_focus => (:Nothing, [:UInt32]), :mnemonic_activate => (:Cint, [:Cint]), :direction_changed => (:Nothing, [:UInt32]), :activate => (:Nothing, Any[]), :destroy => (:Nothing, Any[]), :keynav_failed => (:Cint, [:UInt32]), :realize => (:Nothing, Any[]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkAppChooserButton
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkAppChooserButton
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkDialog] = GtkDialogLeaf
    (GLib.g_type(::Type{T}) where T <: GtkDialog) = ccall(("gtk_dialog_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkDialog})
        vcat([:close, :response], signalnames(supertype(GtkDialog)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :state_flags_changed => (:Nothing, [:UInt32]), :map => (:Nothing, Any[]), :close => (:Nothing, Any[]), :keys_changed => (:Nothing, Any[]), :close_request => (:Cint, Any[]), :enable_debugging => (:Cint, [:Cint]), :unrealize => (:Nothing, Any[]), :activate_focus => (:Nothing, Any[]), :show => (:Nothing, Any[]), :unmap => (:Nothing, Any[]), :hide => (:Nothing, Any[]), :query_tooltip => (:Cint, Any[:Int32, :Int32, :Cint, :(Ptr{GObject})]), :activate_default => (:Nothing, Any[]), :move_focus => (:Nothing, [:UInt32]), :mnemonic_activate => (:Cint, [:Cint]), :direction_changed => (:Nothing, [:UInt32]), :response => (:Nothing, [:Int32]), :destroy => (:Nothing, Any[]), :keynav_failed => (:Cint, [:UInt32]), :realize => (:Nothing, Any[]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkDialog
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkDialog
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkAppChooserDialog] = GtkAppChooserDialogLeaf
    (GLib.g_type(::Type{T}) where T <: GtkAppChooserDialog) = ccall(("gtk_app_chooser_dialog_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkAppChooserDialog})
        signalnames(supertype(GtkAppChooserDialog))
    end
    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
    gtype_wrapper_cache[:GtkAppChooserWidget] = GtkAppChooserWidgetLeaf
    (GLib.g_type(::Type{T}) where T <: GtkAppChooserWidget) = ccall(("gtk_app_chooser_widget_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkAppChooserWidget})
        vcat([:application_activated, :application_selected], signalnames(supertype(GtkAppChooserWidget)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :state_flags_changed => (:Nothing, [:UInt32]), :map => (:Nothing, Any[]), :application_selected => (:Nothing, Expr[:(Ptr{GObject})]), :unrealize => (:Nothing, Any[]), :application_activated => (:Nothing, Expr[:(Ptr{GObject})]), :show => (:Nothing, Any[]), :unmap => (:Nothing, Any[]), :hide => (:Nothing, Any[]), :query_tooltip => (:Cint, Any[:Int32, :Int32, :Cint, :(Ptr{GObject})]), :move_focus => (:Nothing, [:UInt32]), :mnemonic_activate => (:Cint, [:Cint]), :direction_changed => (:Nothing, [:UInt32]), :destroy => (:Nothing, Any[]), :keynav_failed => (:Cint, [:UInt32]), :realize => (:Nothing, Any[]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkAppChooserWidget
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkAppChooserWidget
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkApplication] = GtkApplicationLeaf
    (GLib.g_type(::Type{T}) where T <: GtkApplication) = ccall(("gtk_application_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkApplication})
        vcat([:query_end, :window_added, :window_removed, :action_added, :action_enabled_changed, :action_removed, :action_state_changed], signalnames(supertype(GtkApplication)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :startup => (:Nothing, Any[]), :command_line => (:Int32, Expr[:(Ptr{GObject})]), :open => (:Nothing, Any[:(Ptr{Ptr{GObject}}), :Int32, :Cstring]), :window_removed => (:Nothing, Expr[:(Ptr{GObject})]), :shutdown => (:Nothing, Any[]), :name_lost => (:Cint, Any[]), :window_added => (:Nothing, Expr[:(Ptr{GObject})]), :activate => (:Nothing, Any[]), :handle_local_options => (:Int32, [:GVariantDict]), :query_end => (:Nothing, Any[]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkApplication
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkApplication
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkApplicationWindow] = GtkApplicationWindowLeaf
    (GLib.g_type(::Type{T}) where T <: GtkApplicationWindow) = ccall(("gtk_application_window_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkApplicationWindow})
        vcat([:action_added, :action_enabled_changed, :action_removed, :action_state_changed], signalnames(supertype(GtkApplicationWindow)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :state_flags_changed => (:Nothing, [:UInt32]), :map => (:Nothing, Any[]), :keys_changed => (:Nothing, Any[]), :close_request => (:Cint, Any[]), :enable_debugging => (:Cint, [:Cint]), :unrealize => (:Nothing, Any[]), :activate_focus => (:Nothing, Any[]), :show => (:Nothing, Any[]), :unmap => (:Nothing, Any[]), :hide => (:Nothing, Any[]), :query_tooltip => (:Cint, Any[:Int32, :Int32, :Cint, :(Ptr{GObject})]), :activate_default => (:Nothing, Any[]), :move_focus => (:Nothing, [:UInt32]), :mnemonic_activate => (:Cint, [:Cint]), :direction_changed => (:Nothing, [:UInt32]), :destroy => (:Nothing, Any[]), :keynav_failed => (:Cint, [:UInt32]), :realize => (:Nothing, Any[]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkApplicationWindow
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkApplicationWindow
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkAspectFrame] = GtkAspectFrameLeaf
    (GLib.g_type(::Type{T}) where T <: GtkAspectFrame) = ccall(("gtk_aspect_frame_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkAspectFrame})
        signalnames(supertype(GtkAspectFrame))
    end
    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
    gtype_wrapper_cache[:GtkAssistant] = GtkAssistantLeaf
    (GLib.g_type(::Type{T}) where T <: GtkAssistant) = ccall(("gtk_assistant_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkAssistant})
        vcat([:apply, :cancel, :close, :escape, :prepare], signalnames(supertype(GtkAssistant)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :map => (:Nothing, Any[]), :escape => (:Nothing, Any[]), :activate_focus => (:Nothing, Any[]), :prepare => (:Nothing, Expr[:(Ptr{GObject})]), :activate_default => (:Nothing, Any[]), :move_focus => (:Nothing, [:UInt32]), :direction_changed => (:Nothing, [:UInt32]), :cancel => (:Nothing, Any[]), :close => (:Nothing, Any[]), :state_flags_changed => (:Nothing, [:UInt32]), :keys_changed => (:Nothing, Any[]), :close_request => (:Cint, Any[]), :enable_debugging => (:Cint, [:Cint]), :unrealize => (:Nothing, Any[]), :apply => (:Nothing, Any[]), :show => (:Nothing, Any[]), :unmap => (:Nothing, Any[]), :hide => (:Nothing, Any[]), :query_tooltip => (:Cint, Any[:Int32, :Int32, :Cint, :(Ptr{GObject})]), :mnemonic_activate => (:Cint, [:Cint]), :destroy => (:Nothing, Any[]), :keynav_failed => (:Cint, [:UInt32]), :realize => (:Nothing, Any[]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkAssistant
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkAssistant
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkAssistantPage] = GtkAssistantPageLeaf
    (GLib.g_type(::Type{T}) where T <: GtkAssistantPage) = ccall(("gtk_assistant_page_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkAssistantPage})
        signalnames(supertype(GtkAssistantPage))
    end
    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
    gtype_wrapper_cache[:GtkLayoutManager] = GtkLayoutManagerLeaf
    (GLib.g_type(::Type{T}) where T <: GtkLayoutManager) = ccall(("gtk_layout_manager_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkLayoutManager})
        signalnames(supertype(GtkLayoutManager))
    end
    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
    gtype_wrapper_cache[:GtkBinLayout] = GtkBinLayoutLeaf
    (GLib.g_type(::Type{T}) where T <: GtkBinLayout) = ccall(("gtk_bin_layout_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkBinLayout})
        signalnames(supertype(GtkBinLayout))
    end
    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
    gtype_wrapper_cache[:GtkBookmarkList] = GtkBookmarkListLeaf
    (GLib.g_type(::Type{T}) where T <: GtkBookmarkList) = ccall(("gtk_bookmark_list_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkBookmarkList})
        vcat([:items_changed], signalnames(supertype(GtkBookmarkList)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkBookmarkList
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkBookmarkList
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkBoolFilter] = GtkBoolFilterLeaf
    (GLib.g_type(::Type{T}) where T <: GtkBoolFilter) = ccall(("gtk_bool_filter_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkBoolFilter})
        signalnames(supertype(GtkBoolFilter))
    end
    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
    gtype_wrapper_cache[:GtkBox] = GtkBoxLeaf
    (GLib.g_type(::Type{T}) where T <: GtkBox) = ccall(("gtk_box_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkBox})
        signalnames(supertype(GtkBox))
    end
    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
    gtype_wrapper_cache[:GtkBoxLayout] = GtkBoxLayoutLeaf
    (GLib.g_type(::Type{T}) where T <: GtkBoxLayout) = ccall(("gtk_box_layout_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkBoxLayout})
        signalnames(supertype(GtkBoxLayout))
    end
    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
    gtype_wrapper_cache[:GtkBuilder] = GtkBuilderLeaf
    (GLib.g_type(::Type{T}) where T <: GtkBuilder) = ccall(("gtk_builder_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkBuilder})
        signalnames(supertype(GtkBuilder))
    end
    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
    gtype_wrapper_cache[:GtkBuilderCScope] = GtkBuilderCScopeLeaf
    (GLib.g_type(::Type{T}) where T <: GtkBuilderCScope) = ccall(("gtk_builder_cscope_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkBuilderCScope})
        signalnames(supertype(GtkBuilderCScope))
    end
    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
    gtype_wrapper_cache[:GtkListItemFactory] = GtkListItemFactoryLeaf
    (GLib.g_type(::Type{T}) where T <: GtkListItemFactory) = ccall(("gtk_list_item_factory_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkListItemFactory})
        signalnames(supertype(GtkListItemFactory))
    end
    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
    gtype_wrapper_cache[:GtkBuilderListItemFactory] = GtkBuilderListItemFactoryLeaf
    (GLib.g_type(::Type{T}) where T <: GtkBuilderListItemFactory) = ccall(("gtk_builder_list_item_factory_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkBuilderListItemFactory})
        signalnames(supertype(GtkBuilderListItemFactory))
    end
    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
    gtype_wrapper_cache[:GtkButton] = GtkButtonLeaf
    (GLib.g_type(::Type{T}) where T <: GtkButton) = ccall(("gtk_button_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkButton})
        vcat([:activate, :clicked], signalnames(supertype(GtkButton)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :state_flags_changed => (:Nothing, [:UInt32]), :map => (:Nothing, Any[]), :unrealize => (:Nothing, Any[]), :show => (:Nothing, Any[]), :unmap => (:Nothing, Any[]), :hide => (:Nothing, Any[]), :query_tooltip => (:Cint, Any[:Int32, :Int32, :Cint, :(Ptr{GObject})]), :clicked => (:Nothing, Any[]), :move_focus => (:Nothing, [:UInt32]), :mnemonic_activate => (:Cint, [:Cint]), :direction_changed => (:Nothing, [:UInt32]), :activate => (:Nothing, Any[]), :destroy => (:Nothing, Any[]), :keynav_failed => (:Cint, [:UInt32]), :realize => (:Nothing, Any[]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkButton
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkButton
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkCalendar] = GtkCalendarLeaf
    (GLib.g_type(::Type{T}) where T <: GtkCalendar) = ccall(("gtk_calendar_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkCalendar})
        vcat([:day_selected, :next_month, :next_year, :prev_month, :prev_year], signalnames(supertype(GtkCalendar)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :state_flags_changed => (:Nothing, [:UInt32]), :map => (:Nothing, Any[]), :next_year => (:Nothing, Any[]), :next_month => (:Nothing, Any[]), :unrealize => (:Nothing, Any[]), :day_selected => (:Nothing, Any[]), :show => (:Nothing, Any[]), :unmap => (:Nothing, Any[]), :hide => (:Nothing, Any[]), :query_tooltip => (:Cint, Any[:Int32, :Int32, :Cint, :(Ptr{GObject})]), :prev_year => (:Nothing, Any[]), :move_focus => (:Nothing, [:UInt32]), :mnemonic_activate => (:Cint, [:Cint]), :direction_changed => (:Nothing, [:UInt32]), :prev_month => (:Nothing, Any[]), :destroy => (:Nothing, Any[]), :keynav_failed => (:Cint, [:UInt32]), :realize => (:Nothing, Any[]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkCalendar
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkCalendar
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkCallbackAction] = GtkCallbackActionLeaf
    (GLib.g_type(::Type{T}) where T <: GtkCallbackAction) = ccall(("gtk_callback_action_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkCallbackAction})
        signalnames(supertype(GtkCallbackAction))
    end
    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
    gtype_wrapper_cache[:GtkCellArea] = GtkCellAreaLeaf
    (GLib.g_type(::Type{T}) where T <: GtkCellArea) = ccall(("gtk_cell_area_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkCellArea})
        vcat([:add_editable, :apply_attributes, :focus_changed, :remove_editable], signalnames(supertype(GtkCellArea)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :apply_attributes => (:Nothing, Any[:(Ptr{GObject}), :_GtkTreeIter, :Cint, :Cint]), :remove_editable => (:Nothing, Expr[:(Ptr{GObject}), :(Ptr{GtkWidget})]), :focus_changed => (:Nothing, Any[:(Ptr{GObject}), :Cstring]), :add_editable => (:Nothing, Any[:(Ptr{GObject}), :(Ptr{GtkWidget}), :_GdkRectangle, :Cstring]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkCellArea
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkCellArea
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkCellAreaBox] = GtkCellAreaBoxLeaf
    (GLib.g_type(::Type{T}) where T <: GtkCellAreaBox) = ccall(("gtk_cell_area_box_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkCellAreaBox})
        signalnames(supertype(GtkCellAreaBox))
    end
    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
    gtype_wrapper_cache[:GtkCellAreaContext] = GtkCellAreaContextLeaf
    (GLib.g_type(::Type{T}) where T <: GtkCellAreaContext) = ccall(("gtk_cell_area_context_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkCellAreaContext})
        signalnames(supertype(GtkCellAreaContext))
    end
    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
    gtype_wrapper_cache[:GtkCellRenderer] = GtkCellRendererLeaf
    (GLib.g_type(::Type{T}) where T <: GtkCellRenderer) = ccall(("gtk_cell_renderer_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkCellRenderer})
        vcat([:editing_canceled, :editing_started], signalnames(supertype(GtkCellRenderer)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :editing_canceled => (:Nothing, Any[]), :editing_started => (:Nothing, Any[:(Ptr{GtkWidget}), :Cstring]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkCellRenderer
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkCellRenderer
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkCellRendererText] = GtkCellRendererTextLeaf
    (GLib.g_type(::Type{T}) where T <: GtkCellRendererText) = ccall(("gtk_cell_renderer_text_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkCellRendererText})
        vcat([:edited], signalnames(supertype(GtkCellRendererText)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :editing_canceled => (:Nothing, Any[]), :editing_started => (:Nothing, Any[:(Ptr{GtkWidget}), :Cstring]), :edited => (:Nothing, [:Cstring, :Cstring]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkCellRendererText
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkCellRendererText
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkCellRendererAccel] = GtkCellRendererAccelLeaf
    (GLib.g_type(::Type{T}) where T <: GtkCellRendererAccel) = ccall(("gtk_cell_renderer_accel_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkCellRendererAccel})
        vcat([:accel_cleared, :accel_edited], signalnames(supertype(GtkCellRendererAccel)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :accel_edited => (:Nothing, [:Cstring, :UInt32, :UInt32, :UInt32]), :editing_canceled => (:Nothing, Any[]), :editing_started => (:Nothing, Any[:(Ptr{GtkWidget}), :Cstring]), :accel_cleared => (:Nothing, [:Cstring]), :edited => (:Nothing, [:Cstring, :Cstring]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkCellRendererAccel
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkCellRendererAccel
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkCellRendererCombo] = GtkCellRendererComboLeaf
    (GLib.g_type(::Type{T}) where T <: GtkCellRendererCombo) = ccall(("gtk_cell_renderer_combo_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkCellRendererCombo})
        vcat([:changed], signalnames(supertype(GtkCellRendererCombo)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :editing_canceled => (:Nothing, Any[]), :editing_started => (:Nothing, Any[:(Ptr{GtkWidget}), :Cstring]), :changed => (:Nothing, [:Cstring, :_GtkTreeIter]), :edited => (:Nothing, [:Cstring, :Cstring]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkCellRendererCombo
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkCellRendererCombo
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkCellRendererPixbuf] = GtkCellRendererPixbufLeaf
    (GLib.g_type(::Type{T}) where T <: GtkCellRendererPixbuf) = ccall(("gtk_cell_renderer_pixbuf_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkCellRendererPixbuf})
        signalnames(supertype(GtkCellRendererPixbuf))
    end
    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
    gtype_wrapper_cache[:GtkCellRendererProgress] = GtkCellRendererProgressLeaf
    (GLib.g_type(::Type{T}) where T <: GtkCellRendererProgress) = ccall(("gtk_cell_renderer_progress_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkCellRendererProgress})
        signalnames(supertype(GtkCellRendererProgress))
    end
    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
    gtype_wrapper_cache[:GtkCellRendererSpin] = GtkCellRendererSpinLeaf
    (GLib.g_type(::Type{T}) where T <: GtkCellRendererSpin) = ccall(("gtk_cell_renderer_spin_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkCellRendererSpin})
        signalnames(supertype(GtkCellRendererSpin))
    end
    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
    gtype_wrapper_cache[:GtkCellRendererSpinner] = GtkCellRendererSpinnerLeaf
    (GLib.g_type(::Type{T}) where T <: GtkCellRendererSpinner) = ccall(("gtk_cell_renderer_spinner_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkCellRendererSpinner})
        signalnames(supertype(GtkCellRendererSpinner))
    end
    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
    gtype_wrapper_cache[:GtkCellRendererToggle] = GtkCellRendererToggleLeaf
    (GLib.g_type(::Type{T}) where T <: GtkCellRendererToggle) = ccall(("gtk_cell_renderer_toggle_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkCellRendererToggle})
        vcat([:toggled], signalnames(supertype(GtkCellRendererToggle)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :editing_canceled => (:Nothing, Any[]), :editing_started => (:Nothing, Any[:(Ptr{GtkWidget}), :Cstring]), :toggled => (:Nothing, [:Cstring]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkCellRendererToggle
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkCellRendererToggle
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkCellView] = GtkCellViewLeaf
    (GLib.g_type(::Type{T}) where T <: GtkCellView) = ccall(("gtk_cell_view_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkCellView})
        signalnames(supertype(GtkCellView))
    end
    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
    gtype_wrapper_cache[:GtkCenterBox] = GtkCenterBoxLeaf
    (GLib.g_type(::Type{T}) where T <: GtkCenterBox) = ccall(("gtk_center_box_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkCenterBox})
        signalnames(supertype(GtkCenterBox))
    end
    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
    gtype_wrapper_cache[:GtkCenterLayout] = GtkCenterLayoutLeaf
    (GLib.g_type(::Type{T}) where T <: GtkCenterLayout) = ccall(("gtk_center_layout_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkCenterLayout})
        signalnames(supertype(GtkCenterLayout))
    end
    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
    gtype_wrapper_cache[:GtkCheckButton] = GtkCheckButtonLeaf
    (GLib.g_type(::Type{T}) where T <: GtkCheckButton) = ccall(("gtk_check_button_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkCheckButton})
        vcat([:activate, :toggled], signalnames(supertype(GtkCheckButton)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :state_flags_changed => (:Nothing, [:UInt32]), :map => (:Nothing, Any[]), :unrealize => (:Nothing, Any[]), :toggled => (:Nothing, Any[]), :show => (:Nothing, Any[]), :unmap => (:Nothing, Any[]), :hide => (:Nothing, Any[]), :query_tooltip => (:Cint, Any[:Int32, :Int32, :Cint, :(Ptr{GObject})]), :move_focus => (:Nothing, [:UInt32]), :mnemonic_activate => (:Cint, [:Cint]), :direction_changed => (:Nothing, [:UInt32]), :activate => (:Nothing, Any[]), :destroy => (:Nothing, Any[]), :keynav_failed => (:Cint, [:UInt32]), :realize => (:Nothing, Any[]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkCheckButton
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkCheckButton
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkColorButton] = GtkColorButtonLeaf
    (GLib.g_type(::Type{T}) where T <: GtkColorButton) = ccall(("gtk_color_button_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkColorButton})
        vcat([:activate, :color_set, :color_activated], signalnames(supertype(GtkColorButton)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :state_flags_changed => (:Nothing, [:UInt32]), :map => (:Nothing, Any[]), :unrealize => (:Nothing, Any[]), :color_set => (:Nothing, Any[]), :show => (:Nothing, Any[]), :unmap => (:Nothing, Any[]), :hide => (:Nothing, Any[]), :query_tooltip => (:Cint, Any[:Int32, :Int32, :Cint, :(Ptr{GObject})]), :move_focus => (:Nothing, [:UInt32]), :mnemonic_activate => (:Cint, [:Cint]), :direction_changed => (:Nothing, [:UInt32]), :activate => (:Nothing, Any[]), :destroy => (:Nothing, Any[]), :keynav_failed => (:Cint, [:UInt32]), :realize => (:Nothing, Any[]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkColorButton
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkColorButton
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkColorChooserDialog] = GtkColorChooserDialogLeaf
    (GLib.g_type(::Type{T}) where T <: GtkColorChooserDialog) = ccall(("gtk_color_chooser_dialog_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkColorChooserDialog})
        vcat([:color_activated], signalnames(supertype(GtkColorChooserDialog)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :state_flags_changed => (:Nothing, [:UInt32]), :map => (:Nothing, Any[]), :close => (:Nothing, Any[]), :keys_changed => (:Nothing, Any[]), :close_request => (:Cint, Any[]), :enable_debugging => (:Cint, [:Cint]), :unrealize => (:Nothing, Any[]), :activate_focus => (:Nothing, Any[]), :show => (:Nothing, Any[]), :unmap => (:Nothing, Any[]), :hide => (:Nothing, Any[]), :query_tooltip => (:Cint, Any[:Int32, :Int32, :Cint, :(Ptr{GObject})]), :activate_default => (:Nothing, Any[]), :move_focus => (:Nothing, [:UInt32]), :mnemonic_activate => (:Cint, [:Cint]), :direction_changed => (:Nothing, [:UInt32]), :response => (:Nothing, [:Int32]), :destroy => (:Nothing, Any[]), :keynav_failed => (:Cint, [:UInt32]), :realize => (:Nothing, Any[]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkColorChooserDialog
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkColorChooserDialog
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkColorChooserWidget] = GtkColorChooserWidgetLeaf
    (GLib.g_type(::Type{T}) where T <: GtkColorChooserWidget) = ccall(("gtk_color_chooser_widget_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkColorChooserWidget})
        vcat([:color_activated], signalnames(supertype(GtkColorChooserWidget)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :state_flags_changed => (:Nothing, [:UInt32]), :map => (:Nothing, Any[]), :unrealize => (:Nothing, Any[]), :show => (:Nothing, Any[]), :unmap => (:Nothing, Any[]), :hide => (:Nothing, Any[]), :query_tooltip => (:Cint, Any[:Int32, :Int32, :Cint, :(Ptr{GObject})]), :move_focus => (:Nothing, [:UInt32]), :mnemonic_activate => (:Cint, [:Cint]), :direction_changed => (:Nothing, [:UInt32]), :destroy => (:Nothing, Any[]), :keynav_failed => (:Cint, [:UInt32]), :realize => (:Nothing, Any[]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkColorChooserWidget
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkColorChooserWidget
            Tuple(eval.((d[name])[2]))
        end
    end
    abstract type GtkColorDialog <: GObject end
    mutable struct GtkColorDialogLeaf <: GtkColorDialog
        handle::Ptr{GObject}
        function GtkColorDialogLeaf(handle::Ptr{GObject}, owns = false)
            if handle == C_NULL
                error("Cannot construct GtkColorDialogLeaf with a NULL pointer")
            end
            GLib.gobject_maybe_sink(handle, owns)
            return gobject_ref(new(handle))
        end
    end
    gtype_wrapper_cache[:GtkColorDialog] = GtkColorDialogLeaf
    (GLib.g_type(::Type{T}) where T <: GtkColorDialog) = ccall(("gtk_color_dialog_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkColorDialog})
        signalnames(supertype(GtkColorDialog))
    end
    abstract type GtkColorDialogButton <: GtkWidget end
    mutable struct GtkColorDialogButtonLeaf <: GtkColorDialogButton
        handle::Ptr{GObject}
        function GtkColorDialogButtonLeaf(handle::Ptr{GObject}, owns = false)
            if handle == C_NULL
                error("Cannot construct GtkColorDialogButtonLeaf with a NULL pointer")
            end
            GLib.gobject_maybe_sink(handle, owns)
            return gobject_ref(new(handle))
        end
    end
    gtype_wrapper_cache[:GtkColorDialogButton] = GtkColorDialogButtonLeaf
    (GLib.g_type(::Type{T}) where T <: GtkColorDialogButton) = ccall(("gtk_color_dialog_button_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkColorDialogButton})
        vcat([:activate], signalnames(supertype(GtkColorDialogButton)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :state_flags_changed => (:Nothing, [:UInt32]), :map => (:Nothing, Any[]), :unrealize => (:Nothing, Any[]), :show => (:Nothing, Any[]), :unmap => (:Nothing, Any[]), :hide => (:Nothing, Any[]), :query_tooltip => (:Cint, Any[:Int32, :Int32, :Cint, :(Ptr{GObject})]), :move_focus => (:Nothing, [:UInt32]), :mnemonic_activate => (:Cint, [:Cint]), :direction_changed => (:Nothing, [:UInt32]), :activate => (:Nothing, Any[]), :destroy => (:Nothing, Any[]), :keynav_failed => (:Cint, [:UInt32]), :realize => (:Nothing, Any[]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkColorDialogButton
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkColorDialogButton
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkColumnView] = GtkColumnViewLeaf
    (GLib.g_type(::Type{T}) where T <: GtkColumnView) = ccall(("gtk_column_view_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkColumnView})
        vcat([:activate], signalnames(supertype(GtkColumnView)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :state_flags_changed => (:Nothing, [:UInt32]), :map => (:Nothing, Any[]), :unrealize => (:Nothing, Any[]), :show => (:Nothing, Any[]), :unmap => (:Nothing, Any[]), :hide => (:Nothing, Any[]), :query_tooltip => (:Cint, Any[:Int32, :Int32, :Cint, :(Ptr{GObject})]), :move_focus => (:Nothing, [:UInt32]), :mnemonic_activate => (:Cint, [:Cint]), :direction_changed => (:Nothing, [:UInt32]), :activate => (:Nothing, [:UInt32]), :destroy => (:Nothing, Any[]), :keynav_failed => (:Cint, [:UInt32]), :realize => (:Nothing, Any[]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkColumnView
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkColumnView
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkListItem] = GtkListItemLeaf
    (GLib.g_type(::Type{T}) where T <: GtkListItem) = ccall(("gtk_list_item_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkListItem})
        signalnames(supertype(GtkListItem))
    end
    abstract type GtkColumnViewCell <: GtkListItem end
    mutable struct GtkColumnViewCellLeaf <: GtkColumnViewCell
        handle::Ptr{GObject}
        function GtkColumnViewCellLeaf(handle::Ptr{GObject}, owns = false)
            if handle == C_NULL
                error("Cannot construct GtkColumnViewCellLeaf with a NULL pointer")
            end
            GLib.gobject_maybe_sink(handle, owns)
            return gobject_ref(new(handle))
        end
    end
    gtype_wrapper_cache[:GtkColumnViewCell] = GtkColumnViewCellLeaf
    (GLib.g_type(::Type{T}) where T <: GtkColumnViewCell) = ccall(("gtk_column_view_cell_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkColumnViewCell})
        signalnames(supertype(GtkColumnViewCell))
    end
    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
    gtype_wrapper_cache[:GtkColumnViewColumn] = GtkColumnViewColumnLeaf
    (GLib.g_type(::Type{T}) where T <: GtkColumnViewColumn) = ccall(("gtk_column_view_column_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkColumnViewColumn})
        signalnames(supertype(GtkColumnViewColumn))
    end
    abstract type GtkColumnViewRow <: GObject end
    mutable struct GtkColumnViewRowLeaf <: GtkColumnViewRow
        handle::Ptr{GObject}
        function GtkColumnViewRowLeaf(handle::Ptr{GObject}, owns = false)
            if handle == C_NULL
                error("Cannot construct GtkColumnViewRowLeaf with a NULL pointer")
            end
            GLib.gobject_maybe_sink(handle, owns)
            return gobject_ref(new(handle))
        end
    end
    gtype_wrapper_cache[:GtkColumnViewRow] = GtkColumnViewRowLeaf
    (GLib.g_type(::Type{T}) where T <: GtkColumnViewRow) = ccall(("gtk_column_view_row_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkColumnViewRow})
        signalnames(supertype(GtkColumnViewRow))
    end
    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
    gtype_wrapper_cache[:GtkSorter] = GtkSorterLeaf
    (GLib.g_type(::Type{T}) where T <: GtkSorter) = ccall(("gtk_sorter_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkSorter})
        vcat([:changed], signalnames(supertype(GtkSorter)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :changed => (:Nothing, [:UInt32]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkSorter
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkSorter
            Tuple(eval.((d[name])[2]))
        end
    end
    abstract type GtkColumnViewSorter <: GtkSorter end
    mutable struct GtkColumnViewSorterLeaf <: GtkColumnViewSorter
        handle::Ptr{GObject}
        function GtkColumnViewSorterLeaf(handle::Ptr{GObject}, owns = false)
            if handle == C_NULL
                error("Cannot construct GtkColumnViewSorterLeaf with a NULL pointer")
            end
            GLib.gobject_maybe_sink(handle, owns)
            return gobject_ref(new(handle))
        end
    end
    gtype_wrapper_cache[:GtkColumnViewSorter] = GtkColumnViewSorterLeaf
    (GLib.g_type(::Type{T}) where T <: GtkColumnViewSorter) = ccall(("gtk_column_view_sorter_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkColumnViewSorter})
        signalnames(supertype(GtkColumnViewSorter))
    end
    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
    gtype_wrapper_cache[:GtkComboBox] = GtkComboBoxLeaf
    (GLib.g_type(::Type{T}) where T <: GtkComboBox) = ccall(("gtk_combo_box_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkComboBox})
        vcat([:activate, :changed, :format_entry_text, :move_active, :popdown, :popup, :editing_done, :remove_widget], signalnames(supertype(GtkComboBox)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :state_flags_changed => (:Nothing, [:UInt32]), :map => (:Nothing, Any[]), :changed => (:Nothing, Any[]), :popdown => (:Cint, Any[]), :unrealize => (:Nothing, Any[]), :move_active => (:Nothing, [:UInt32]), :popup => (:Nothing, Any[]), :format_entry_text => (:Cstring, [:Cstring]), :show => (:Nothing, Any[]), :unmap => (:Nothing, Any[]), :hide => (:Nothing, Any[]), :query_tooltip => (:Cint, Any[:Int32, :Int32, :Cint, :(Ptr{GObject})]), :move_focus => (:Nothing, [:UInt32]), :mnemonic_activate => (:Cint, [:Cint]), :direction_changed => (:Nothing, [:UInt32]), :activate => (:Nothing, Any[]), :destroy => (:Nothing, Any[]), :keynav_failed => (:Cint, [:UInt32]), :realize => (:Nothing, Any[]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkComboBox
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkComboBox
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkComboBoxText] = GtkComboBoxTextLeaf
    (GLib.g_type(::Type{T}) where T <: GtkComboBoxText) = ccall(("gtk_combo_box_text_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkComboBoxText})
        vcat([:editing_done, :remove_widget], signalnames(supertype(GtkComboBoxText)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :state_flags_changed => (:Nothing, [:UInt32]), :map => (:Nothing, Any[]), :changed => (:Nothing, Any[]), :popdown => (:Cint, Any[]), :unrealize => (:Nothing, Any[]), :move_active => (:Nothing, [:UInt32]), :popup => (:Nothing, Any[]), :format_entry_text => (:Cstring, [:Cstring]), :show => (:Nothing, Any[]), :unmap => (:Nothing, Any[]), :hide => (:Nothing, Any[]), :query_tooltip => (:Cint, Any[:Int32, :Int32, :Cint, :(Ptr{GObject})]), :move_focus => (:Nothing, [:UInt32]), :mnemonic_activate => (:Cint, [:Cint]), :direction_changed => (:Nothing, [:UInt32]), :activate => (:Nothing, Any[]), :destroy => (:Nothing, Any[]), :keynav_failed => (:Cint, [:UInt32]), :realize => (:Nothing, Any[]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkComboBoxText
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkComboBoxText
            Tuple(eval.((d[name])[2]))
        end
    end
    abstract type GtkExpression <: GTypeInstance end
    Base.convert(::Type{GtkExpression}, ptr::Ptr{GtkExpression}) = GtkExpressionLeaf(ptr)
    Base.unsafe_convert(::Type{Ptr{GtkExpression}}, o::GtkExpression) = o.handle
    mutable struct GtkExpressionLeaf <: GtkExpression
        handle::Ptr{GtkExpression}
    end
    abstract type GtkConstantExpression <: GtkExpression end
    mutable struct GtkConstantExpressionLeaf <: GtkConstantExpression
        handle::Ptr{GtkExpression}
    end
    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
    gtype_wrapper_cache[:GtkConstraint] = GtkConstraintLeaf
    (GLib.g_type(::Type{T}) where T <: GtkConstraint) = ccall(("gtk_constraint_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkConstraint})
        signalnames(supertype(GtkConstraint))
    end
    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
    gtype_wrapper_cache[:GtkConstraintGuide] = GtkConstraintGuideLeaf
    (GLib.g_type(::Type{T}) where T <: GtkConstraintGuide) = ccall(("gtk_constraint_guide_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkConstraintGuide})
        signalnames(supertype(GtkConstraintGuide))
    end
    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
    gtype_wrapper_cache[:GtkConstraintLayout] = GtkConstraintLayoutLeaf
    (GLib.g_type(::Type{T}) where T <: GtkConstraintLayout) = ccall(("gtk_constraint_layout_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkConstraintLayout})
        signalnames(supertype(GtkConstraintLayout))
    end
    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
    gtype_wrapper_cache[:GtkLayoutChild] = GtkLayoutChildLeaf
    (GLib.g_type(::Type{T}) where T <: GtkLayoutChild) = ccall(("gtk_layout_child_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkLayoutChild})
        signalnames(supertype(GtkLayoutChild))
    end
    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
    gtype_wrapper_cache[:GtkConstraintLayoutChild] = GtkConstraintLayoutChildLeaf
    (GLib.g_type(::Type{T}) where T <: GtkConstraintLayoutChild) = ccall(("gtk_constraint_layout_child_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkConstraintLayoutChild})
        signalnames(supertype(GtkConstraintLayoutChild))
    end
    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
    gtype_wrapper_cache[:GtkCssProvider] = GtkCssProviderLeaf
    (GLib.g_type(::Type{T}) where T <: GtkCssProvider) = ccall(("gtk_css_provider_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkCssProvider})
        vcat([:parsing_error, :gtk_private_changed], signalnames(supertype(GtkCssProvider)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :parsing_error => (:Nothing, Any[:GtkCssSection, :(Ptr{GError})]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkCssProvider
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkCssProvider
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkCustomFilter] = GtkCustomFilterLeaf
    (GLib.g_type(::Type{T}) where T <: GtkCustomFilter) = ccall(("gtk_custom_filter_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkCustomFilter})
        signalnames(supertype(GtkCustomFilter))
    end
    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
    gtype_wrapper_cache[:GtkCustomLayout] = GtkCustomLayoutLeaf
    (GLib.g_type(::Type{T}) where T <: GtkCustomLayout) = ccall(("gtk_custom_layout_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkCustomLayout})
        signalnames(supertype(GtkCustomLayout))
    end
    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
    gtype_wrapper_cache[:GtkCustomSorter] = GtkCustomSorterLeaf
    (GLib.g_type(::Type{T}) where T <: GtkCustomSorter) = ccall(("gtk_custom_sorter_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkCustomSorter})
        signalnames(supertype(GtkCustomSorter))
    end
    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
    gtype_wrapper_cache[:GtkDirectoryList] = GtkDirectoryListLeaf
    (GLib.g_type(::Type{T}) where T <: GtkDirectoryList) = ccall(("gtk_directory_list_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkDirectoryList})
        vcat([:items_changed], signalnames(supertype(GtkDirectoryList)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkDirectoryList
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkDirectoryList
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkDragIcon] = GtkDragIconLeaf
    (GLib.g_type(::Type{T}) where T <: GtkDragIcon) = ccall(("gtk_drag_icon_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkDragIcon})
        signalnames(supertype(GtkDragIcon))
    end
    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
    gtype_wrapper_cache[:GtkEventController] = GtkEventControllerLeaf
    (GLib.g_type(::Type{T}) where T <: GtkEventController) = ccall(("gtk_event_controller_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkEventController})
        signalnames(supertype(GtkEventController))
    end
    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
    gtype_wrapper_cache[:GtkGesture] = GtkGestureLeaf
    (GLib.g_type(::Type{T}) where T <: GtkGesture) = ccall(("gtk_gesture_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkGesture})
        vcat([:begin, :cancel, :end, :sequence_state_changed, :update], signalnames(supertype(GtkGesture)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :begin => (:Nothing, [:GdkEventSequence]), :update => (:Nothing, [:GdkEventSequence]), :end => (:Nothing, [:GdkEventSequence]), :cancel => (:Nothing, [:GdkEventSequence]), :sequence_state_changed => (:Nothing, [:GdkEventSequence, :UInt32]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkGesture
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkGesture
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkGestureSingle] = GtkGestureSingleLeaf
    (GLib.g_type(::Type{T}) where T <: GtkGestureSingle) = ccall(("gtk_gesture_single_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkGestureSingle})
        signalnames(supertype(GtkGestureSingle))
    end
    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
    gtype_wrapper_cache[:GtkDragSource] = GtkDragSourceLeaf
    (GLib.g_type(::Type{T}) where T <: GtkDragSource) = ccall(("gtk_drag_source_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkDragSource})
        vcat([:drag_begin, :drag_cancel, :drag_end, :prepare], signalnames(supertype(GtkDragSource)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :begin => (:Nothing, [:GdkEventSequence]), :drag_begin => (:Nothing, Expr[:(Ptr{GObject})]), :drag_cancel => (:Cint, Any[:(Ptr{GObject}), :UInt32]), :prepare => (:(Ptr{GObject}), [:Float64, :Float64]), :update => (:Nothing, [:GdkEventSequence]), :end => (:Nothing, [:GdkEventSequence]), :drag_end => (:Nothing, Any[:(Ptr{GObject}), :Cint]), :cancel => (:Nothing, [:GdkEventSequence]), :sequence_state_changed => (:Nothing, [:GdkEventSequence, :UInt32]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkDragSource
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkDragSource
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkDrawingArea] = GtkDrawingAreaLeaf
    (GLib.g_type(::Type{T}) where T <: GtkDrawingArea) = ccall(("gtk_drawing_area_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkDrawingArea})
        vcat([:resize], signalnames(supertype(GtkDrawingArea)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :state_flags_changed => (:Nothing, [:UInt32]), :map => (:Nothing, Any[]), :unrealize => (:Nothing, Any[]), :show => (:Nothing, Any[]), :unmap => (:Nothing, Any[]), :resize => (:Nothing, [:Int32, :Int32]), :hide => (:Nothing, Any[]), :query_tooltip => (:Cint, Any[:Int32, :Int32, :Cint, :(Ptr{GObject})]), :move_focus => (:Nothing, [:UInt32]), :mnemonic_activate => (:Cint, [:Cint]), :direction_changed => (:Nothing, [:UInt32]), :destroy => (:Nothing, Any[]), :keynav_failed => (:Cint, [:UInt32]), :realize => (:Nothing, Any[]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkDrawingArea
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkDrawingArea
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkDropControllerMotion] = GtkDropControllerMotionLeaf
    (GLib.g_type(::Type{T}) where T <: GtkDropControllerMotion) = ccall(("gtk_drop_controller_motion_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkDropControllerMotion})
        vcat([:enter, :leave, :motion], signalnames(supertype(GtkDropControllerMotion)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :enter => (:Nothing, [:Float64, :Float64]), :motion => (:Nothing, [:Float64, :Float64]), :leave => (:Nothing, Any[]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkDropControllerMotion
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkDropControllerMotion
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkDropDown] = GtkDropDownLeaf
    (GLib.g_type(::Type{T}) where T <: GtkDropDown) = ccall(("gtk_drop_down_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkDropDown})
        vcat([:activate], signalnames(supertype(GtkDropDown)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :state_flags_changed => (:Nothing, [:UInt32]), :map => (:Nothing, Any[]), :unrealize => (:Nothing, Any[]), :show => (:Nothing, Any[]), :unmap => (:Nothing, Any[]), :hide => (:Nothing, Any[]), :query_tooltip => (:Cint, Any[:Int32, :Int32, :Cint, :(Ptr{GObject})]), :move_focus => (:Nothing, [:UInt32]), :mnemonic_activate => (:Cint, [:Cint]), :direction_changed => (:Nothing, [:UInt32]), :activate => (:Nothing, Any[]), :destroy => (:Nothing, Any[]), :keynav_failed => (:Cint, [:UInt32]), :realize => (:Nothing, Any[]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkDropDown
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkDropDown
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkDropTarget] = GtkDropTargetLeaf
    (GLib.g_type(::Type{T}) where T <: GtkDropTarget) = ccall(("gtk_drop_target_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkDropTarget})
        vcat([:accept, :drop, :enter, :leave, :motion], signalnames(supertype(GtkDropTarget)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :accept => (:Cint, Expr[:(Ptr{GObject})]), :enter => (:UInt32, [:Float64, :Float64]), :drop => (:Cint, [:_GValue, :Float64, :Float64]), :motion => (:UInt32, [:Float64, :Float64]), :leave => (:Nothing, Any[]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkDropTarget
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkDropTarget
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkDropTargetAsync] = GtkDropTargetAsyncLeaf
    (GLib.g_type(::Type{T}) where T <: GtkDropTargetAsync) = ccall(("gtk_drop_target_async_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkDropTargetAsync})
        vcat([:accept, :drag_enter, :drag_leave, :drag_motion, :drop], signalnames(supertype(GtkDropTargetAsync)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :accept => (:Cint, Expr[:(Ptr{GObject})]), :drag_motion => (:UInt32, Any[:(Ptr{GObject}), :Float64, :Float64]), :drag_leave => (:Nothing, Expr[:(Ptr{GObject})]), :drop => (:Cint, Any[:(Ptr{GObject}), :Float64, :Float64]), :drag_enter => (:UInt32, Any[:(Ptr{GObject}), :Float64, :Float64]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkDropTargetAsync
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkDropTargetAsync
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkEditableLabel] = GtkEditableLabelLeaf
    (GLib.g_type(::Type{T}) where T <: GtkEditableLabel) = ccall(("gtk_editable_label_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkEditableLabel})
        vcat([:changed, :delete_text, :insert_text], signalnames(supertype(GtkEditableLabel)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :state_flags_changed => (:Nothing, [:UInt32]), :map => (:Nothing, Any[]), :unrealize => (:Nothing, Any[]), :show => (:Nothing, Any[]), :unmap => (:Nothing, Any[]), :hide => (:Nothing, Any[]), :query_tooltip => (:Cint, Any[:Int32, :Int32, :Cint, :(Ptr{GObject})]), :move_focus => (:Nothing, [:UInt32]), :mnemonic_activate => (:Cint, [:Cint]), :direction_changed => (:Nothing, [:UInt32]), :destroy => (:Nothing, Any[]), :keynav_failed => (:Cint, [:UInt32]), :realize => (:Nothing, Any[]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkEditableLabel
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkEditableLabel
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkPopover] = GtkPopoverLeaf
    (GLib.g_type(::Type{T}) where T <: GtkPopover) = ccall(("gtk_popover_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkPopover})
        vcat([:activate_default, :closed], signalnames(supertype(GtkPopover)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :state_flags_changed => (:Nothing, [:UInt32]), :map => (:Nothing, Any[]), :unrealize => (:Nothing, Any[]), :closed => (:Nothing, Any[]), :show => (:Nothing, Any[]), :unmap => (:Nothing, Any[]), :hide => (:Nothing, Any[]), :query_tooltip => (:Cint, Any[:Int32, :Int32, :Cint, :(Ptr{GObject})]), :activate_default => (:Nothing, Any[]), :move_focus => (:Nothing, [:UInt32]), :mnemonic_activate => (:Cint, [:Cint]), :direction_changed => (:Nothing, [:UInt32]), :destroy => (:Nothing, Any[]), :keynav_failed => (:Cint, [:UInt32]), :realize => (:Nothing, Any[]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkPopover
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkPopover
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkEmojiChooser] = GtkEmojiChooserLeaf
    (GLib.g_type(::Type{T}) where T <: GtkEmojiChooser) = ccall(("gtk_emoji_chooser_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkEmojiChooser})
        vcat([:emoji_picked], signalnames(supertype(GtkEmojiChooser)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :state_flags_changed => (:Nothing, [:UInt32]), :map => (:Nothing, Any[]), :unrealize => (:Nothing, Any[]), :closed => (:Nothing, Any[]), :show => (:Nothing, Any[]), :unmap => (:Nothing, Any[]), :emoji_picked => (:Nothing, [:Cstring]), :hide => (:Nothing, Any[]), :query_tooltip => (:Cint, Any[:Int32, :Int32, :Cint, :(Ptr{GObject})]), :activate_default => (:Nothing, Any[]), :move_focus => (:Nothing, [:UInt32]), :mnemonic_activate => (:Cint, [:Cint]), :direction_changed => (:Nothing, [:UInt32]), :destroy => (:Nothing, Any[]), :keynav_failed => (:Cint, [:UInt32]), :realize => (:Nothing, Any[]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkEmojiChooser
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkEmojiChooser
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkEntry] = GtkEntryLeaf
    (GLib.g_type(::Type{T}) where T <: GtkEntry) = ccall(("gtk_entry_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkEntry})
        vcat([:activate, :icon_press, :icon_release, :editing_done, :remove_widget, :changed, :delete_text, :insert_text], signalnames(supertype(GtkEntry)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :state_flags_changed => (:Nothing, [:UInt32]), :map => (:Nothing, Any[]), :icon_release => (:Nothing, [:UInt32]), :unrealize => (:Nothing, Any[]), :icon_press => (:Nothing, [:UInt32]), :show => (:Nothing, Any[]), :unmap => (:Nothing, Any[]), :hide => (:Nothing, Any[]), :query_tooltip => (:Cint, Any[:Int32, :Int32, :Cint, :(Ptr{GObject})]), :move_focus => (:Nothing, [:UInt32]), :mnemonic_activate => (:Cint, [:Cint]), :direction_changed => (:Nothing, [:UInt32]), :activate => (:Nothing, Any[]), :destroy => (:Nothing, Any[]), :keynav_failed => (:Cint, [:UInt32]), :realize => (:Nothing, Any[]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkEntry
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkEntry
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkEntryBuffer] = GtkEntryBufferLeaf
    (GLib.g_type(::Type{T}) where T <: GtkEntryBuffer) = ccall(("gtk_entry_buffer_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkEntryBuffer})
        vcat([:deleted_text, :inserted_text], signalnames(supertype(GtkEntryBuffer)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :inserted_text => (:Nothing, [:UInt32, :Cstring, :UInt32]), :deleted_text => (:Nothing, [:UInt32, :UInt32]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkEntryBuffer
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkEntryBuffer
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkEntryCompletion] = GtkEntryCompletionLeaf
    (GLib.g_type(::Type{T}) where T <: GtkEntryCompletion) = ccall(("gtk_entry_completion_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkEntryCompletion})
        vcat([:cursor_on_match, :insert_prefix, :match_selected, :no_matches], signalnames(supertype(GtkEntryCompletion)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :cursor_on_match => (:Cint, Any[:(Ptr{GObject}), :_GtkTreeIter]), :match_selected => (:Cint, Any[:(Ptr{GObject}), :_GtkTreeIter]), :insert_prefix => (:Cint, [:Cstring]), :no_matches => (:Nothing, Any[]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkEntryCompletion
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkEntryCompletion
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkEventControllerFocus] = GtkEventControllerFocusLeaf
    (GLib.g_type(::Type{T}) where T <: GtkEventControllerFocus) = ccall(("gtk_event_controller_focus_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkEventControllerFocus})
        vcat([:enter, :leave], signalnames(supertype(GtkEventControllerFocus)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :enter => (:Nothing, Any[]), :leave => (:Nothing, Any[]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkEventControllerFocus
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkEventControllerFocus
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkEventControllerKey] = GtkEventControllerKeyLeaf
    (GLib.g_type(::Type{T}) where T <: GtkEventControllerKey) = ccall(("gtk_event_controller_key_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkEventControllerKey})
        vcat([:im_update, :key_pressed, :key_released, :modifiers], signalnames(supertype(GtkEventControllerKey)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :key_released => (:Nothing, [:UInt32, :UInt32, :UInt32]), :im_update => (:Nothing, Any[]), :key_pressed => (:Cint, [:UInt32, :UInt32, :UInt32]), :modifiers => (:Cint, [:UInt32]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkEventControllerKey
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkEventControllerKey
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkEventControllerLegacy] = GtkEventControllerLegacyLeaf
    (GLib.g_type(::Type{T}) where T <: GtkEventControllerLegacy) = ccall(("gtk_event_controller_legacy_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkEventControllerLegacy})
        vcat([:event], signalnames(supertype(GtkEventControllerLegacy)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :event => (:Cint, [:GdkEvent]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkEventControllerLegacy
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkEventControllerLegacy
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkEventControllerMotion] = GtkEventControllerMotionLeaf
    (GLib.g_type(::Type{T}) where T <: GtkEventControllerMotion) = ccall(("gtk_event_controller_motion_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkEventControllerMotion})
        vcat([:enter, :leave, :motion], signalnames(supertype(GtkEventControllerMotion)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :enter => (:Nothing, [:Float64, :Float64]), :motion => (:Nothing, [:Float64, :Float64]), :leave => (:Nothing, Any[]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkEventControllerMotion
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkEventControllerMotion
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkEventControllerScroll] = GtkEventControllerScrollLeaf
    (GLib.g_type(::Type{T}) where T <: GtkEventControllerScroll) = ccall(("gtk_event_controller_scroll_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkEventControllerScroll})
        vcat([:decelerate, :scroll, :scroll_begin, :scroll_end], signalnames(supertype(GtkEventControllerScroll)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :scroll => (:Cint, [:Float64, :Float64]), :decelerate => (:Nothing, [:Float64, :Float64]), :scroll_end => (:Nothing, Any[]), :scroll_begin => (:Nothing, Any[]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkEventControllerScroll
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkEventControllerScroll
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkEveryFilter] = GtkEveryFilterLeaf
    (GLib.g_type(::Type{T}) where T <: GtkEveryFilter) = ccall(("gtk_every_filter_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkEveryFilter})
        vcat([:items_changed], signalnames(supertype(GtkEveryFilter)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :changed => (:Nothing, [:UInt32]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkEveryFilter
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkEveryFilter
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkExpander] = GtkExpanderLeaf
    (GLib.g_type(::Type{T}) where T <: GtkExpander) = ccall(("gtk_expander_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkExpander})
        vcat([:activate], signalnames(supertype(GtkExpander)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :state_flags_changed => (:Nothing, [:UInt32]), :map => (:Nothing, Any[]), :unrealize => (:Nothing, Any[]), :show => (:Nothing, Any[]), :unmap => (:Nothing, Any[]), :hide => (:Nothing, Any[]), :query_tooltip => (:Cint, Any[:Int32, :Int32, :Cint, :(Ptr{GObject})]), :move_focus => (:Nothing, [:UInt32]), :mnemonic_activate => (:Cint, [:Cint]), :direction_changed => (:Nothing, [:UInt32]), :activate => (:Nothing, Any[]), :destroy => (:Nothing, Any[]), :keynav_failed => (:Cint, [:UInt32]), :realize => (:Nothing, Any[]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkExpander
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkExpander
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkFileChooserDialog] = GtkFileChooserDialogLeaf
    (GLib.g_type(::Type{T}) where T <: GtkFileChooserDialog) = ccall(("gtk_file_chooser_dialog_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkFileChooserDialog})
        signalnames(supertype(GtkFileChooserDialog))
    end
    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
    gtype_wrapper_cache[:GtkNativeDialog] = GtkNativeDialogLeaf
    (GLib.g_type(::Type{T}) where T <: GtkNativeDialog) = ccall(("gtk_native_dialog_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkNativeDialog})
        vcat([:response], signalnames(supertype(GtkNativeDialog)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :response => (:Nothing, [:Int32]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkNativeDialog
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkNativeDialog
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkFileChooserNative] = GtkFileChooserNativeLeaf
    (GLib.g_type(::Type{T}) where T <: GtkFileChooserNative) = ccall(("gtk_file_chooser_native_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkFileChooserNative})
        signalnames(supertype(GtkFileChooserNative))
    end
    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
    gtype_wrapper_cache[:GtkFileChooserWidget] = GtkFileChooserWidgetLeaf
    (GLib.g_type(::Type{T}) where T <: GtkFileChooserWidget) = ccall(("gtk_file_chooser_widget_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkFileChooserWidget})
        vcat([:desktop_folder, :down_folder, :home_folder, :location_popup, :location_popup_on_paste, :location_toggle_popup, :places_shortcut, :quick_bookmark, :recent_shortcut, :search_shortcut, :show_hidden, :up_folder], signalnames(supertype(GtkFileChooserWidget)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :location_popup_on_paste => (:Nothing, Any[]), :map => (:Nothing, Any[]), :show_hidden => (:Nothing, Any[]), :location_popup => (:Nothing, [:Cstring]), :quick_bookmark => (:Nothing, [:Int32]), :move_focus => (:Nothing, [:UInt32]), :direction_changed => (:Nothing, [:UInt32]), :state_flags_changed => (:Nothing, [:UInt32]), :home_folder => (:Nothing, Any[]), :down_folder => (:Nothing, Any[]), :unrealize => (:Nothing, Any[]), :location_toggle_popup => (:Nothing, Any[]), :desktop_folder => (:Nothing, Any[]), :places_shortcut => (:Nothing, Any[]), :show => (:Nothing, Any[]), :unmap => (:Nothing, Any[]), :hide => (:Nothing, Any[]), :query_tooltip => (:Cint, Any[:Int32, :Int32, :Cint, :(Ptr{GObject})]), :recent_shortcut => (:Nothing, Any[]), :up_folder => (:Nothing, Any[]), :mnemonic_activate => (:Cint, [:Cint]), :search_shortcut => (:Nothing, Any[]), :destroy => (:Nothing, Any[]), :keynav_failed => (:Cint, [:UInt32]), :realize => (:Nothing, Any[]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkFileChooserWidget
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkFileChooserWidget
            Tuple(eval.((d[name])[2]))
        end
    end
    abstract type GtkFileDialog <: GObject end
    mutable struct GtkFileDialogLeaf <: GtkFileDialog
        handle::Ptr{GObject}
        function GtkFileDialogLeaf(handle::Ptr{GObject}, owns = false)
            if handle == C_NULL
                error("Cannot construct GtkFileDialogLeaf with a NULL pointer")
            end
            GLib.gobject_maybe_sink(handle, owns)
            return gobject_ref(new(handle))
        end
    end
    gtype_wrapper_cache[:GtkFileDialog] = GtkFileDialogLeaf
    (GLib.g_type(::Type{T}) where T <: GtkFileDialog) = ccall(("gtk_file_dialog_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkFileDialog})
        signalnames(supertype(GtkFileDialog))
    end
    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
    gtype_wrapper_cache[:GtkFileFilter] = GtkFileFilterLeaf
    (GLib.g_type(::Type{T}) where T <: GtkFileFilter) = ccall(("gtk_file_filter_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkFileFilter})
        signalnames(supertype(GtkFileFilter))
    end
    abstract type GtkFileLauncher <: GObject end
    mutable struct GtkFileLauncherLeaf <: GtkFileLauncher
        handle::Ptr{GObject}
        function GtkFileLauncherLeaf(handle::Ptr{GObject}, owns = false)
            if handle == C_NULL
                error("Cannot construct GtkFileLauncherLeaf with a NULL pointer")
            end
            GLib.gobject_maybe_sink(handle, owns)
            return gobject_ref(new(handle))
        end
    end
    gtype_wrapper_cache[:GtkFileLauncher] = GtkFileLauncherLeaf
    (GLib.g_type(::Type{T}) where T <: GtkFileLauncher) = ccall(("gtk_file_launcher_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkFileLauncher})
        signalnames(supertype(GtkFileLauncher))
    end
    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
    gtype_wrapper_cache[:GtkFilterListModel] = GtkFilterListModelLeaf
    (GLib.g_type(::Type{T}) where T <: GtkFilterListModel) = ccall(("gtk_filter_list_model_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkFilterListModel})
        vcat([:items_changed, :sections_changed], signalnames(supertype(GtkFilterListModel)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkFilterListModel
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkFilterListModel
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkFixed] = GtkFixedLeaf
    (GLib.g_type(::Type{T}) where T <: GtkFixed) = ccall(("gtk_fixed_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkFixed})
        signalnames(supertype(GtkFixed))
    end
    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
    gtype_wrapper_cache[:GtkFixedLayout] = GtkFixedLayoutLeaf
    (GLib.g_type(::Type{T}) where T <: GtkFixedLayout) = ccall(("gtk_fixed_layout_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkFixedLayout})
        signalnames(supertype(GtkFixedLayout))
    end
    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
    gtype_wrapper_cache[:GtkFixedLayoutChild] = GtkFixedLayoutChildLeaf
    (GLib.g_type(::Type{T}) where T <: GtkFixedLayoutChild) = ccall(("gtk_fixed_layout_child_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkFixedLayoutChild})
        signalnames(supertype(GtkFixedLayoutChild))
    end
    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
    gtype_wrapper_cache[:GtkFlattenListModel] = GtkFlattenListModelLeaf
    (GLib.g_type(::Type{T}) where T <: GtkFlattenListModel) = ccall(("gtk_flatten_list_model_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkFlattenListModel})
        vcat([:items_changed, :sections_changed], signalnames(supertype(GtkFlattenListModel)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkFlattenListModel
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkFlattenListModel
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkFlowBox] = GtkFlowBoxLeaf
    (GLib.g_type(::Type{T}) where T <: GtkFlowBox) = ccall(("gtk_flow_box_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkFlowBox})
        vcat([:activate_cursor_child, :child_activated, :move_cursor, :select_all, :selected_children_changed, :toggle_cursor_child, :unselect_all], signalnames(supertype(GtkFlowBox)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :state_flags_changed => (:Nothing, [:UInt32]), :map => (:Nothing, Any[]), :select_all => (:Nothing, Any[]), :activate_cursor_child => (:Nothing, Any[]), :child_activated => (:Nothing, Expr[:(Ptr{GObject})]), :selected_children_changed => (:Nothing, Any[]), :unrealize => (:Nothing, Any[]), :unselect_all => (:Nothing, Any[]), :move_cursor => (:Cint, [:UInt32, :Int32, :Cint, :Cint]), :show => (:Nothing, Any[]), :unmap => (:Nothing, Any[]), :hide => (:Nothing, Any[]), :query_tooltip => (:Cint, Any[:Int32, :Int32, :Cint, :(Ptr{GObject})]), :toggle_cursor_child => (:Nothing, Any[]), :move_focus => (:Nothing, [:UInt32]), :mnemonic_activate => (:Cint, [:Cint]), :direction_changed => (:Nothing, [:UInt32]), :destroy => (:Nothing, Any[]), :keynav_failed => (:Cint, [:UInt32]), :realize => (:Nothing, Any[]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkFlowBox
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkFlowBox
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkFlowBoxChild] = GtkFlowBoxChildLeaf
    (GLib.g_type(::Type{T}) where T <: GtkFlowBoxChild) = ccall(("gtk_flow_box_child_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkFlowBoxChild})
        vcat([:activate], signalnames(supertype(GtkFlowBoxChild)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :state_flags_changed => (:Nothing, [:UInt32]), :map => (:Nothing, Any[]), :unrealize => (:Nothing, Any[]), :show => (:Nothing, Any[]), :unmap => (:Nothing, Any[]), :hide => (:Nothing, Any[]), :query_tooltip => (:Cint, Any[:Int32, :Int32, :Cint, :(Ptr{GObject})]), :move_focus => (:Nothing, [:UInt32]), :mnemonic_activate => (:Cint, [:Cint]), :direction_changed => (:Nothing, [:UInt32]), :activate => (:Nothing, Any[]), :destroy => (:Nothing, Any[]), :keynav_failed => (:Cint, [:UInt32]), :realize => (:Nothing, Any[]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkFlowBoxChild
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkFlowBoxChild
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkFontButton] = GtkFontButtonLeaf
    (GLib.g_type(::Type{T}) where T <: GtkFontButton) = ccall(("gtk_font_button_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkFontButton})
        vcat([:activate, :font_set, :font_activated], signalnames(supertype(GtkFontButton)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :state_flags_changed => (:Nothing, [:UInt32]), :map => (:Nothing, Any[]), :unrealize => (:Nothing, Any[]), :font_set => (:Nothing, Any[]), :show => (:Nothing, Any[]), :unmap => (:Nothing, Any[]), :hide => (:Nothing, Any[]), :query_tooltip => (:Cint, Any[:Int32, :Int32, :Cint, :(Ptr{GObject})]), :move_focus => (:Nothing, [:UInt32]), :mnemonic_activate => (:Cint, [:Cint]), :direction_changed => (:Nothing, [:UInt32]), :activate => (:Nothing, Any[]), :destroy => (:Nothing, Any[]), :keynav_failed => (:Cint, [:UInt32]), :realize => (:Nothing, Any[]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkFontButton
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkFontButton
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkFontChooserDialog] = GtkFontChooserDialogLeaf
    (GLib.g_type(::Type{T}) where T <: GtkFontChooserDialog) = ccall(("gtk_font_chooser_dialog_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkFontChooserDialog})
        vcat([:font_activated], signalnames(supertype(GtkFontChooserDialog)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :state_flags_changed => (:Nothing, [:UInt32]), :map => (:Nothing, Any[]), :close => (:Nothing, Any[]), :keys_changed => (:Nothing, Any[]), :close_request => (:Cint, Any[]), :enable_debugging => (:Cint, [:Cint]), :unrealize => (:Nothing, Any[]), :activate_focus => (:Nothing, Any[]), :show => (:Nothing, Any[]), :unmap => (:Nothing, Any[]), :hide => (:Nothing, Any[]), :query_tooltip => (:Cint, Any[:Int32, :Int32, :Cint, :(Ptr{GObject})]), :activate_default => (:Nothing, Any[]), :move_focus => (:Nothing, [:UInt32]), :mnemonic_activate => (:Cint, [:Cint]), :direction_changed => (:Nothing, [:UInt32]), :response => (:Nothing, [:Int32]), :destroy => (:Nothing, Any[]), :keynav_failed => (:Cint, [:UInt32]), :realize => (:Nothing, Any[]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkFontChooserDialog
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkFontChooserDialog
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkFontChooserWidget] = GtkFontChooserWidgetLeaf
    (GLib.g_type(::Type{T}) where T <: GtkFontChooserWidget) = ccall(("gtk_font_chooser_widget_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkFontChooserWidget})
        vcat([:font_activated], signalnames(supertype(GtkFontChooserWidget)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :state_flags_changed => (:Nothing, [:UInt32]), :map => (:Nothing, Any[]), :unrealize => (:Nothing, Any[]), :show => (:Nothing, Any[]), :unmap => (:Nothing, Any[]), :hide => (:Nothing, Any[]), :query_tooltip => (:Cint, Any[:Int32, :Int32, :Cint, :(Ptr{GObject})]), :move_focus => (:Nothing, [:UInt32]), :mnemonic_activate => (:Cint, [:Cint]), :direction_changed => (:Nothing, [:UInt32]), :destroy => (:Nothing, Any[]), :keynav_failed => (:Cint, [:UInt32]), :realize => (:Nothing, Any[]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkFontChooserWidget
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkFontChooserWidget
            Tuple(eval.((d[name])[2]))
        end
    end
    abstract type GtkFontDialog <: GObject end
    mutable struct GtkFontDialogLeaf <: GtkFontDialog
        handle::Ptr{GObject}
        function GtkFontDialogLeaf(handle::Ptr{GObject}, owns = false)
            if handle == C_NULL
                error("Cannot construct GtkFontDialogLeaf with a NULL pointer")
            end
            GLib.gobject_maybe_sink(handle, owns)
            return gobject_ref(new(handle))
        end
    end
    gtype_wrapper_cache[:GtkFontDialog] = GtkFontDialogLeaf
    (GLib.g_type(::Type{T}) where T <: GtkFontDialog) = ccall(("gtk_font_dialog_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkFontDialog})
        signalnames(supertype(GtkFontDialog))
    end
    abstract type GtkFontDialogButton <: GtkWidget end
    mutable struct GtkFontDialogButtonLeaf <: GtkFontDialogButton
        handle::Ptr{GObject}
        function GtkFontDialogButtonLeaf(handle::Ptr{GObject}, owns = false)
            if handle == C_NULL
                error("Cannot construct GtkFontDialogButtonLeaf with a NULL pointer")
            end
            GLib.gobject_maybe_sink(handle, owns)
            return gobject_ref(new(handle))
        end
    end
    gtype_wrapper_cache[:GtkFontDialogButton] = GtkFontDialogButtonLeaf
    (GLib.g_type(::Type{T}) where T <: GtkFontDialogButton) = ccall(("gtk_font_dialog_button_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkFontDialogButton})
        vcat([:activate], signalnames(supertype(GtkFontDialogButton)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :state_flags_changed => (:Nothing, [:UInt32]), :map => (:Nothing, Any[]), :unrealize => (:Nothing, Any[]), :show => (:Nothing, Any[]), :unmap => (:Nothing, Any[]), :hide => (:Nothing, Any[]), :query_tooltip => (:Cint, Any[:Int32, :Int32, :Cint, :(Ptr{GObject})]), :move_focus => (:Nothing, [:UInt32]), :mnemonic_activate => (:Cint, [:Cint]), :direction_changed => (:Nothing, [:UInt32]), :activate => (:Nothing, Any[]), :destroy => (:Nothing, Any[]), :keynav_failed => (:Cint, [:UInt32]), :realize => (:Nothing, Any[]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkFontDialogButton
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkFontDialogButton
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkFrame] = GtkFrameLeaf
    (GLib.g_type(::Type{T}) where T <: GtkFrame) = ccall(("gtk_frame_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkFrame})
        signalnames(supertype(GtkFrame))
    end
    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
    gtype_wrapper_cache[:GtkGLArea] = GtkGLAreaLeaf
    (GLib.g_type(::Type{T}) where T <: GtkGLArea) = ccall(("gtk_gl_area_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkGLArea})
        vcat([:create_context, :render, :resize], signalnames(supertype(GtkGLArea)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :state_flags_changed => (:Nothing, [:UInt32]), :map => (:Nothing, Any[]), :render => (:Cint, Expr[:(Ptr{GObject})]), :create_context => (:(Ptr{GObject}), Any[]), :unrealize => (:Nothing, Any[]), :show => (:Nothing, Any[]), :unmap => (:Nothing, Any[]), :resize => (:Nothing, [:Int32, :Int32]), :hide => (:Nothing, Any[]), :query_tooltip => (:Cint, Any[:Int32, :Int32, :Cint, :(Ptr{GObject})]), :move_focus => (:Nothing, [:UInt32]), :mnemonic_activate => (:Cint, [:Cint]), :direction_changed => (:Nothing, [:UInt32]), :destroy => (:Nothing, Any[]), :keynav_failed => (:Cint, [:UInt32]), :realize => (:Nothing, Any[]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkGLArea
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkGLArea
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkGestureClick] = GtkGestureClickLeaf
    (GLib.g_type(::Type{T}) where T <: GtkGestureClick) = ccall(("gtk_gesture_click_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkGestureClick})
        vcat([:pressed, :released, :stopped, :unpaired_release], signalnames(supertype(GtkGestureClick)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :begin => (:Nothing, [:GdkEventSequence]), :released => (:Nothing, [:Int32, :Float64, :Float64]), :unpaired_release => (:Nothing, [:Float64, :Float64, :UInt32, :GdkEventSequence]), :update => (:Nothing, [:GdkEventSequence]), :stopped => (:Nothing, Any[]), :end => (:Nothing, [:GdkEventSequence]), :pressed => (:Nothing, [:Int32, :Float64, :Float64]), :cancel => (:Nothing, [:GdkEventSequence]), :sequence_state_changed => (:Nothing, [:GdkEventSequence, :UInt32]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkGestureClick
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkGestureClick
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkGestureDrag] = GtkGestureDragLeaf
    (GLib.g_type(::Type{T}) where T <: GtkGestureDrag) = ccall(("gtk_gesture_drag_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkGestureDrag})
        vcat([:drag_begin, :drag_end, :drag_update], signalnames(supertype(GtkGestureDrag)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :begin => (:Nothing, [:GdkEventSequence]), :drag_begin => (:Nothing, [:Float64, :Float64]), :drag_update => (:Nothing, [:Float64, :Float64]), :update => (:Nothing, [:GdkEventSequence]), :end => (:Nothing, [:GdkEventSequence]), :drag_end => (:Nothing, [:Float64, :Float64]), :cancel => (:Nothing, [:GdkEventSequence]), :sequence_state_changed => (:Nothing, [:GdkEventSequence, :UInt32]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkGestureDrag
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkGestureDrag
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkGestureLongPress] = GtkGestureLongPressLeaf
    (GLib.g_type(::Type{T}) where T <: GtkGestureLongPress) = ccall(("gtk_gesture_long_press_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkGestureLongPress})
        vcat([:cancelled, :pressed], signalnames(supertype(GtkGestureLongPress)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :begin => (:Nothing, [:GdkEventSequence]), :update => (:Nothing, [:GdkEventSequence]), :pressed => (:Nothing, [:Float64, :Float64]), :end => (:Nothing, [:GdkEventSequence]), :cancelled => (:Nothing, Any[]), :cancel => (:Nothing, [:GdkEventSequence]), :sequence_state_changed => (:Nothing, [:GdkEventSequence, :UInt32]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkGestureLongPress
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkGestureLongPress
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkGesturePan] = GtkGesturePanLeaf
    (GLib.g_type(::Type{T}) where T <: GtkGesturePan) = ccall(("gtk_gesture_pan_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkGesturePan})
        vcat([:pan], signalnames(supertype(GtkGesturePan)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :begin => (:Nothing, [:GdkEventSequence]), :drag_begin => (:Nothing, [:Float64, :Float64]), :drag_update => (:Nothing, [:Float64, :Float64]), :update => (:Nothing, [:GdkEventSequence]), :pan => (:Nothing, [:UInt32, :Float64]), :end => (:Nothing, [:GdkEventSequence]), :drag_end => (:Nothing, [:Float64, :Float64]), :cancel => (:Nothing, [:GdkEventSequence]), :sequence_state_changed => (:Nothing, [:GdkEventSequence, :UInt32]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkGesturePan
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkGesturePan
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkGestureRotate] = GtkGestureRotateLeaf
    (GLib.g_type(::Type{T}) where T <: GtkGestureRotate) = ccall(("gtk_gesture_rotate_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkGestureRotate})
        vcat([:angle_changed], signalnames(supertype(GtkGestureRotate)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :begin => (:Nothing, [:GdkEventSequence]), :update => (:Nothing, [:GdkEventSequence]), :angle_changed => (:Nothing, [:Float64, :Float64]), :end => (:Nothing, [:GdkEventSequence]), :cancel => (:Nothing, [:GdkEventSequence]), :sequence_state_changed => (:Nothing, [:GdkEventSequence, :UInt32]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkGestureRotate
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkGestureRotate
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkGestureStylus] = GtkGestureStylusLeaf
    (GLib.g_type(::Type{T}) where T <: GtkGestureStylus) = ccall(("gtk_gesture_stylus_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkGestureStylus})
        vcat([:down, :motion, :proximity, :up], signalnames(supertype(GtkGestureStylus)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :begin => (:Nothing, [:GdkEventSequence]), :down => (:Nothing, [:Float64, :Float64]), :update => (:Nothing, [:GdkEventSequence]), :proximity => (:Nothing, [:Float64, :Float64]), :end => (:Nothing, [:GdkEventSequence]), :motion => (:Nothing, [:Float64, :Float64]), :up => (:Nothing, [:Float64, :Float64]), :cancel => (:Nothing, [:GdkEventSequence]), :sequence_state_changed => (:Nothing, [:GdkEventSequence, :UInt32]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkGestureStylus
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkGestureStylus
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkGestureSwipe] = GtkGestureSwipeLeaf
    (GLib.g_type(::Type{T}) where T <: GtkGestureSwipe) = ccall(("gtk_gesture_swipe_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkGestureSwipe})
        vcat([:swipe], signalnames(supertype(GtkGestureSwipe)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :begin => (:Nothing, [:GdkEventSequence]), :swipe => (:Nothing, [:Float64, :Float64]), :update => (:Nothing, [:GdkEventSequence]), :end => (:Nothing, [:GdkEventSequence]), :cancel => (:Nothing, [:GdkEventSequence]), :sequence_state_changed => (:Nothing, [:GdkEventSequence, :UInt32]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkGestureSwipe
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkGestureSwipe
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkGestureZoom] = GtkGestureZoomLeaf
    (GLib.g_type(::Type{T}) where T <: GtkGestureZoom) = ccall(("gtk_gesture_zoom_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkGestureZoom})
        vcat([:scale_changed], signalnames(supertype(GtkGestureZoom)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :begin => (:Nothing, [:GdkEventSequence]), :scale_changed => (:Nothing, [:Float64]), :update => (:Nothing, [:GdkEventSequence]), :end => (:Nothing, [:GdkEventSequence]), :cancel => (:Nothing, [:GdkEventSequence]), :sequence_state_changed => (:Nothing, [:GdkEventSequence, :UInt32]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkGestureZoom
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkGestureZoom
            Tuple(eval.((d[name])[2]))
        end
    end
    abstract type GtkGraphicsOffload <: GtkWidget end
    mutable struct GtkGraphicsOffloadLeaf <: GtkGraphicsOffload
        handle::Ptr{GObject}
        function GtkGraphicsOffloadLeaf(handle::Ptr{GObject}, owns = false)
            if handle == C_NULL
                error("Cannot construct GtkGraphicsOffloadLeaf with a NULL pointer")
            end
            GLib.gobject_maybe_sink(handle, owns)
            return gobject_ref(new(handle))
        end
    end
    gtype_wrapper_cache[:GtkGraphicsOffload] = GtkGraphicsOffloadLeaf
    (GLib.g_type(::Type{T}) where T <: GtkGraphicsOffload) = ccall(("gtk_graphics_offload_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkGraphicsOffload})
        signalnames(supertype(GtkGraphicsOffload))
    end
    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
    gtype_wrapper_cache[:GtkGrid] = GtkGridLeaf
    (GLib.g_type(::Type{T}) where T <: GtkGrid) = ccall(("gtk_grid_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkGrid})
        signalnames(supertype(GtkGrid))
    end
    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
    gtype_wrapper_cache[:GtkGridLayout] = GtkGridLayoutLeaf
    (GLib.g_type(::Type{T}) where T <: GtkGridLayout) = ccall(("gtk_grid_layout_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkGridLayout})
        signalnames(supertype(GtkGridLayout))
    end
    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
    gtype_wrapper_cache[:GtkGridLayoutChild] = GtkGridLayoutChildLeaf
    (GLib.g_type(::Type{T}) where T <: GtkGridLayoutChild) = ccall(("gtk_grid_layout_child_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkGridLayoutChild})
        signalnames(supertype(GtkGridLayoutChild))
    end
    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
    gtype_wrapper_cache[:GtkListBase] = GtkListBaseLeaf
    (GLib.g_type(::Type{T}) where T <: GtkListBase) = ccall(("gtk_list_base_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkListBase})
        signalnames(supertype(GtkListBase))
    end
    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
    gtype_wrapper_cache[:GtkGridView] = GtkGridViewLeaf
    (GLib.g_type(::Type{T}) where T <: GtkGridView) = ccall(("gtk_grid_view_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkGridView})
        vcat([:activate], signalnames(supertype(GtkGridView)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :state_flags_changed => (:Nothing, [:UInt32]), :map => (:Nothing, Any[]), :unrealize => (:Nothing, Any[]), :show => (:Nothing, Any[]), :unmap => (:Nothing, Any[]), :hide => (:Nothing, Any[]), :query_tooltip => (:Cint, Any[:Int32, :Int32, :Cint, :(Ptr{GObject})]), :move_focus => (:Nothing, [:UInt32]), :mnemonic_activate => (:Cint, [:Cint]), :direction_changed => (:Nothing, [:UInt32]), :activate => (:Nothing, [:UInt32]), :destroy => (:Nothing, Any[]), :keynav_failed => (:Cint, [:UInt32]), :realize => (:Nothing, Any[]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkGridView
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkGridView
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkHeaderBar] = GtkHeaderBarLeaf
    (GLib.g_type(::Type{T}) where T <: GtkHeaderBar) = ccall(("gtk_header_bar_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkHeaderBar})
        signalnames(supertype(GtkHeaderBar))
    end
    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
    gtype_wrapper_cache[:GtkIMContext] = GtkIMContextLeaf
    (GLib.g_type(::Type{T}) where T <: GtkIMContext) = ccall(("gtk_im_context_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkIMContext})
        vcat([:commit, :delete_surrounding, :preedit_changed, :preedit_end, :preedit_start, :retrieve_surrounding], signalnames(supertype(GtkIMContext)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :preedit_changed => (:Nothing, Any[]), :delete_surrounding => (:Cint, [:Int32, :Int32]), :preedit_start => (:Nothing, Any[]), :commit => (:Nothing, [:Cstring]), :preedit_end => (:Nothing, Any[]), :retrieve_surrounding => (:Cint, Any[]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkIMContext
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkIMContext
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkIMContextSimple] = GtkIMContextSimpleLeaf
    (GLib.g_type(::Type{T}) where T <: GtkIMContextSimple) = ccall(("gtk_im_context_simple_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkIMContextSimple})
        signalnames(supertype(GtkIMContextSimple))
    end
    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
    gtype_wrapper_cache[:GtkIMMulticontext] = GtkIMMulticontextLeaf
    (GLib.g_type(::Type{T}) where T <: GtkIMMulticontext) = ccall(("gtk_im_multicontext_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkIMMulticontext})
        signalnames(supertype(GtkIMMulticontext))
    end
    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
    gtype_wrapper_cache[:GtkIconPaintable] = GtkIconPaintableLeaf
    (GLib.g_type(::Type{T}) where T <: GtkIconPaintable) = ccall(("gtk_icon_paintable_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkIconPaintable})
        vcat([:invalidate_contents, :invalidate_size], signalnames(supertype(GtkIconPaintable)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkIconPaintable
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkIconPaintable
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkIconTheme] = GtkIconThemeLeaf
    (GLib.g_type(::Type{T}) where T <: GtkIconTheme) = ccall(("gtk_icon_theme_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkIconTheme})
        vcat([:changed], signalnames(supertype(GtkIconTheme)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :changed => (:Nothing, Any[]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkIconTheme
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkIconTheme
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkIconView] = GtkIconViewLeaf
    (GLib.g_type(::Type{T}) where T <: GtkIconView) = ccall(("gtk_icon_view_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkIconView})
        vcat([:activate_cursor_item, :item_activated, :move_cursor, :select_all, :select_cursor_item, :selection_changed, :toggle_cursor_item, :unselect_all], signalnames(supertype(GtkIconView)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :map => (:Nothing, Any[]), :selection_changed => (:Nothing, Any[]), :toggle_cursor_item => (:Nothing, Any[]), :activate_cursor_item => (:Cint, Any[]), :move_focus => (:Nothing, [:UInt32]), :direction_changed => (:Nothing, [:UInt32]), :state_flags_changed => (:Nothing, [:UInt32]), :select_all => (:Nothing, Any[]), :select_cursor_item => (:Nothing, Any[]), :item_activated => (:Nothing, [:GtkTreePath]), :unrealize => (:Nothing, Any[]), :unselect_all => (:Nothing, Any[]), :move_cursor => (:Cint, [:UInt32, :Int32, :Cint, :Cint]), :show => (:Nothing, Any[]), :unmap => (:Nothing, Any[]), :hide => (:Nothing, Any[]), :query_tooltip => (:Cint, Any[:Int32, :Int32, :Cint, :(Ptr{GObject})]), :mnemonic_activate => (:Cint, [:Cint]), :destroy => (:Nothing, Any[]), :keynav_failed => (:Cint, [:UInt32]), :realize => (:Nothing, Any[]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkIconView
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkIconView
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkImage] = GtkImageLeaf
    (GLib.g_type(::Type{T}) where T <: GtkImage) = ccall(("gtk_image_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkImage})
        signalnames(supertype(GtkImage))
    end
    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
    gtype_wrapper_cache[:GtkInfoBar] = GtkInfoBarLeaf
    (GLib.g_type(::Type{T}) where T <: GtkInfoBar) = ccall(("gtk_info_bar_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkInfoBar})
        vcat([:close, :response], signalnames(supertype(GtkInfoBar)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :state_flags_changed => (:Nothing, [:UInt32]), :map => (:Nothing, Any[]), :close => (:Nothing, Any[]), :unrealize => (:Nothing, Any[]), :show => (:Nothing, Any[]), :unmap => (:Nothing, Any[]), :hide => (:Nothing, Any[]), :query_tooltip => (:Cint, Any[:Int32, :Int32, :Cint, :(Ptr{GObject})]), :response => (:Nothing, [:Int32]), :move_focus => (:Nothing, [:UInt32]), :mnemonic_activate => (:Cint, [:Cint]), :direction_changed => (:Nothing, [:UInt32]), :destroy => (:Nothing, Any[]), :keynav_failed => (:Cint, [:UInt32]), :realize => (:Nothing, Any[]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkInfoBar
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkInfoBar
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkInscription] = GtkInscriptionLeaf
    (GLib.g_type(::Type{T}) where T <: GtkInscription) = ccall(("gtk_inscription_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkInscription})
        signalnames(supertype(GtkInscription))
    end
    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
    gtype_wrapper_cache[:GtkKeyvalTrigger] = GtkKeyvalTriggerLeaf
    (GLib.g_type(::Type{T}) where T <: GtkKeyvalTrigger) = ccall(("gtk_keyval_trigger_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkKeyvalTrigger})
        signalnames(supertype(GtkKeyvalTrigger))
    end
    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
    gtype_wrapper_cache[:GtkLabel] = GtkLabelLeaf
    (GLib.g_type(::Type{T}) where T <: GtkLabel) = ccall(("gtk_label_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkLabel})
        vcat([:activate_current_link, :activate_link, :copy_clipboard, :move_cursor], signalnames(supertype(GtkLabel)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :state_flags_changed => (:Nothing, [:UInt32]), :map => (:Nothing, Any[]), :activate_link => (:Cint, [:Cstring]), :unrealize => (:Nothing, Any[]), :move_cursor => (:Nothing, [:UInt32, :Int32, :Cint]), :show => (:Nothing, Any[]), :unmap => (:Nothing, Any[]), :copy_clipboard => (:Nothing, Any[]), :hide => (:Nothing, Any[]), :query_tooltip => (:Cint, Any[:Int32, :Int32, :Cint, :(Ptr{GObject})]), :move_focus => (:Nothing, [:UInt32]), :mnemonic_activate => (:Cint, [:Cint]), :direction_changed => (:Nothing, [:UInt32]), :activate_current_link => (:Nothing, Any[]), :destroy => (:Nothing, Any[]), :keynav_failed => (:Cint, [:UInt32]), :realize => (:Nothing, Any[]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkLabel
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkLabel
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkLevelBar] = GtkLevelBarLeaf
    (GLib.g_type(::Type{T}) where T <: GtkLevelBar) = ccall(("gtk_level_bar_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkLevelBar})
        vcat([:offset_changed], signalnames(supertype(GtkLevelBar)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :state_flags_changed => (:Nothing, [:UInt32]), :map => (:Nothing, Any[]), :offset_changed => (:Nothing, [:Cstring]), :unrealize => (:Nothing, Any[]), :show => (:Nothing, Any[]), :unmap => (:Nothing, Any[]), :hide => (:Nothing, Any[]), :query_tooltip => (:Cint, Any[:Int32, :Int32, :Cint, :(Ptr{GObject})]), :move_focus => (:Nothing, [:UInt32]), :mnemonic_activate => (:Cint, [:Cint]), :direction_changed => (:Nothing, [:UInt32]), :destroy => (:Nothing, Any[]), :keynav_failed => (:Cint, [:UInt32]), :realize => (:Nothing, Any[]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkLevelBar
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkLevelBar
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkLinkButton] = GtkLinkButtonLeaf
    (GLib.g_type(::Type{T}) where T <: GtkLinkButton) = ccall(("gtk_link_button_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkLinkButton})
        vcat([:activate_link], signalnames(supertype(GtkLinkButton)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :state_flags_changed => (:Nothing, [:UInt32]), :map => (:Nothing, Any[]), :activate_link => (:Cint, Any[]), :unrealize => (:Nothing, Any[]), :show => (:Nothing, Any[]), :unmap => (:Nothing, Any[]), :hide => (:Nothing, Any[]), :query_tooltip => (:Cint, Any[:Int32, :Int32, :Cint, :(Ptr{GObject})]), :clicked => (:Nothing, Any[]), :move_focus => (:Nothing, [:UInt32]), :mnemonic_activate => (:Cint, [:Cint]), :direction_changed => (:Nothing, [:UInt32]), :activate => (:Nothing, Any[]), :destroy => (:Nothing, Any[]), :keynav_failed => (:Cint, [:UInt32]), :realize => (:Nothing, Any[]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkLinkButton
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkLinkButton
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkListBox] = GtkListBoxLeaf
    (GLib.g_type(::Type{T}) where T <: GtkListBox) = ccall(("gtk_list_box_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkListBox})
        vcat([:activate_cursor_row, :move_cursor, :row_activated, :row_selected, :select_all, :selected_rows_changed, :toggle_cursor_row, :unselect_all], signalnames(supertype(GtkListBox)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :map => (:Nothing, Any[]), :activate_cursor_row => (:Nothing, Any[]), :row_activated => (:Nothing, Expr[:(Ptr{GObject})]), :row_selected => (:Nothing, Expr[:(Ptr{GObject})]), :selected_rows_changed => (:Nothing, Any[]), :toggle_cursor_row => (:Nothing, Any[]), :move_focus => (:Nothing, [:UInt32]), :direction_changed => (:Nothing, [:UInt32]), :state_flags_changed => (:Nothing, [:UInt32]), :select_all => (:Nothing, Any[]), :unrealize => (:Nothing, Any[]), :unselect_all => (:Nothing, Any[]), :move_cursor => (:Nothing, [:UInt32, :Int32, :Cint, :Cint]), :show => (:Nothing, Any[]), :unmap => (:Nothing, Any[]), :hide => (:Nothing, Any[]), :query_tooltip => (:Cint, Any[:Int32, :Int32, :Cint, :(Ptr{GObject})]), :mnemonic_activate => (:Cint, [:Cint]), :destroy => (:Nothing, Any[]), :keynav_failed => (:Cint, [:UInt32]), :realize => (:Nothing, Any[]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkListBox
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkListBox
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkListBoxRow] = GtkListBoxRowLeaf
    (GLib.g_type(::Type{T}) where T <: GtkListBoxRow) = ccall(("gtk_list_box_row_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkListBoxRow})
        vcat([:activate], signalnames(supertype(GtkListBoxRow)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :state_flags_changed => (:Nothing, [:UInt32]), :map => (:Nothing, Any[]), :unrealize => (:Nothing, Any[]), :show => (:Nothing, Any[]), :unmap => (:Nothing, Any[]), :hide => (:Nothing, Any[]), :query_tooltip => (:Cint, Any[:Int32, :Int32, :Cint, :(Ptr{GObject})]), :move_focus => (:Nothing, [:UInt32]), :mnemonic_activate => (:Cint, [:Cint]), :direction_changed => (:Nothing, [:UInt32]), :activate => (:Nothing, Any[]), :destroy => (:Nothing, Any[]), :keynav_failed => (:Cint, [:UInt32]), :realize => (:Nothing, Any[]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkListBoxRow
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkListBoxRow
            Tuple(eval.((d[name])[2]))
        end
    end
    abstract type GtkListHeader <: GObject end
    mutable struct GtkListHeaderLeaf <: GtkListHeader
        handle::Ptr{GObject}
        function GtkListHeaderLeaf(handle::Ptr{GObject}, owns = false)
            if handle == C_NULL
                error("Cannot construct GtkListHeaderLeaf with a NULL pointer")
            end
            GLib.gobject_maybe_sink(handle, owns)
            return gobject_ref(new(handle))
        end
    end
    gtype_wrapper_cache[:GtkListHeader] = GtkListHeaderLeaf
    (GLib.g_type(::Type{T}) where T <: GtkListHeader) = ccall(("gtk_list_header_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkListHeader})
        signalnames(supertype(GtkListHeader))
    end
    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
    gtype_wrapper_cache[:GtkListStore] = GtkListStoreLeaf
    (GLib.g_type(::Type{T}) where T <: GtkListStore) = ccall(("gtk_list_store_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkListStore})
        vcat([:row_changed, :row_deleted, :row_has_child_toggled, :row_inserted, :sort_column_changed], signalnames(supertype(GtkListStore)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkListStore
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkListStore
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkListView] = GtkListViewLeaf
    (GLib.g_type(::Type{T}) where T <: GtkListView) = ccall(("gtk_list_view_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkListView})
        vcat([:activate], signalnames(supertype(GtkListView)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :state_flags_changed => (:Nothing, [:UInt32]), :map => (:Nothing, Any[]), :unrealize => (:Nothing, Any[]), :show => (:Nothing, Any[]), :unmap => (:Nothing, Any[]), :hide => (:Nothing, Any[]), :query_tooltip => (:Cint, Any[:Int32, :Int32, :Cint, :(Ptr{GObject})]), :move_focus => (:Nothing, [:UInt32]), :mnemonic_activate => (:Cint, [:Cint]), :direction_changed => (:Nothing, [:UInt32]), :activate => (:Nothing, [:UInt32]), :destroy => (:Nothing, Any[]), :keynav_failed => (:Cint, [:UInt32]), :realize => (:Nothing, Any[]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkListView
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkListView
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkLockButton] = GtkLockButtonLeaf
    (GLib.g_type(::Type{T}) where T <: GtkLockButton) = ccall(("gtk_lock_button_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkLockButton})
        signalnames(supertype(GtkLockButton))
    end
    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
    gtype_wrapper_cache[:GtkMapListModel] = GtkMapListModelLeaf
    (GLib.g_type(::Type{T}) where T <: GtkMapListModel) = ccall(("gtk_map_list_model_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkMapListModel})
        vcat([:items_changed, :sections_changed], signalnames(supertype(GtkMapListModel)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkMapListModel
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkMapListModel
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkMediaControls] = GtkMediaControlsLeaf
    (GLib.g_type(::Type{T}) where T <: GtkMediaControls) = ccall(("gtk_media_controls_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkMediaControls})
        signalnames(supertype(GtkMediaControls))
    end
    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
    gtype_wrapper_cache[:GtkMediaStream] = GtkMediaStreamLeaf
    (GLib.g_type(::Type{T}) where T <: GtkMediaStream) = ccall(("gtk_media_stream_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkMediaStream})
        vcat([:invalidate_contents, :invalidate_size], signalnames(supertype(GtkMediaStream)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkMediaStream
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkMediaStream
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkMediaFile] = GtkMediaFileLeaf
    (GLib.g_type(::Type{T}) where T <: GtkMediaFile) = ccall(("gtk_media_file_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkMediaFile})
        vcat([:invalidate_contents, :invalidate_size], signalnames(supertype(GtkMediaFile)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkMediaFile
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkMediaFile
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkMenuButton] = GtkMenuButtonLeaf
    (GLib.g_type(::Type{T}) where T <: GtkMenuButton) = ccall(("gtk_menu_button_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkMenuButton})
        vcat([:activate], signalnames(supertype(GtkMenuButton)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :state_flags_changed => (:Nothing, [:UInt32]), :map => (:Nothing, Any[]), :unrealize => (:Nothing, Any[]), :show => (:Nothing, Any[]), :unmap => (:Nothing, Any[]), :hide => (:Nothing, Any[]), :query_tooltip => (:Cint, Any[:Int32, :Int32, :Cint, :(Ptr{GObject})]), :move_focus => (:Nothing, [:UInt32]), :mnemonic_activate => (:Cint, [:Cint]), :direction_changed => (:Nothing, [:UInt32]), :activate => (:Nothing, Any[]), :destroy => (:Nothing, Any[]), :keynav_failed => (:Cint, [:UInt32]), :realize => (:Nothing, Any[]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkMenuButton
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkMenuButton
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkMessageDialog] = GtkMessageDialogLeaf
    (GLib.g_type(::Type{T}) where T <: GtkMessageDialog) = ccall(("gtk_message_dialog_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkMessageDialog})
        signalnames(supertype(GtkMessageDialog))
    end
    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
    gtype_wrapper_cache[:GtkMnemonicAction] = GtkMnemonicActionLeaf
    (GLib.g_type(::Type{T}) where T <: GtkMnemonicAction) = ccall(("gtk_mnemonic_action_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkMnemonicAction})
        signalnames(supertype(GtkMnemonicAction))
    end
    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
    gtype_wrapper_cache[:GtkMnemonicTrigger] = GtkMnemonicTriggerLeaf
    (GLib.g_type(::Type{T}) where T <: GtkMnemonicTrigger) = ccall(("gtk_mnemonic_trigger_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkMnemonicTrigger})
        signalnames(supertype(GtkMnemonicTrigger))
    end
    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
    gtype_wrapper_cache[:GtkMountOperation] = GtkMountOperationLeaf
    (GLib.g_type(::Type{T}) where T <: GtkMountOperation) = ccall(("gtk_mount_operation_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkMountOperation})
        signalnames(supertype(GtkMountOperation))
    end
    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
    gtype_wrapper_cache[:GtkMultiSelection] = GtkMultiSelectionLeaf
    (GLib.g_type(::Type{T}) where T <: GtkMultiSelection) = ccall(("gtk_multi_selection_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkMultiSelection})
        vcat([:items_changed, :sections_changed, :selection_changed], signalnames(supertype(GtkMultiSelection)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkMultiSelection
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkMultiSelection
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkMultiSorter] = GtkMultiSorterLeaf
    (GLib.g_type(::Type{T}) where T <: GtkMultiSorter) = ccall(("gtk_multi_sorter_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkMultiSorter})
        vcat([:items_changed], signalnames(supertype(GtkMultiSorter)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :changed => (:Nothing, [:UInt32]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkMultiSorter
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkMultiSorter
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkNamedAction] = GtkNamedActionLeaf
    (GLib.g_type(::Type{T}) where T <: GtkNamedAction) = ccall(("gtk_named_action_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkNamedAction})
        signalnames(supertype(GtkNamedAction))
    end
    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
    gtype_wrapper_cache[:GtkNeverTrigger] = GtkNeverTriggerLeaf
    (GLib.g_type(::Type{T}) where T <: GtkNeverTrigger) = ccall(("gtk_never_trigger_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkNeverTrigger})
        signalnames(supertype(GtkNeverTrigger))
    end
    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
    gtype_wrapper_cache[:GtkNoSelection] = GtkNoSelectionLeaf
    (GLib.g_type(::Type{T}) where T <: GtkNoSelection) = ccall(("gtk_no_selection_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkNoSelection})
        vcat([:items_changed, :sections_changed, :selection_changed], signalnames(supertype(GtkNoSelection)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkNoSelection
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkNoSelection
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkNotebook] = GtkNotebookLeaf
    (GLib.g_type(::Type{T}) where T <: GtkNotebook) = ccall(("gtk_notebook_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkNotebook})
        vcat([:change_current_page, :create_window, :focus_tab, :move_focus_out, :page_added, :page_removed, :page_reordered, :reorder_tab, :select_page, :switch_page], signalnames(supertype(GtkNotebook)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :page_reordered => (:Nothing, Any[:(Ptr{GObject}), :UInt32]), :map => (:Nothing, Any[]), :page_removed => (:Nothing, Any[:(Ptr{GObject}), :UInt32]), :move_focus => (:Nothing, [:UInt32]), :direction_changed => (:Nothing, [:UInt32]), :focus_tab => (:Cint, [:UInt32]), :state_flags_changed => (:Nothing, [:UInt32]), :reorder_tab => (:Cint, [:UInt32, :Cint]), :move_focus_out => (:Nothing, [:UInt32]), :unrealize => (:Nothing, Any[]), :create_window => (:(Ptr{GObject}), Expr[:(Ptr{GObject})]), :select_page => (:Cint, [:Cint]), :show => (:Nothing, Any[]), :unmap => (:Nothing, Any[]), :change_current_page => (:Cint, [:Int32]), :hide => (:Nothing, Any[]), :query_tooltip => (:Cint, Any[:Int32, :Int32, :Cint, :(Ptr{GObject})]), :page_added => (:Nothing, Any[:(Ptr{GObject}), :UInt32]), :switch_page => (:Nothing, Any[:(Ptr{GObject}), :UInt32]), :mnemonic_activate => (:Cint, [:Cint]), :destroy => (:Nothing, Any[]), :keynav_failed => (:Cint, [:UInt32]), :realize => (:Nothing, Any[]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkNotebook
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkNotebook
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkNotebookPage] = GtkNotebookPageLeaf
    (GLib.g_type(::Type{T}) where T <: GtkNotebookPage) = ccall(("gtk_notebook_page_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkNotebookPage})
        signalnames(supertype(GtkNotebookPage))
    end
    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
    gtype_wrapper_cache[:GtkNothingAction] = GtkNothingActionLeaf
    (GLib.g_type(::Type{T}) where T <: GtkNothingAction) = ccall(("gtk_nothing_action_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkNothingAction})
        signalnames(supertype(GtkNothingAction))
    end
    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
    gtype_wrapper_cache[:GtkNumericSorter] = GtkNumericSorterLeaf
    (GLib.g_type(::Type{T}) where T <: GtkNumericSorter) = ccall(("gtk_numeric_sorter_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkNumericSorter})
        signalnames(supertype(GtkNumericSorter))
    end
    abstract type GtkObjectExpression <: GtkExpression end
    mutable struct GtkObjectExpressionLeaf <: GtkObjectExpression
        handle::Ptr{GtkExpression}
    end
    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
    gtype_wrapper_cache[:GtkOverlay] = GtkOverlayLeaf
    (GLib.g_type(::Type{T}) where T <: GtkOverlay) = ccall(("gtk_overlay_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkOverlay})
        vcat([:get_child_position], signalnames(supertype(GtkOverlay)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :state_flags_changed => (:Nothing, [:UInt32]), :map => (:Nothing, Any[]), :get_child_position => (:Cint, Any[:(Ptr{GObject}), :_GdkRectangle]), :unrealize => (:Nothing, Any[]), :show => (:Nothing, Any[]), :unmap => (:Nothing, Any[]), :hide => (:Nothing, Any[]), :query_tooltip => (:Cint, Any[:Int32, :Int32, :Cint, :(Ptr{GObject})]), :move_focus => (:Nothing, [:UInt32]), :mnemonic_activate => (:Cint, [:Cint]), :direction_changed => (:Nothing, [:UInt32]), :destroy => (:Nothing, Any[]), :keynav_failed => (:Cint, [:UInt32]), :realize => (:Nothing, Any[]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkOverlay
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkOverlay
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkOverlayLayout] = GtkOverlayLayoutLeaf
    (GLib.g_type(::Type{T}) where T <: GtkOverlayLayout) = ccall(("gtk_overlay_layout_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkOverlayLayout})
        signalnames(supertype(GtkOverlayLayout))
    end
    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
    gtype_wrapper_cache[:GtkOverlayLayoutChild] = GtkOverlayLayoutChildLeaf
    (GLib.g_type(::Type{T}) where T <: GtkOverlayLayoutChild) = ccall(("gtk_overlay_layout_child_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkOverlayLayoutChild})
        signalnames(supertype(GtkOverlayLayoutChild))
    end
    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
    gtype_wrapper_cache[:GtkPadController] = GtkPadControllerLeaf
    (GLib.g_type(::Type{T}) where T <: GtkPadController) = ccall(("gtk_pad_controller_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkPadController})
        signalnames(supertype(GtkPadController))
    end
    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
    gtype_wrapper_cache[:GtkPageSetup] = GtkPageSetupLeaf
    (GLib.g_type(::Type{T}) where T <: GtkPageSetup) = ccall(("gtk_page_setup_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkPageSetup})
        signalnames(supertype(GtkPageSetup))
    end
    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
    gtype_wrapper_cache[:GtkPaned] = GtkPanedLeaf
    (GLib.g_type(::Type{T}) where T <: GtkPaned) = ccall(("gtk_paned_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkPaned})
        vcat([:accept_position, :cancel_position, :cycle_child_focus, :cycle_handle_focus, :move_handle, :toggle_handle_focus], signalnames(supertype(GtkPaned)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :state_flags_changed => (:Nothing, [:UInt32]), :map => (:Nothing, Any[]), :toggle_handle_focus => (:Cint, Any[]), :cancel_position => (:Cint, Any[]), :cycle_handle_focus => (:Cint, [:Cint]), :cycle_child_focus => (:Cint, [:Cint]), :unrealize => (:Nothing, Any[]), :show => (:Nothing, Any[]), :unmap => (:Nothing, Any[]), :hide => (:Nothing, Any[]), :query_tooltip => (:Cint, Any[:Int32, :Int32, :Cint, :(Ptr{GObject})]), :accept_position => (:Cint, Any[]), :move_focus => (:Nothing, [:UInt32]), :mnemonic_activate => (:Cint, [:Cint]), :direction_changed => (:Nothing, [:UInt32]), :move_handle => (:Cint, [:UInt32]), :destroy => (:Nothing, Any[]), :keynav_failed => (:Cint, [:UInt32]), :realize => (:Nothing, Any[]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkPaned
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkPaned
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkPasswordEntry] = GtkPasswordEntryLeaf
    (GLib.g_type(::Type{T}) where T <: GtkPasswordEntry) = ccall(("gtk_password_entry_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkPasswordEntry})
        vcat([:activate, :changed, :delete_text, :insert_text], signalnames(supertype(GtkPasswordEntry)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :state_flags_changed => (:Nothing, [:UInt32]), :map => (:Nothing, Any[]), :unrealize => (:Nothing, Any[]), :show => (:Nothing, Any[]), :unmap => (:Nothing, Any[]), :hide => (:Nothing, Any[]), :query_tooltip => (:Cint, Any[:Int32, :Int32, :Cint, :(Ptr{GObject})]), :move_focus => (:Nothing, [:UInt32]), :mnemonic_activate => (:Cint, [:Cint]), :direction_changed => (:Nothing, [:UInt32]), :activate => (:Nothing, Any[]), :destroy => (:Nothing, Any[]), :keynav_failed => (:Cint, [:UInt32]), :realize => (:Nothing, Any[]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkPasswordEntry
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkPasswordEntry
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkPasswordEntryBuffer] = GtkPasswordEntryBufferLeaf
    (GLib.g_type(::Type{T}) where T <: GtkPasswordEntryBuffer) = ccall(("gtk_password_entry_buffer_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkPasswordEntryBuffer})
        signalnames(supertype(GtkPasswordEntryBuffer))
    end
    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
    gtype_wrapper_cache[:GtkPicture] = GtkPictureLeaf
    (GLib.g_type(::Type{T}) where T <: GtkPicture) = ccall(("gtk_picture_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkPicture})
        signalnames(supertype(GtkPicture))
    end
    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
    gtype_wrapper_cache[:GtkPopoverMenu] = GtkPopoverMenuLeaf
    (GLib.g_type(::Type{T}) where T <: GtkPopoverMenu) = ccall(("gtk_popover_menu_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkPopoverMenu})
        signalnames(supertype(GtkPopoverMenu))
    end
    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
    gtype_wrapper_cache[:GtkPopoverMenuBar] = GtkPopoverMenuBarLeaf
    (GLib.g_type(::Type{T}) where T <: GtkPopoverMenuBar) = ccall(("gtk_popover_menu_bar_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkPopoverMenuBar})
        signalnames(supertype(GtkPopoverMenuBar))
    end
    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
    gtype_wrapper_cache[:GtkPrintContext] = GtkPrintContextLeaf
    (GLib.g_type(::Type{T}) where T <: GtkPrintContext) = ccall(("gtk_print_context_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkPrintContext})
        signalnames(supertype(GtkPrintContext))
    end
    abstract type GtkPrintDialog <: GObject end
    mutable struct GtkPrintDialogLeaf <: GtkPrintDialog
        handle::Ptr{GObject}
        function GtkPrintDialogLeaf(handle::Ptr{GObject}, owns = false)
            if handle == C_NULL
                error("Cannot construct GtkPrintDialogLeaf with a NULL pointer")
            end
            GLib.gobject_maybe_sink(handle, owns)
            return gobject_ref(new(handle))
        end
    end
    gtype_wrapper_cache[:GtkPrintDialog] = GtkPrintDialogLeaf
    (GLib.g_type(::Type{T}) where T <: GtkPrintDialog) = ccall(("gtk_print_dialog_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkPrintDialog})
        signalnames(supertype(GtkPrintDialog))
    end
    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
    gtype_wrapper_cache[:GtkPrintJob] = GtkPrintJobLeaf
    (GLib.g_type(::Type{T}) where T <: GtkPrintJob) = ccall(("gtk_print_job_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkPrintJob})
        vcat([:status_changed], signalnames(supertype(GtkPrintJob)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :status_changed => (:Nothing, Any[]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkPrintJob
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkPrintJob
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkPrintOperation] = GtkPrintOperationLeaf
    (GLib.g_type(::Type{T}) where T <: GtkPrintOperation) = ccall(("gtk_print_operation_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkPrintOperation})
        vcat([:begin_print, :create_custom_widget, :custom_widget_apply, :done, :draw_page, :end_print, :paginate, :preview, :request_page_setup, :status_changed, :update_custom_widget, :got_page_size, :ready], signalnames(supertype(GtkPrintOperation)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :create_custom_widget => (:(Ptr{GObject}), Any[]), :status_changed => (:Nothing, Any[]), :end_print => (:Nothing, Expr[:(Ptr{GObject})]), :update_custom_widget => (:Nothing, Expr[:(Ptr{GObject}), :(Ptr{GObject}), :(Ptr{GObject})]), :paginate => (:Cint, Expr[:(Ptr{GObject})]), :request_page_setup => (:Nothing, Any[:(Ptr{GObject}), :Int32, :(Ptr{GObject})]), :begin_print => (:Nothing, Expr[:(Ptr{GObject})]), :done => (:Nothing, [:UInt32]), :preview => (:Cint, Expr[:(Ptr{GObject}), :(Ptr{GObject}), :(Ptr{GObject})]), :custom_widget_apply => (:Nothing, Expr[:(Ptr{GObject})]), :draw_page => (:Nothing, Any[:(Ptr{GObject}), :Int32]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkPrintOperation
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkPrintOperation
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkPrintSettings] = GtkPrintSettingsLeaf
    (GLib.g_type(::Type{T}) where T <: GtkPrintSettings) = ccall(("gtk_print_settings_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkPrintSettings})
        signalnames(supertype(GtkPrintSettings))
    end
    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
    gtype_wrapper_cache[:GtkPrinter] = GtkPrinterLeaf
    (GLib.g_type(::Type{T}) where T <: GtkPrinter) = ccall(("gtk_printer_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkPrinter})
        vcat([:details_acquired], signalnames(supertype(GtkPrinter)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :details_acquired => (:Nothing, [:Cint]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkPrinter
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkPrinter
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkProgressBar] = GtkProgressBarLeaf
    (GLib.g_type(::Type{T}) where T <: GtkProgressBar) = ccall(("gtk_progress_bar_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkProgressBar})
        signalnames(supertype(GtkProgressBar))
    end
    abstract type GtkPropertyExpression <: GtkExpression end
    mutable struct GtkPropertyExpressionLeaf <: GtkPropertyExpression
        handle::Ptr{GtkExpression}
    end
    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
    gtype_wrapper_cache[:GtkRange] = GtkRangeLeaf
    (GLib.g_type(::Type{T}) where T <: GtkRange) = ccall(("gtk_range_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkRange})
        vcat([:adjust_bounds, :change_value, :move_slider, :value_changed], signalnames(supertype(GtkRange)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :state_flags_changed => (:Nothing, [:UInt32]), :map => (:Nothing, Any[]), :change_value => (:Cint, [:UInt32, :Float64]), :move_slider => (:Nothing, [:UInt32]), :unrealize => (:Nothing, Any[]), :value_changed => (:Nothing, Any[]), :show => (:Nothing, Any[]), :unmap => (:Nothing, Any[]), :hide => (:Nothing, Any[]), :query_tooltip => (:Cint, Any[:Int32, :Int32, :Cint, :(Ptr{GObject})]), :move_focus => (:Nothing, [:UInt32]), :mnemonic_activate => (:Cint, [:Cint]), :direction_changed => (:Nothing, [:UInt32]), :adjust_bounds => (:Nothing, [:Float64]), :destroy => (:Nothing, Any[]), :keynav_failed => (:Cint, [:UInt32]), :realize => (:Nothing, Any[]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkRange
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkRange
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkRecentManager] = GtkRecentManagerLeaf
    (GLib.g_type(::Type{T}) where T <: GtkRecentManager) = ccall(("gtk_recent_manager_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkRecentManager})
        vcat([:changed], signalnames(supertype(GtkRecentManager)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :changed => (:Nothing, Any[]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkRecentManager
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkRecentManager
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkRevealer] = GtkRevealerLeaf
    (GLib.g_type(::Type{T}) where T <: GtkRevealer) = ccall(("gtk_revealer_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkRevealer})
        signalnames(supertype(GtkRevealer))
    end
    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
    gtype_wrapper_cache[:GtkScale] = GtkScaleLeaf
    (GLib.g_type(::Type{T}) where T <: GtkScale) = ccall(("gtk_scale_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkScale})
        signalnames(supertype(GtkScale))
    end
    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
    gtype_wrapper_cache[:GtkScaleButton] = GtkScaleButtonLeaf
    (GLib.g_type(::Type{T}) where T <: GtkScaleButton) = ccall(("gtk_scale_button_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkScaleButton})
        vcat([:popdown, :popup, :value_changed], signalnames(supertype(GtkScaleButton)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :state_flags_changed => (:Nothing, [:UInt32]), :map => (:Nothing, Any[]), :popdown => (:Nothing, Any[]), :unrealize => (:Nothing, Any[]), :value_changed => (:Nothing, [:Float64]), :popup => (:Nothing, Any[]), :show => (:Nothing, Any[]), :unmap => (:Nothing, Any[]), :hide => (:Nothing, Any[]), :query_tooltip => (:Cint, Any[:Int32, :Int32, :Cint, :(Ptr{GObject})]), :move_focus => (:Nothing, [:UInt32]), :mnemonic_activate => (:Cint, [:Cint]), :direction_changed => (:Nothing, [:UInt32]), :destroy => (:Nothing, Any[]), :keynav_failed => (:Cint, [:UInt32]), :realize => (:Nothing, Any[]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkScaleButton
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkScaleButton
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkScrollbar] = GtkScrollbarLeaf
    (GLib.g_type(::Type{T}) where T <: GtkScrollbar) = ccall(("gtk_scrollbar_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkScrollbar})
        signalnames(supertype(GtkScrollbar))
    end
    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
    gtype_wrapper_cache[:GtkScrolledWindow] = GtkScrolledWindowLeaf
    (GLib.g_type(::Type{T}) where T <: GtkScrolledWindow) = ccall(("gtk_scrolled_window_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkScrolledWindow})
        vcat([:edge_overshot, :edge_reached, :move_focus_out, :scroll_child], signalnames(supertype(GtkScrolledWindow)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :state_flags_changed => (:Nothing, [:UInt32]), :map => (:Nothing, Any[]), :move_focus_out => (:Nothing, [:UInt32]), :unrealize => (:Nothing, Any[]), :show => (:Nothing, Any[]), :unmap => (:Nothing, Any[]), :edge_overshot => (:Nothing, [:UInt32]), :hide => (:Nothing, Any[]), :query_tooltip => (:Cint, Any[:Int32, :Int32, :Cint, :(Ptr{GObject})]), :edge_reached => (:Nothing, [:UInt32]), :move_focus => (:Nothing, [:UInt32]), :mnemonic_activate => (:Cint, [:Cint]), :direction_changed => (:Nothing, [:UInt32]), :scroll_child => (:Cint, [:UInt32, :Cint]), :destroy => (:Nothing, Any[]), :keynav_failed => (:Cint, [:UInt32]), :realize => (:Nothing, Any[]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkScrolledWindow
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkScrolledWindow
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkSearchBar] = GtkSearchBarLeaf
    (GLib.g_type(::Type{T}) where T <: GtkSearchBar) = ccall(("gtk_search_bar_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkSearchBar})
        signalnames(supertype(GtkSearchBar))
    end
    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
    gtype_wrapper_cache[:GtkSearchEntry] = GtkSearchEntryLeaf
    (GLib.g_type(::Type{T}) where T <: GtkSearchEntry) = ccall(("gtk_search_entry_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkSearchEntry})
        vcat([:activate, :next_match, :previous_match, :search_changed, :search_started, :stop_search, :changed, :delete_text, :insert_text], signalnames(supertype(GtkSearchEntry)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :state_flags_changed => (:Nothing, [:UInt32]), :map => (:Nothing, Any[]), :previous_match => (:Nothing, Any[]), :search_started => (:Nothing, Any[]), :search_changed => (:Nothing, Any[]), :unrealize => (:Nothing, Any[]), :stop_search => (:Nothing, Any[]), :show => (:Nothing, Any[]), :unmap => (:Nothing, Any[]), :hide => (:Nothing, Any[]), :query_tooltip => (:Cint, Any[:Int32, :Int32, :Cint, :(Ptr{GObject})]), :next_match => (:Nothing, Any[]), :move_focus => (:Nothing, [:UInt32]), :mnemonic_activate => (:Cint, [:Cint]), :direction_changed => (:Nothing, [:UInt32]), :activate => (:Nothing, Any[]), :destroy => (:Nothing, Any[]), :keynav_failed => (:Cint, [:UInt32]), :realize => (:Nothing, Any[]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkSearchEntry
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkSearchEntry
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkSelectionFilterModel] = GtkSelectionFilterModelLeaf
    (GLib.g_type(::Type{T}) where T <: GtkSelectionFilterModel) = ccall(("gtk_selection_filter_model_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkSelectionFilterModel})
        vcat([:items_changed], signalnames(supertype(GtkSelectionFilterModel)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkSelectionFilterModel
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkSelectionFilterModel
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkSeparator] = GtkSeparatorLeaf
    (GLib.g_type(::Type{T}) where T <: GtkSeparator) = ccall(("gtk_separator_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkSeparator})
        signalnames(supertype(GtkSeparator))
    end
    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
    gtype_wrapper_cache[:GtkSettings] = GtkSettingsLeaf
    (GLib.g_type(::Type{T}) where T <: GtkSettings) = ccall(("gtk_settings_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkSettings})
        vcat([:gtk_private_changed], signalnames(supertype(GtkSettings)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkSettings
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkSettings
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkShortcut] = GtkShortcutLeaf
    (GLib.g_type(::Type{T}) where T <: GtkShortcut) = ccall(("gtk_shortcut_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkShortcut})
        signalnames(supertype(GtkShortcut))
    end
    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
    gtype_wrapper_cache[:GtkShortcutController] = GtkShortcutControllerLeaf
    (GLib.g_type(::Type{T}) where T <: GtkShortcutController) = ccall(("gtk_shortcut_controller_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkShortcutController})
        vcat([:items_changed], signalnames(supertype(GtkShortcutController)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkShortcutController
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkShortcutController
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkShortcutLabel] = GtkShortcutLabelLeaf
    (GLib.g_type(::Type{T}) where T <: GtkShortcutLabel) = ccall(("gtk_shortcut_label_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkShortcutLabel})
        signalnames(supertype(GtkShortcutLabel))
    end
    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
    gtype_wrapper_cache[:GtkShortcutsGroup] = GtkShortcutsGroupLeaf
    (GLib.g_type(::Type{T}) where T <: GtkShortcutsGroup) = ccall(("gtk_shortcuts_group_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkShortcutsGroup})
        signalnames(supertype(GtkShortcutsGroup))
    end
    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
    gtype_wrapper_cache[:GtkShortcutsSection] = GtkShortcutsSectionLeaf
    (GLib.g_type(::Type{T}) where T <: GtkShortcutsSection) = ccall(("gtk_shortcuts_section_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkShortcutsSection})
        vcat([:change_current_page], signalnames(supertype(GtkShortcutsSection)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :state_flags_changed => (:Nothing, [:UInt32]), :map => (:Nothing, Any[]), :unrealize => (:Nothing, Any[]), :show => (:Nothing, Any[]), :unmap => (:Nothing, Any[]), :change_current_page => (:Cint, [:Int32]), :hide => (:Nothing, Any[]), :query_tooltip => (:Cint, Any[:Int32, :Int32, :Cint, :(Ptr{GObject})]), :move_focus => (:Nothing, [:UInt32]), :mnemonic_activate => (:Cint, [:Cint]), :direction_changed => (:Nothing, [:UInt32]), :destroy => (:Nothing, Any[]), :keynav_failed => (:Cint, [:UInt32]), :realize => (:Nothing, Any[]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkShortcutsSection
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkShortcutsSection
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkShortcutsShortcut] = GtkShortcutsShortcutLeaf
    (GLib.g_type(::Type{T}) where T <: GtkShortcutsShortcut) = ccall(("gtk_shortcuts_shortcut_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkShortcutsShortcut})
        signalnames(supertype(GtkShortcutsShortcut))
    end
    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
    gtype_wrapper_cache[:GtkShortcutsWindow] = GtkShortcutsWindowLeaf
    (GLib.g_type(::Type{T}) where T <: GtkShortcutsWindow) = ccall(("gtk_shortcuts_window_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkShortcutsWindow})
        vcat([:close, :search], signalnames(supertype(GtkShortcutsWindow)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :state_flags_changed => (:Nothing, [:UInt32]), :map => (:Nothing, Any[]), :search => (:Nothing, Any[]), :close => (:Nothing, Any[]), :keys_changed => (:Nothing, Any[]), :close_request => (:Cint, Any[]), :enable_debugging => (:Cint, [:Cint]), :unrealize => (:Nothing, Any[]), :activate_focus => (:Nothing, Any[]), :show => (:Nothing, Any[]), :unmap => (:Nothing, Any[]), :hide => (:Nothing, Any[]), :query_tooltip => (:Cint, Any[:Int32, :Int32, :Cint, :(Ptr{GObject})]), :activate_default => (:Nothing, Any[]), :move_focus => (:Nothing, [:UInt32]), :mnemonic_activate => (:Cint, [:Cint]), :direction_changed => (:Nothing, [:UInt32]), :destroy => (:Nothing, Any[]), :keynav_failed => (:Cint, [:UInt32]), :realize => (:Nothing, Any[]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkShortcutsWindow
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkShortcutsWindow
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkSignalAction] = GtkSignalActionLeaf
    (GLib.g_type(::Type{T}) where T <: GtkSignalAction) = ccall(("gtk_signal_action_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkSignalAction})
        signalnames(supertype(GtkSignalAction))
    end
    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
    gtype_wrapper_cache[:GtkSignalListItemFactory] = GtkSignalListItemFactoryLeaf
    (GLib.g_type(::Type{T}) where T <: GtkSignalListItemFactory) = ccall(("gtk_signal_list_item_factory_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkSignalListItemFactory})
        vcat([:bind, :setup, :teardown, :unbind], signalnames(supertype(GtkSignalListItemFactory)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :setup => (:Nothing, Expr[:(Ptr{GObject})]), :unbind => (:Nothing, Expr[:(Ptr{GObject})]), :teardown => (:Nothing, Expr[:(Ptr{GObject})]), :bind => (:Nothing, Expr[:(Ptr{GObject})]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkSignalListItemFactory
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkSignalListItemFactory
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkSingleSelection] = GtkSingleSelectionLeaf
    (GLib.g_type(::Type{T}) where T <: GtkSingleSelection) = ccall(("gtk_single_selection_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkSingleSelection})
        vcat([:items_changed, :sections_changed, :selection_changed], signalnames(supertype(GtkSingleSelection)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkSingleSelection
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkSingleSelection
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkSizeGroup] = GtkSizeGroupLeaf
    (GLib.g_type(::Type{T}) where T <: GtkSizeGroup) = ccall(("gtk_size_group_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkSizeGroup})
        signalnames(supertype(GtkSizeGroup))
    end
    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
    gtype_wrapper_cache[:GtkSliceListModel] = GtkSliceListModelLeaf
    (GLib.g_type(::Type{T}) where T <: GtkSliceListModel) = ccall(("gtk_slice_list_model_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkSliceListModel})
        vcat([:items_changed, :sections_changed], signalnames(supertype(GtkSliceListModel)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkSliceListModel
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkSliceListModel
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkSnapshot] = GtkSnapshotLeaf
    (GLib.g_type(::Type{T}) where T <: GtkSnapshot) = ccall(("gtk_snapshot_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkSnapshot})
        signalnames(supertype(GtkSnapshot))
    end
    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
    gtype_wrapper_cache[:GtkSortListModel] = GtkSortListModelLeaf
    (GLib.g_type(::Type{T}) where T <: GtkSortListModel) = ccall(("gtk_sort_list_model_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkSortListModel})
        vcat([:items_changed, :sections_changed], signalnames(supertype(GtkSortListModel)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkSortListModel
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkSortListModel
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkSpinButton] = GtkSpinButtonLeaf
    (GLib.g_type(::Type{T}) where T <: GtkSpinButton) = ccall(("gtk_spin_button_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkSpinButton})
        vcat([:activate, :change_value, :input, :output, :value_changed, :wrapped, :editing_done, :remove_widget, :changed, :delete_text, :insert_text], signalnames(supertype(GtkSpinButton)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :state_flags_changed => (:Nothing, [:UInt32]), :map => (:Nothing, Any[]), :change_value => (:Nothing, [:UInt32]), :unrealize => (:Nothing, Any[]), :input => (:Int32, [:Float64]), :value_changed => (:Nothing, Any[]), :wrapped => (:Nothing, Any[]), :output => (:Cint, Any[]), :show => (:Nothing, Any[]), :unmap => (:Nothing, Any[]), :hide => (:Nothing, Any[]), :query_tooltip => (:Cint, Any[:Int32, :Int32, :Cint, :(Ptr{GObject})]), :move_focus => (:Nothing, [:UInt32]), :mnemonic_activate => (:Cint, [:Cint]), :direction_changed => (:Nothing, [:UInt32]), :activate => (:Nothing, Any[]), :destroy => (:Nothing, Any[]), :keynav_failed => (:Cint, [:UInt32]), :realize => (:Nothing, Any[]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkSpinButton
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkSpinButton
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkSpinner] = GtkSpinnerLeaf
    (GLib.g_type(::Type{T}) where T <: GtkSpinner) = ccall(("gtk_spinner_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkSpinner})
        signalnames(supertype(GtkSpinner))
    end
    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
    gtype_wrapper_cache[:GtkStack] = GtkStackLeaf
    (GLib.g_type(::Type{T}) where T <: GtkStack) = ccall(("gtk_stack_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkStack})
        signalnames(supertype(GtkStack))
    end
    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
    gtype_wrapper_cache[:GtkStackPage] = GtkStackPageLeaf
    (GLib.g_type(::Type{T}) where T <: GtkStackPage) = ccall(("gtk_stack_page_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkStackPage})
        signalnames(supertype(GtkStackPage))
    end
    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
    gtype_wrapper_cache[:GtkStackSidebar] = GtkStackSidebarLeaf
    (GLib.g_type(::Type{T}) where T <: GtkStackSidebar) = ccall(("gtk_stack_sidebar_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkStackSidebar})
        signalnames(supertype(GtkStackSidebar))
    end
    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
    gtype_wrapper_cache[:GtkStackSwitcher] = GtkStackSwitcherLeaf
    (GLib.g_type(::Type{T}) where T <: GtkStackSwitcher) = ccall(("gtk_stack_switcher_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkStackSwitcher})
        signalnames(supertype(GtkStackSwitcher))
    end
    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
    gtype_wrapper_cache[:GtkStatusbar] = GtkStatusbarLeaf
    (GLib.g_type(::Type{T}) where T <: GtkStatusbar) = ccall(("gtk_statusbar_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkStatusbar})
        vcat([:text_popped, :text_pushed], signalnames(supertype(GtkStatusbar)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :state_flags_changed => (:Nothing, [:UInt32]), :map => (:Nothing, Any[]), :unrealize => (:Nothing, Any[]), :text_popped => (:Nothing, [:UInt32, :Cstring]), :show => (:Nothing, Any[]), :unmap => (:Nothing, Any[]), :text_pushed => (:Nothing, [:UInt32, :Cstring]), :hide => (:Nothing, Any[]), :query_tooltip => (:Cint, Any[:Int32, :Int32, :Cint, :(Ptr{GObject})]), :move_focus => (:Nothing, [:UInt32]), :mnemonic_activate => (:Cint, [:Cint]), :direction_changed => (:Nothing, [:UInt32]), :destroy => (:Nothing, Any[]), :keynav_failed => (:Cint, [:UInt32]), :realize => (:Nothing, Any[]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkStatusbar
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkStatusbar
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkStringFilter] = GtkStringFilterLeaf
    (GLib.g_type(::Type{T}) where T <: GtkStringFilter) = ccall(("gtk_string_filter_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkStringFilter})
        signalnames(supertype(GtkStringFilter))
    end
    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
    gtype_wrapper_cache[:GtkStringList] = GtkStringListLeaf
    (GLib.g_type(::Type{T}) where T <: GtkStringList) = ccall(("gtk_string_list_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkStringList})
        vcat([:items_changed], signalnames(supertype(GtkStringList)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkStringList
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkStringList
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkStringObject] = GtkStringObjectLeaf
    (GLib.g_type(::Type{T}) where T <: GtkStringObject) = ccall(("gtk_string_object_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkStringObject})
        signalnames(supertype(GtkStringObject))
    end
    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
    gtype_wrapper_cache[:GtkStringSorter] = GtkStringSorterLeaf
    (GLib.g_type(::Type{T}) where T <: GtkStringSorter) = ccall(("gtk_string_sorter_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkStringSorter})
        signalnames(supertype(GtkStringSorter))
    end
    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
    gtype_wrapper_cache[:GtkStyleContext] = GtkStyleContextLeaf
    (GLib.g_type(::Type{T}) where T <: GtkStyleContext) = ccall(("gtk_style_context_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkStyleContext})
        signalnames(supertype(GtkStyleContext))
    end
    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
    gtype_wrapper_cache[:GtkSwitch] = GtkSwitchLeaf
    (GLib.g_type(::Type{T}) where T <: GtkSwitch) = ccall(("gtk_switch_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkSwitch})
        vcat([:activate, :state_set], signalnames(supertype(GtkSwitch)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :state_flags_changed => (:Nothing, [:UInt32]), :map => (:Nothing, Any[]), :unrealize => (:Nothing, Any[]), :show => (:Nothing, Any[]), :unmap => (:Nothing, Any[]), :hide => (:Nothing, Any[]), :query_tooltip => (:Cint, Any[:Int32, :Int32, :Cint, :(Ptr{GObject})]), :state_set => (:Cint, [:Cint]), :move_focus => (:Nothing, [:UInt32]), :mnemonic_activate => (:Cint, [:Cint]), :direction_changed => (:Nothing, [:UInt32]), :activate => (:Nothing, Any[]), :destroy => (:Nothing, Any[]), :keynav_failed => (:Cint, [:UInt32]), :realize => (:Nothing, Any[]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkSwitch
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkSwitch
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkText] = GtkTextLeaf
    (GLib.g_type(::Type{T}) where T <: GtkText) = ccall(("gtk_text_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkText})
        vcat([:activate, :backspace, :copy_clipboard, :cut_clipboard, :delete_from_cursor, :insert_at_cursor, :insert_emoji, :move_cursor, :paste_clipboard, :preedit_changed, :toggle_overwrite, :changed, :delete_text, :insert_text], signalnames(supertype(GtkText)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :insert_at_cursor => (:Nothing, [:Cstring]), :map => (:Nothing, Any[]), :preedit_changed => (:Nothing, [:Cstring]), :cut_clipboard => (:Nothing, Any[]), :insert_emoji => (:Nothing, Any[]), :move_focus => (:Nothing, [:UInt32]), :activate => (:Nothing, Any[]), :direction_changed => (:Nothing, [:UInt32]), :state_flags_changed => (:Nothing, [:UInt32]), :delete_from_cursor => (:Nothing, [:UInt32, :Int32]), :unrealize => (:Nothing, Any[]), :toggle_overwrite => (:Nothing, Any[]), :backspace => (:Nothing, Any[]), :paste_clipboard => (:Nothing, Any[]), :move_cursor => (:Nothing, [:UInt32, :Int32, :Cint]), :show => (:Nothing, Any[]), :unmap => (:Nothing, Any[]), :copy_clipboard => (:Nothing, Any[]), :hide => (:Nothing, Any[]), :query_tooltip => (:Cint, Any[:Int32, :Int32, :Cint, :(Ptr{GObject})]), :mnemonic_activate => (:Cint, [:Cint]), :destroy => (:Nothing, Any[]), :keynav_failed => (:Cint, [:UInt32]), :realize => (:Nothing, Any[]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkText
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkText
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkTextBuffer] = GtkTextBufferLeaf
    (GLib.g_type(::Type{T}) where T <: GtkTextBuffer) = ccall(("gtk_text_buffer_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkTextBuffer})
        vcat([:apply_tag, :begin_user_action, :changed, :delete_range, :end_user_action, :insert_child_anchor, :insert_paintable, :insert_text, :mark_deleted, :mark_set, :modified_changed, :paste_done, :redo, :remove_tag, :undo], signalnames(supertype(GtkTextBuffer)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :undo => (:Nothing, Any[]), :remove_tag => (:Nothing, Any[:(Ptr{GObject}), :_GtkTextIter, :_GtkTextIter]), :insert_child_anchor => (:Nothing, Any[:_GtkTextIter, :(Ptr{GObject})]), :redo => (:Nothing, Any[]), :begin_user_action => (:Nothing, Any[]), :delete_range => (:Nothing, [:_GtkTextIter, :_GtkTextIter]), :mark_deleted => (:Nothing, Expr[:(Ptr{GObject})]), :end_user_action => (:Nothing, Any[]), :modified_changed => (:Nothing, Any[]), :mark_set => (:Nothing, Any[:_GtkTextIter, :(Ptr{GObject})]), :insert_paintable => (:Nothing, Any[:_GtkTextIter, :(Ptr{GObject})]), :apply_tag => (:Nothing, Any[:(Ptr{GObject}), :_GtkTextIter, :_GtkTextIter]), :changed => (:Nothing, Any[]), :insert_text => (:Nothing, [:_GtkTextIter, :Cstring, :Int32]), :paste_done => (:Nothing, Expr[:(Ptr{GObject})]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkTextBuffer
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkTextBuffer
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkTextChildAnchor] = GtkTextChildAnchorLeaf
    (GLib.g_type(::Type{T}) where T <: GtkTextChildAnchor) = ccall(("gtk_text_child_anchor_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkTextChildAnchor})
        signalnames(supertype(GtkTextChildAnchor))
    end
    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
    gtype_wrapper_cache[:GtkTextMark] = GtkTextMarkLeaf
    (GLib.g_type(::Type{T}) where T <: GtkTextMark) = ccall(("gtk_text_mark_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkTextMark})
        signalnames(supertype(GtkTextMark))
    end
    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
    gtype_wrapper_cache[:GtkTextTag] = GtkTextTagLeaf
    (GLib.g_type(::Type{T}) where T <: GtkTextTag) = ccall(("gtk_text_tag_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkTextTag})
        signalnames(supertype(GtkTextTag))
    end
    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
    gtype_wrapper_cache[:GtkTextTagTable] = GtkTextTagTableLeaf
    (GLib.g_type(::Type{T}) where T <: GtkTextTagTable) = ccall(("gtk_text_tag_table_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkTextTagTable})
        vcat([:tag_added, :tag_changed, :tag_removed], signalnames(supertype(GtkTextTagTable)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :tag_added => (:Nothing, Expr[:(Ptr{GObject})]), :tag_removed => (:Nothing, Expr[:(Ptr{GObject})]), :tag_changed => (:Nothing, Any[:(Ptr{GObject}), :Cint]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkTextTagTable
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkTextTagTable
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkTextView] = GtkTextViewLeaf
    (GLib.g_type(::Type{T}) where T <: GtkTextView) = ccall(("gtk_text_view_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkTextView})
        vcat([:backspace, :copy_clipboard, :cut_clipboard, :delete_from_cursor, :extend_selection, :insert_at_cursor, :insert_emoji, :move_cursor, :move_viewport, :paste_clipboard, :preedit_changed, :select_all, :set_anchor, :toggle_cursor_visible, :toggle_overwrite], signalnames(supertype(GtkTextView)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :insert_at_cursor => (:Nothing, [:Cstring]), :map => (:Nothing, Any[]), :preedit_changed => (:Nothing, [:Cstring]), :cut_clipboard => (:Nothing, Any[]), :insert_emoji => (:Nothing, Any[]), :toggle_cursor_visible => (:Nothing, Any[]), :move_focus => (:Nothing, [:UInt32]), :direction_changed => (:Nothing, [:UInt32]), :state_flags_changed => (:Nothing, [:UInt32]), :select_all => (:Nothing, [:Cint]), :extend_selection => (:Cint, [:UInt32, :_GtkTextIter, :_GtkTextIter, :_GtkTextIter]), :delete_from_cursor => (:Nothing, [:UInt32, :Int32]), :unrealize => (:Nothing, Any[]), :set_anchor => (:Nothing, Any[]), :toggle_overwrite => (:Nothing, Any[]), :backspace => (:Nothing, Any[]), :move_viewport => (:Nothing, [:UInt32, :Int32]), :move_cursor => (:Nothing, [:UInt32, :Int32, :Cint]), :paste_clipboard => (:Nothing, Any[]), :show => (:Nothing, Any[]), :unmap => (:Nothing, Any[]), :copy_clipboard => (:Nothing, Any[]), :hide => (:Nothing, Any[]), :query_tooltip => (:Cint, Any[:Int32, :Int32, :Cint, :(Ptr{GObject})]), :mnemonic_activate => (:Cint, [:Cint]), :destroy => (:Nothing, Any[]), :keynav_failed => (:Cint, [:UInt32]), :realize => (:Nothing, Any[]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkTextView
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkTextView
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkToggleButton] = GtkToggleButtonLeaf
    (GLib.g_type(::Type{T}) where T <: GtkToggleButton) = ccall(("gtk_toggle_button_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkToggleButton})
        vcat([:toggled], signalnames(supertype(GtkToggleButton)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :state_flags_changed => (:Nothing, [:UInt32]), :map => (:Nothing, Any[]), :unrealize => (:Nothing, Any[]), :toggled => (:Nothing, Any[]), :show => (:Nothing, Any[]), :unmap => (:Nothing, Any[]), :hide => (:Nothing, Any[]), :query_tooltip => (:Cint, Any[:Int32, :Int32, :Cint, :(Ptr{GObject})]), :clicked => (:Nothing, Any[]), :move_focus => (:Nothing, [:UInt32]), :mnemonic_activate => (:Cint, [:Cint]), :direction_changed => (:Nothing, [:UInt32]), :activate => (:Nothing, Any[]), :destroy => (:Nothing, Any[]), :keynav_failed => (:Cint, [:UInt32]), :realize => (:Nothing, Any[]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkToggleButton
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkToggleButton
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkTooltip] = GtkTooltipLeaf
    (GLib.g_type(::Type{T}) where T <: GtkTooltip) = ccall(("gtk_tooltip_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkTooltip})
        signalnames(supertype(GtkTooltip))
    end
    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
    gtype_wrapper_cache[:GtkTreeExpander] = GtkTreeExpanderLeaf
    (GLib.g_type(::Type{T}) where T <: GtkTreeExpander) = ccall(("gtk_tree_expander_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkTreeExpander})
        signalnames(supertype(GtkTreeExpander))
    end
    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
    gtype_wrapper_cache[:GtkTreeListModel] = GtkTreeListModelLeaf
    (GLib.g_type(::Type{T}) where T <: GtkTreeListModel) = ccall(("gtk_tree_list_model_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkTreeListModel})
        vcat([:items_changed], signalnames(supertype(GtkTreeListModel)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkTreeListModel
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkTreeListModel
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkTreeListRow] = GtkTreeListRowLeaf
    (GLib.g_type(::Type{T}) where T <: GtkTreeListRow) = ccall(("gtk_tree_list_row_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkTreeListRow})
        signalnames(supertype(GtkTreeListRow))
    end
    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
    gtype_wrapper_cache[:GtkTreeListRowSorter] = GtkTreeListRowSorterLeaf
    (GLib.g_type(::Type{T}) where T <: GtkTreeListRowSorter) = ccall(("gtk_tree_list_row_sorter_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkTreeListRowSorter})
        signalnames(supertype(GtkTreeListRowSorter))
    end
    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
    gtype_wrapper_cache[:GtkTreeModelFilter] = GtkTreeModelFilterLeaf
    (GLib.g_type(::Type{T}) where T <: GtkTreeModelFilter) = ccall(("gtk_tree_model_filter_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkTreeModelFilter})
        vcat([:row_changed, :row_deleted, :row_has_child_toggled, :row_inserted], signalnames(supertype(GtkTreeModelFilter)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkTreeModelFilter
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkTreeModelFilter
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkTreeModelSort] = GtkTreeModelSortLeaf
    (GLib.g_type(::Type{T}) where T <: GtkTreeModelSort) = ccall(("gtk_tree_model_sort_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkTreeModelSort})
        vcat([:row_changed, :row_deleted, :row_has_child_toggled, :row_inserted, :sort_column_changed], signalnames(supertype(GtkTreeModelSort)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkTreeModelSort
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkTreeModelSort
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkTreeSelection] = GtkTreeSelectionLeaf
    (GLib.g_type(::Type{T}) where T <: GtkTreeSelection) = ccall(("gtk_tree_selection_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkTreeSelection})
        vcat([:changed], signalnames(supertype(GtkTreeSelection)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :changed => (:Nothing, Any[]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkTreeSelection
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkTreeSelection
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkTreeStore] = GtkTreeStoreLeaf
    (GLib.g_type(::Type{T}) where T <: GtkTreeStore) = ccall(("gtk_tree_store_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkTreeStore})
        vcat([:row_changed, :row_deleted, :row_has_child_toggled, :row_inserted, :sort_column_changed], signalnames(supertype(GtkTreeStore)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkTreeStore
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkTreeStore
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkTreeView] = GtkTreeViewLeaf
    (GLib.g_type(::Type{T}) where T <: GtkTreeView) = ccall(("gtk_tree_view_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkTreeView})
        vcat([:columns_changed, :cursor_changed, :expand_collapse_cursor_row, :move_cursor, :row_activated, :row_collapsed, :row_expanded, :select_all, :select_cursor_parent, :select_cursor_row, :start_interactive_search, :test_collapse_row, :test_expand_row, :toggle_cursor_row, :unselect_all], signalnames(supertype(GtkTreeView)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :select_cursor_row => (:Cint, [:Cint]), :map => (:Nothing, Any[]), :start_interactive_search => (:Cint, Any[]), :row_activated => (:Nothing, Any[:GtkTreePath, :(Ptr{GObject})]), :test_expand_row => (:Cint, [:_GtkTreeIter, :GtkTreePath]), :row_expanded => (:Nothing, [:_GtkTreeIter, :GtkTreePath]), :select_cursor_parent => (:Cint, Any[]), :toggle_cursor_row => (:Cint, Any[]), :move_focus => (:Nothing, [:UInt32]), :direction_changed => (:Nothing, [:UInt32]), :test_collapse_row => (:Cint, [:_GtkTreeIter, :GtkTreePath]), :state_flags_changed => (:Nothing, [:UInt32]), :select_all => (:Cint, Any[]), :cursor_changed => (:Nothing, Any[]), :expand_collapse_cursor_row => (:Cint, [:Cint, :Cint, :Cint]), :unrealize => (:Nothing, Any[]), :unselect_all => (:Cint, Any[]), :move_cursor => (:Cint, [:UInt32, :Int32, :Cint, :Cint]), :row_collapsed => (:Nothing, [:_GtkTreeIter, :GtkTreePath]), :show => (:Nothing, Any[]), :unmap => (:Nothing, Any[]), :columns_changed => (:Nothing, Any[]), :hide => (:Nothing, Any[]), :query_tooltip => (:Cint, Any[:Int32, :Int32, :Cint, :(Ptr{GObject})]), :mnemonic_activate => (:Cint, [:Cint]), :destroy => (:Nothing, Any[]), :keynav_failed => (:Cint, [:UInt32]), :realize => (:Nothing, Any[]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkTreeView
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkTreeView
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkTreeViewColumn] = GtkTreeViewColumnLeaf
    (GLib.g_type(::Type{T}) where T <: GtkTreeViewColumn) = ccall(("gtk_tree_view_column_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkTreeViewColumn})
        vcat([:clicked], signalnames(supertype(GtkTreeViewColumn)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]), :clicked => (:Nothing, Any[]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkTreeViewColumn
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkTreeViewColumn
            Tuple(eval.((d[name])[2]))
        end
    end
    abstract type GtkUriLauncher <: GObject end
    mutable struct GtkUriLauncherLeaf <: GtkUriLauncher
        handle::Ptr{GObject}
        function GtkUriLauncherLeaf(handle::Ptr{GObject}, owns = false)
            if handle == C_NULL
                error("Cannot construct GtkUriLauncherLeaf with a NULL pointer")
            end
            GLib.gobject_maybe_sink(handle, owns)
            return gobject_ref(new(handle))
        end
    end
    gtype_wrapper_cache[:GtkUriLauncher] = GtkUriLauncherLeaf
    (GLib.g_type(::Type{T}) where T <: GtkUriLauncher) = ccall(("gtk_uri_launcher_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkUriLauncher})
        signalnames(supertype(GtkUriLauncher))
    end
    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
    gtype_wrapper_cache[:GtkVideo] = GtkVideoLeaf
    (GLib.g_type(::Type{T}) where T <: GtkVideo) = ccall(("gtk_video_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkVideo})
        signalnames(supertype(GtkVideo))
    end
    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
    gtype_wrapper_cache[:GtkViewport] = GtkViewportLeaf
    (GLib.g_type(::Type{T}) where T <: GtkViewport) = ccall(("gtk_viewport_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkViewport})
        signalnames(supertype(GtkViewport))
    end
    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
    gtype_wrapper_cache[:GtkVolumeButton] = GtkVolumeButtonLeaf
    (GLib.g_type(::Type{T}) where T <: GtkVolumeButton) = ccall(("gtk_volume_button_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkVolumeButton})
        signalnames(supertype(GtkVolumeButton))
    end
    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
    gtype_wrapper_cache[:GtkWidgetPaintable] = GtkWidgetPaintableLeaf
    (GLib.g_type(::Type{T}) where T <: GtkWidgetPaintable) = ccall(("gtk_widget_paintable_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkWidgetPaintable})
        vcat([:invalidate_contents, :invalidate_size], signalnames(supertype(GtkWidgetPaintable)))
    end
    let d = Dict{Symbol, Tuple{Any, Any}}(:notify => (:Nothing, Any[:(Ptr{GParamSpec})]))
        function GLib.signal_return_type(::Type{T}, name::Symbol) where T <: GtkWidgetPaintable
            eval((d[name])[1])
        end
        function GLib.signal_argument_types(::Type{T}, name::Symbol) where T <: GtkWidgetPaintable
            Tuple(eval.((d[name])[2]))
        end
    end
    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
    gtype_wrapper_cache[:GtkWindowControls] = GtkWindowControlsLeaf
    (GLib.g_type(::Type{T}) where T <: GtkWindowControls) = ccall(("gtk_window_controls_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkWindowControls})
        signalnames(supertype(GtkWindowControls))
    end
    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
    gtype_wrapper_cache[:GtkWindowGroup] = GtkWindowGroupLeaf
    (GLib.g_type(::Type{T}) where T <: GtkWindowGroup) = ccall(("gtk_window_group_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkWindowGroup})
        signalnames(supertype(GtkWindowGroup))
    end
    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
    gtype_wrapper_cache[:GtkWindowHandle] = GtkWindowHandleLeaf
    (GLib.g_type(::Type{T}) where T <: GtkWindowHandle) = ccall(("gtk_window_handle_get_type", libgtk4), GType, ())
    function GLib.signalnames(::Type{GtkWindowHandle})
        signalnames(supertype(GtkWindowHandle))
    end
    function GtkATContext(_accessible_role, _accessible::GtkAccessible, _display::GdkDisplay; kwargs...)
        obj = G_.ATContext_create(_accessible_role, _accessible, _display)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkAboutDialog(; kwargs...)
        obj = G_.AboutDialog_new()
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkActionBar(; kwargs...)
        obj = G_.ActionBar_new()
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkAdjustment(_value::Real, _lower::Real, _upper::Real, _step_increment::Real, _page_increment::Real, _page_size::Real; kwargs...)
        obj = G_.Adjustment_new(_value, _lower, _upper, _step_increment, _page_increment, _page_size)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkAlternativeTrigger(_first::GtkShortcutTrigger, _second::GtkShortcutTrigger; kwargs...)
        obj = G_.AlternativeTrigger_new(_first, _second)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkAnyFilter()
        G_.AnyFilter_new()
    end
    function GtkAppChooserButton(_content_type::Union{AbstractString, Symbol}; kwargs...)
        obj = G_.AppChooserButton_new(_content_type)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkAppChooserDialog(_parent::Maybe(GtkWindow), _flags, _file::GFile; kwargs...)
        obj = G_.AppChooserDialog_new(_parent, _flags, _file)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkAppChooserDialog(_parent::Maybe(GtkWindow), _flags, _content_type::Union{AbstractString, Symbol}; kwargs...)
        obj = G_.AppChooserDialog_new_for_content_type(_parent, _flags, _content_type)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkAppChooserWidget(_content_type::Union{AbstractString, Symbol}; kwargs...)
        obj = G_.AppChooserWidget_new(_content_type)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkApplication(_application_id::Maybe(Union{AbstractString, Symbol}), _flags; kwargs...)
        obj = G_.Application_new(_application_id, _flags)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkApplicationWindow(_application::GtkApplication; kwargs...)
        obj = G_.ApplicationWindow_new(_application)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkAspectFrame(_xalign::Real, _yalign::Real, _ratio::Real, _obey_child::Bool; kwargs...)
        obj = G_.AspectFrame_new(_xalign, _yalign, _ratio, _obey_child)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkAssistant(; kwargs...)
        obj = G_.Assistant_new()
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkBinLayout()
        G_.BinLayout_new()
    end
    function GtkBookmarkList(_filename::Maybe(Union{AbstractString, Symbol}), _attributes::Maybe(Union{AbstractString, Symbol}); kwargs...)
        obj = G_.BookmarkList_new(_filename, _attributes)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkBoolFilter(_expression::Maybe(GtkExpression); kwargs...)
        obj = G_.BoolFilter_new(_expression)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkBox(_orientation, _spacing::Integer; kwargs...)
        obj = G_.Box_new(_orientation, _spacing)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkBoxLayout(_orientation; kwargs...)
        obj = G_.BoxLayout_new(_orientation)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkBuilder(; kwargs...)
        obj = G_.Builder_new()
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkBuilder(_filename::Union{AbstractString, Symbol}; kwargs...)
        obj = G_.Builder_new_from_file(_filename)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkBuilder(_string::Union{AbstractString, Symbol}, _length::Integer; kwargs...)
        obj = G_.Builder_new_from_string(_string, _length)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkBuilderCScope()
        G_.BuilderCScope_new()
    end
    function GtkBuilderListItemFactory(_scope::Maybe(GtkBuilderScope), _bytes::GBytes; kwargs...)
        obj = G_.BuilderListItemFactory_new_from_bytes(_scope, _bytes)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkButton(; kwargs...)
        obj = G_.Button_new()
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkButton(_label::Union{AbstractString, Symbol}; kwargs...)
        obj = G_.Button_new_with_label(_label)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkCalendar(; kwargs...)
        obj = G_.Calendar_new()
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkCallbackAction(_callback::Function, _destroy::Function)
        G_.CallbackAction_new(_callback, _destroy)
    end
    function GtkCellAreaBox(; kwargs...)
        obj = G_.CellAreaBox_new()
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkCellRendererAccel(; kwargs...)
        obj = G_.CellRendererAccel_new()
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkCellRendererCombo(; kwargs...)
        obj = G_.CellRendererCombo_new()
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkCellRendererPixbuf(; kwargs...)
        obj = G_.CellRendererPixbuf_new()
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkCellRendererProgress(; kwargs...)
        obj = G_.CellRendererProgress_new()
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkCellRendererSpin(; kwargs...)
        obj = G_.CellRendererSpin_new()
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkCellRendererSpinner(; kwargs...)
        obj = G_.CellRendererSpinner_new()
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkCellRendererText(; kwargs...)
        obj = G_.CellRendererText_new()
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkCellRendererToggle(; kwargs...)
        obj = G_.CellRendererToggle_new()
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkCellView(; kwargs...)
        obj = G_.CellView_new()
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkCellView(_area::GtkCellArea, _context::GtkCellAreaContext; kwargs...)
        obj = G_.CellView_new_with_context(_area, _context)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkCellView(_markup::Union{AbstractString, Symbol}; kwargs...)
        obj = G_.CellView_new_with_markup(_markup)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkCellView(_texture::GdkTexture; kwargs...)
        obj = G_.CellView_new_with_texture(_texture)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkCenterBox(; kwargs...)
        obj = G_.CenterBox_new()
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkCenterLayout(; kwargs...)
        obj = G_.CenterLayout_new()
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkCheckButton(; kwargs...)
        obj = G_.CheckButton_new()
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkCheckButton(_label::Maybe(Union{AbstractString, Symbol}); kwargs...)
        obj = G_.CheckButton_new_with_label(_label)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkColorButton(; kwargs...)
        obj = G_.ColorButton_new()
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkColorButton(_rgba::GdkRGBALike; kwargs...)
        obj = G_.ColorButton_new_with_rgba(_rgba)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkColorChooserDialog(_title::Maybe(Union{AbstractString, Symbol}), _parent::Maybe(GtkWindow); kwargs...)
        obj = G_.ColorChooserDialog_new(_title, _parent)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkColorChooserWidget(; kwargs...)
        obj = G_.ColorChooserWidget_new()
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkColorDialog(; kwargs...)
        obj = G_.ColorDialog_new()
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkColorDialogButton(_dialog::Maybe(GtkColorDialog); kwargs...)
        obj = G_.ColorDialogButton_new(_dialog)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkColumnView(_model::Maybe(GtkSelectionModel); kwargs...)
        obj = G_.ColumnView_new(_model)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkColumnViewColumn(_title::Maybe(Union{AbstractString, Symbol}), _factory::Maybe(GtkListItemFactory); kwargs...)
        obj = G_.ColumnViewColumn_new(_title, _factory)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkComboBox(; kwargs...)
        obj = G_.ComboBox_new()
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkComboBox(_model::GtkTreeModel; kwargs...)
        obj = G_.ComboBox_new_with_model(_model)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkComboBoxText()
        G_.ComboBoxText_new()
    end
    function GtkConstantExpression(_value::GValueLike)
        G_.ConstantExpression_new_for_value(_value)
    end
    function GtkConstraint(_target::Maybe(GtkConstraintTarget), _target_attribute, _relation, _source::Maybe(GtkConstraintTarget), _source_attribute, _multiplier::Real, _constant::Real, _strength::Integer; kwargs...)
        obj = G_.Constraint_new(_target, _target_attribute, _relation, _source, _source_attribute, _multiplier, _constant, _strength)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkConstraint(_target::Maybe(GtkConstraintTarget), _target_attribute, _relation, _constant::Real, _strength::Integer; kwargs...)
        obj = G_.Constraint_new_constant(_target, _target_attribute, _relation, _constant, _strength)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkConstraintGuide(; kwargs...)
        obj = G_.ConstraintGuide_new()
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkConstraintLayout()
        G_.ConstraintLayout_new()
    end
    function GtkCssProvider()
        G_.CssProvider_new()
    end
    function GtkCustomFilter(_match_func::Maybe(Function), _user_destroy::Function)
        G_.CustomFilter_new(_match_func, _user_destroy)
    end
    function GtkCustomLayout(_request_mode::Maybe(Function), _measure::Function, _allocate::Function)
        G_.CustomLayout_new(_request_mode, _measure, _allocate)
    end
    function GtkCustomSorter(_sort_func::Maybe(Function), _user_destroy::Maybe(Function))
        G_.CustomSorter_new(_sort_func, _user_destroy)
    end
    function GtkDialog(; kwargs...)
        obj = G_.Dialog_new()
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkDirectoryList(_attributes::Maybe(Union{AbstractString, Symbol}), _file::Maybe(GFile); kwargs...)
        obj = G_.DirectoryList_new(_attributes, _file)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkDragIcon(_drag::GdkDrag; kwargs...)
        obj = G_.DragIcon_get_for_drag(_drag)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkDragSource(; kwargs...)
        obj = G_.DragSource_new()
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkDrawingArea(; kwargs...)
        obj = G_.DrawingArea_new()
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkDropControllerMotion(; kwargs...)
        obj = G_.DropControllerMotion_new()
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkDropDown(_model::Maybe(GListModel), _expression::Maybe(GtkExpression); kwargs...)
        obj = G_.DropDown_new(_model, _expression)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkDropDown(_strings; kwargs...)
        obj = G_.DropDown_new_from_strings(_strings)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkDropTarget(_type::Integer, _actions; kwargs...)
        obj = G_.DropTarget_new(_type, _actions)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkDropTargetAsync(_formats::Maybe(GdkContentFormats), _actions; kwargs...)
        obj = G_.DropTargetAsync_new(_formats, _actions)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkEditableLabel(_str::Union{AbstractString, Symbol}; kwargs...)
        obj = G_.EditableLabel_new(_str)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkEmojiChooser()
        G_.EmojiChooser_new()
    end
    function GtkEntry(; kwargs...)
        obj = G_.Entry_new()
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkEntry(_buffer::GtkEntryBuffer; kwargs...)
        obj = G_.Entry_new_with_buffer(_buffer)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkEntryBuffer(_initial_chars::Maybe(Union{AbstractString, Symbol}), _n_initial_chars::Integer; kwargs...)
        obj = G_.EntryBuffer_new(_initial_chars, _n_initial_chars)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkEntryCompletion(; kwargs...)
        obj = G_.EntryCompletion_new()
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkEntryCompletion(_area::GtkCellArea; kwargs...)
        obj = G_.EntryCompletion_new_with_area(_area)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkEventControllerFocus(; kwargs...)
        obj = G_.EventControllerFocus_new()
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkEventControllerKey()
        G_.EventControllerKey_new()
    end
    function GtkEventControllerLegacy()
        G_.EventControllerLegacy_new()
    end
    function GtkEventControllerMotion(; kwargs...)
        obj = G_.EventControllerMotion_new()
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkEventControllerScroll(_flags; kwargs...)
        obj = G_.EventControllerScroll_new(_flags)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkEveryFilter()
        G_.EveryFilter_new()
    end
    function GtkExpander(_label::Maybe(Union{AbstractString, Symbol}); kwargs...)
        obj = G_.Expander_new(_label)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkFileChooserNative(_title::Maybe(Union{AbstractString, Symbol}), _parent::Maybe(GtkWindow), _action, _accept_label::Maybe(Union{AbstractString, Symbol}), _cancel_label::Maybe(Union{AbstractString, Symbol}); kwargs...)
        obj = G_.FileChooserNative_new(_title, _parent, _action, _accept_label, _cancel_label)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkFileChooserWidget(_action; kwargs...)
        obj = G_.FileChooserWidget_new(_action)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkFileDialog(; kwargs...)
        obj = G_.FileDialog_new()
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkFileFilter(; kwargs...)
        obj = G_.FileFilter_new()
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkFileFilter(_variant::GVariant; kwargs...)
        obj = G_.FileFilter_new_from_gvariant(_variant)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkFileLauncher(_file::Maybe(GFile); kwargs...)
        obj = G_.FileLauncher_new(_file)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkFilterListModel(_model::Maybe(GListModel), _filter::Maybe(GtkFilter); kwargs...)
        obj = G_.FilterListModel_new(_model, _filter)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkFixed()
        G_.Fixed_new()
    end
    function GtkFixedLayout()
        G_.FixedLayout_new()
    end
    function GtkFlattenListModel(_model::Maybe(GListModel); kwargs...)
        obj = G_.FlattenListModel_new(_model)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkFlowBox(; kwargs...)
        obj = G_.FlowBox_new()
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkFlowBoxChild(; kwargs...)
        obj = G_.FlowBoxChild_new()
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkFontButton(; kwargs...)
        obj = G_.FontButton_new()
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkFontButton(_fontname::Union{AbstractString, Symbol}; kwargs...)
        obj = G_.FontButton_new_with_font(_fontname)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkFontChooserDialog(_title::Maybe(Union{AbstractString, Symbol}), _parent::Maybe(GtkWindow))
        G_.FontChooserDialog_new(_title, _parent)
    end
    function GtkFontChooserWidget(; kwargs...)
        obj = G_.FontChooserWidget_new()
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkFontDialog(; kwargs...)
        obj = G_.FontDialog_new()
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkFontDialogButton(_dialog::Maybe(GtkFontDialog); kwargs...)
        obj = G_.FontDialogButton_new(_dialog)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkFrame(_label::Maybe(Union{AbstractString, Symbol}); kwargs...)
        obj = G_.Frame_new(_label)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkGLArea(; kwargs...)
        obj = G_.GLArea_new()
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkGestureClick()
        G_.GestureClick_new()
    end
    function GtkGestureDrag()
        G_.GestureDrag_new()
    end
    function GtkGestureLongPress(; kwargs...)
        obj = G_.GestureLongPress_new()
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkGesturePan(_orientation; kwargs...)
        obj = G_.GesturePan_new(_orientation)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkGestureRotate()
        G_.GestureRotate_new()
    end
    function GtkGestureStylus(; kwargs...)
        obj = G_.GestureStylus_new()
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkGestureSwipe()
        G_.GestureSwipe_new()
    end
    function GtkGestureZoom()
        G_.GestureZoom_new()
    end
    function GtkGraphicsOffload(_child::Maybe(GtkWidget); kwargs...)
        obj = G_.GraphicsOffload_new(_child)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkGrid(; kwargs...)
        obj = G_.Grid_new()
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkGridLayout(; kwargs...)
        obj = G_.GridLayout_new()
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkGridView(_model::Maybe(GtkSelectionModel), _factory::Maybe(GtkListItemFactory); kwargs...)
        obj = G_.GridView_new(_model, _factory)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkHeaderBar(; kwargs...)
        obj = G_.HeaderBar_new()
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkIMContextSimple()
        G_.IMContextSimple_new()
    end
    function GtkIMMulticontext()
        G_.IMMulticontext_new()
    end
    function GtkIconPaintable(_file::GFile, _size::Integer, _scale::Integer; kwargs...)
        obj = G_.IconPaintable_new_for_file(_file, _size, _scale)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkIconTheme(; kwargs...)
        obj = G_.IconTheme_new()
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkIconView(; kwargs...)
        obj = G_.IconView_new()
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkIconView(_area::GtkCellArea; kwargs...)
        obj = G_.IconView_new_with_area(_area)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkIconView(_model::GtkTreeModel; kwargs...)
        obj = G_.IconView_new_with_model(_model)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkImage(; kwargs...)
        obj = G_.Image_new()
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkImage(_filename::Union{AbstractString, Symbol}; kwargs...)
        obj = G_.Image_new_from_file(_filename)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkImage(_icon::GIcon; kwargs...)
        obj = G_.Image_new_from_gicon(_icon)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkImage(_paintable::Maybe(GdkPaintable); kwargs...)
        obj = G_.Image_new_from_paintable(_paintable)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkImage(_pixbuf::Maybe(GdkPixbuf); kwargs...)
        obj = G_.Image_new_from_pixbuf(_pixbuf)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkInfoBar(; kwargs...)
        obj = G_.InfoBar_new()
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkInscription(_text::Maybe(Union{AbstractString, Symbol}); kwargs...)
        obj = G_.Inscription_new(_text)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkKeyvalTrigger(_keyval::Integer, _modifiers; kwargs...)
        obj = G_.KeyvalTrigger_new(_keyval, _modifiers)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkLabel(_str::Maybe(Union{AbstractString, Symbol}); kwargs...)
        obj = G_.Label_new(_str)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkLevelBar(; kwargs...)
        obj = G_.LevelBar_new()
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkLevelBar(_min_value::Real, _max_value::Real; kwargs...)
        obj = G_.LevelBar_new_for_interval(_min_value, _max_value)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkLinkButton(_uri::Union{AbstractString, Symbol}; kwargs...)
        obj = G_.LinkButton_new(_uri)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkLinkButton(_uri::Union{AbstractString, Symbol}, _label::Maybe(Union{AbstractString, Symbol}); kwargs...)
        obj = G_.LinkButton_new_with_label(_uri, _label)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkListBox(; kwargs...)
        obj = G_.ListBox_new()
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkListBoxRow(; kwargs...)
        obj = G_.ListBoxRow_new()
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkListStore(_types)
        G_.ListStore_new(_types)
    end
    function GtkListView(_model::Maybe(GtkSelectionModel), _factory::Maybe(GtkListItemFactory); kwargs...)
        obj = G_.ListView_new(_model, _factory)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkLockButton(_permission::Maybe(GPermission); kwargs...)
        obj = G_.LockButton_new(_permission)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkMapListModel(_model::Maybe(GListModel), _map_func::Maybe(Function), _user_destroy::Function; kwargs...)
        obj = G_.MapListModel_new(_model, _map_func, _user_destroy)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkMediaControls(_stream::Maybe(GtkMediaStream); kwargs...)
        obj = G_.MediaControls_new(_stream)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkMediaFile(; kwargs...)
        obj = G_.MediaFile_new()
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkMediaFile(_file::GFile; kwargs...)
        obj = G_.MediaFile_new_for_file(_file)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkMediaFile(_filename::Union{AbstractString, Symbol}; kwargs...)
        obj = G_.MediaFile_new_for_filename(_filename)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkMediaFile(_stream::GInputStream; kwargs...)
        obj = G_.MediaFile_new_for_input_stream(_stream)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkMenuButton(; kwargs...)
        obj = G_.MenuButton_new()
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkMnemonicTrigger(_keyval::Integer; kwargs...)
        obj = G_.MnemonicTrigger_new(_keyval)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkMountOperation(_parent::Maybe(GtkWindow); kwargs...)
        obj = G_.MountOperation_new(_parent)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkMultiSelection(_model::Maybe(GListModel); kwargs...)
        obj = G_.MultiSelection_new(_model)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkMultiSorter(; kwargs...)
        obj = G_.MultiSorter_new()
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkNamedAction(_name::Union{AbstractString, Symbol}; kwargs...)
        obj = G_.NamedAction_new(_name)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkNoSelection(_model::Maybe(GListModel); kwargs...)
        obj = G_.NoSelection_new(_model)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkNotebook(; kwargs...)
        obj = G_.Notebook_new()
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkNumericSorter(_expression::Maybe(GtkExpression); kwargs...)
        obj = G_.NumericSorter_new(_expression)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkObjectExpression(_object::GObject)
        G_.ObjectExpression_new(_object)
    end
    function GtkOverlay(; kwargs...)
        obj = G_.Overlay_new()
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkOverlayLayout()
        G_.OverlayLayout_new()
    end
    function GtkPadController(_group::GActionGroup, _pad::Maybe(GdkDevice); kwargs...)
        obj = G_.PadController_new(_group, _pad)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkPageSetup()
        G_.PageSetup_new()
    end
    function GtkPageSetup(_file_name::Union{AbstractString, Symbol})
        G_.PageSetup_new_from_file(_file_name)
    end
    function GtkPageSetup(_variant::GVariant)
        G_.PageSetup_new_from_gvariant(_variant)
    end
    function GtkPageSetup(_key_file::GKeyFile, _group_name::Maybe(Union{AbstractString, Symbol}))
        G_.PageSetup_new_from_key_file(_key_file, _group_name)
    end
    function GtkPaned(_orientation; kwargs...)
        obj = G_.Paned_new(_orientation)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkPasswordEntry(; kwargs...)
        obj = G_.PasswordEntry_new()
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkPasswordEntryBuffer()
        G_.PasswordEntryBuffer_new()
    end
    function GtkPicture(; kwargs...)
        obj = G_.Picture_new()
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkPicture(_file::Maybe(GFile); kwargs...)
        obj = G_.Picture_new_for_file(_file)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkPicture(_filename::Maybe(Union{AbstractString, Symbol}); kwargs...)
        obj = G_.Picture_new_for_filename(_filename)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkPicture(_paintable::Maybe(GdkPaintable); kwargs...)
        obj = G_.Picture_new_for_paintable(_paintable)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkPicture(_pixbuf::Maybe(GdkPixbuf); kwargs...)
        obj = G_.Picture_new_for_pixbuf(_pixbuf)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkPopover(; kwargs...)
        obj = G_.Popover_new()
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkPopoverMenu(_model::Maybe(GMenuModel); kwargs...)
        obj = G_.PopoverMenu_new_from_model(_model)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkPopoverMenu(_model::GMenuModel, _flags; kwargs...)
        obj = G_.PopoverMenu_new_from_model_full(_model, _flags)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkPopoverMenuBar(_model::Maybe(GMenuModel); kwargs...)
        obj = G_.PopoverMenuBar_new_from_model(_model)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkPrintDialog(; kwargs...)
        obj = G_.PrintDialog_new()
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkPrintJob(_title::Union{AbstractString, Symbol}, _printer::GtkPrinter, _settings::GtkPrintSettings, _page_setup::GtkPageSetup; kwargs...)
        obj = G_.PrintJob_new(_title, _printer, _settings, _page_setup)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkPrintOperation(; kwargs...)
        obj = G_.PrintOperation_new()
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkPrintSettings()
        G_.PrintSettings_new()
    end
    function GtkPrintSettings(_file_name::Union{AbstractString, Symbol})
        G_.PrintSettings_new_from_file(_file_name)
    end
    function GtkPrintSettings(_variant::GVariant)
        G_.PrintSettings_new_from_gvariant(_variant)
    end
    function GtkPrintSettings(_key_file::GKeyFile, _group_name::Maybe(Union{AbstractString, Symbol}))
        G_.PrintSettings_new_from_key_file(_key_file, _group_name)
    end
    function GtkPrinter(_name::Union{AbstractString, Symbol}, _backend::GtkPrintBackend, _virtual_::Bool; kwargs...)
        obj = G_.Printer_new(_name, _backend, _virtual_)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkProgressBar(; kwargs...)
        obj = G_.ProgressBar_new()
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkPropertyExpression(_this_type::Integer, _expression::Maybe(GtkExpression), _property_name::Union{AbstractString, Symbol})
        G_.PropertyExpression_new(_this_type, _expression, _property_name)
    end
    function GtkPropertyExpression(_expression::Maybe(GtkExpression), _pspec::GParam)
        G_.PropertyExpression_new_for_pspec(_expression, _pspec)
    end
    function GtkRecentManager(; kwargs...)
        obj = G_.RecentManager_new()
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkRevealer(; kwargs...)
        obj = G_.Revealer_new()
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkScale(_orientation, _adjustment::Maybe(GtkAdjustment); kwargs...)
        obj = G_.Scale_new(_orientation, _adjustment)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkScale(_orientation, _min::Real, _max::Real, _step::Real; kwargs...)
        obj = G_.Scale_new_with_range(_orientation, _min, _max, _step)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkScaleButton(_min::Real, _max::Real, _step::Real, _icons; kwargs...)
        obj = G_.ScaleButton_new(_min, _max, _step, _icons)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkScrollbar(_orientation, _adjustment::Maybe(GtkAdjustment); kwargs...)
        obj = G_.Scrollbar_new(_orientation, _adjustment)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkScrolledWindow(; kwargs...)
        obj = G_.ScrolledWindow_new()
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkSearchBar(; kwargs...)
        obj = G_.SearchBar_new()
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkSearchEntry(; kwargs...)
        obj = G_.SearchEntry_new()
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkSelectionFilterModel(_model::Maybe(GtkSelectionModel); kwargs...)
        obj = G_.SelectionFilterModel_new(_model)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkSeparator(_orientation)
        G_.Separator_new(_orientation)
    end
    function GtkShortcut(_trigger::Maybe(GtkShortcutTrigger), _action::Maybe(GtkShortcutAction); kwargs...)
        obj = G_.Shortcut_new(_trigger, _action)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkShortcutAction(_string::Union{AbstractString, Symbol})
        G_.ShortcutAction_parse_string(_string)
    end
    function GtkShortcutController(; kwargs...)
        obj = G_.ShortcutController_new()
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkShortcutController(_model::GListModel; kwargs...)
        obj = G_.ShortcutController_new_for_model(_model)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkShortcutLabel(_accelerator::Union{AbstractString, Symbol}; kwargs...)
        obj = G_.ShortcutLabel_new(_accelerator)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkShortcutTrigger(_string::Union{AbstractString, Symbol})
        G_.ShortcutTrigger_parse_string(_string)
    end
    function GtkSignalAction(_signal_name::Union{AbstractString, Symbol}; kwargs...)
        obj = G_.SignalAction_new(_signal_name)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkSignalListItemFactory()
        G_.SignalListItemFactory_new()
    end
    function GtkSingleSelection(_model::Maybe(GListModel); kwargs...)
        obj = G_.SingleSelection_new(_model)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkSizeGroup(_mode; kwargs...)
        obj = G_.SizeGroup_new(_mode)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkSliceListModel(_model::Maybe(GListModel), _offset::Integer, _size::Integer; kwargs...)
        obj = G_.SliceListModel_new(_model, _offset, _size)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkSnapshot()
        G_.Snapshot_new()
    end
    function GtkSortListModel(_model::Maybe(GListModel), _sorter::Maybe(GtkSorter); kwargs...)
        obj = G_.SortListModel_new(_model, _sorter)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkSpinButton(_adjustment::Maybe(GtkAdjustment), _climb_rate::Real, _digits::Integer; kwargs...)
        obj = G_.SpinButton_new(_adjustment, _climb_rate, _digits)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkSpinButton(_min::Real, _max::Real, _step::Real; kwargs...)
        obj = G_.SpinButton_new_with_range(_min, _max, _step)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkSpinner(; kwargs...)
        obj = G_.Spinner_new()
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkStack(; kwargs...)
        obj = G_.Stack_new()
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkStackSidebar(; kwargs...)
        obj = G_.StackSidebar_new()
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkStackSwitcher(; kwargs...)
        obj = G_.StackSwitcher_new()
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkStatusbar()
        G_.Statusbar_new()
    end
    function GtkStringFilter(_expression::Maybe(GtkExpression); kwargs...)
        obj = G_.StringFilter_new(_expression)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkStringList(_strings; kwargs...)
        obj = G_.StringList_new(_strings)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkStringObject(_string::Union{AbstractString, Symbol}; kwargs...)
        obj = G_.StringObject_new(_string)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkStringSorter(_expression::Maybe(GtkExpression); kwargs...)
        obj = G_.StringSorter_new(_expression)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkSwitch(; kwargs...)
        obj = G_.Switch_new()
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkText(; kwargs...)
        obj = G_.Text_new()
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkText(_buffer::GtkEntryBuffer; kwargs...)
        obj = G_.Text_new_with_buffer(_buffer)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkTextBuffer(_table::Maybe(GtkTextTagTable); kwargs...)
        obj = G_.TextBuffer_new(_table)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkTextChildAnchor()
        G_.TextChildAnchor_new()
    end
    function GtkTextChildAnchor(_character::Union{AbstractString, Symbol})
        G_.TextChildAnchor_new_with_replacement(_character)
    end
    function GtkTextMark(_name::Maybe(Union{AbstractString, Symbol}), _left_gravity::Bool; kwargs...)
        obj = G_.TextMark_new(_name, _left_gravity)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkTextTag(_name::Maybe(Union{AbstractString, Symbol}); kwargs...)
        obj = G_.TextTag_new(_name)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkTextTagTable()
        G_.TextTagTable_new()
    end
    function GtkTextView(; kwargs...)
        obj = G_.TextView_new()
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkTextView(_buffer::GtkTextBuffer; kwargs...)
        obj = G_.TextView_new_with_buffer(_buffer)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkToggleButton(; kwargs...)
        obj = G_.ToggleButton_new()
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkToggleButton(_label::Union{AbstractString, Symbol}; kwargs...)
        obj = G_.ToggleButton_new_with_label(_label)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkTreeExpander(; kwargs...)
        obj = G_.TreeExpander_new()
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkTreeListModel(_root::GListModel, _passthrough::Bool, _autoexpand::Bool, _create_func::Function, _user_destroy::Function; kwargs...)
        obj = G_.TreeListModel_new(_root, _passthrough, _autoexpand, _create_func, _user_destroy)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkTreeListRowSorter(_sorter::Maybe(GtkSorter); kwargs...)
        obj = G_.TreeListRowSorter_new(_sorter)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkTreeModelSort(_child_model::GtkTreeModel; kwargs...)
        obj = G_.TreeModelSort_new_with_model(_child_model)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkTreeStore(_types)
        G_.TreeStore_new(_types)
    end
    function GtkTreeView(; kwargs...)
        obj = G_.TreeView_new()
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkTreeView(_model::GtkTreeModel; kwargs...)
        obj = G_.TreeView_new_with_model(_model)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkTreeViewColumn(; kwargs...)
        obj = G_.TreeViewColumn_new()
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkTreeViewColumn(_area::GtkCellArea; kwargs...)
        obj = G_.TreeViewColumn_new_with_area(_area)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkUriLauncher(_uri::Maybe(Union{AbstractString, Symbol}); kwargs...)
        obj = G_.UriLauncher_new(_uri)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkVideo(; kwargs...)
        obj = G_.Video_new()
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkVideo(_file::Maybe(GFile); kwargs...)
        obj = G_.Video_new_for_file(_file)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkVideo(_filename::Maybe(Union{AbstractString, Symbol}); kwargs...)
        obj = G_.Video_new_for_filename(_filename)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkVideo(_stream::Maybe(GtkMediaStream); kwargs...)
        obj = G_.Video_new_for_media_stream(_stream)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkViewport(_hadjustment::Maybe(GtkAdjustment), _vadjustment::Maybe(GtkAdjustment); kwargs...)
        obj = G_.Viewport_new(_hadjustment, _vadjustment)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkVolumeButton(; kwargs...)
        obj = G_.VolumeButton_new()
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkWidgetPaintable(_widget::Maybe(GtkWidget); kwargs...)
        obj = G_.WidgetPaintable_new(_widget)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkWindow(; kwargs...)
        obj = G_.Window_new()
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkWindowControls(_side; kwargs...)
        obj = G_.WindowControls_new(_side)
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkWindowGroup()
        G_.WindowGroup_new()
    end
    function GtkWindowHandle(; kwargs...)
        obj = G_.WindowHandle_new()
        obj !== nothing && GLib.setproperties!(obj; kwargs...)
        obj
    end
    function GtkAccessibleList(_accessibles)
        G_.AccessibleList_new_from_array(_accessibles)
    end
    function GtkAccessibleList(_list::GLib.LList{GLib._GList{Ptr{GObject}}})
        G_.AccessibleList_new_from_list(_list)
    end
    function GtkBitset()
        G_.Bitset_new_empty()
    end
    function GtkBitset(_start::Integer, _n_items::Integer)
        G_.Bitset_new_range(_start, _n_items)
    end
    function GtkBorder()
        G_.Border_new()
    end
    function GtkCssSection(_file::Maybe(GFile), _start::GtkCssLocationLike, _end::GtkCssLocationLike)
        G_.CssSection_new(_file, _start, _end)
    end
    function GtkCssSection(_file::Maybe(GFile), _bytes::Maybe(GBytes), _start::GtkCssLocationLike, _end::GtkCssLocationLike)
        G_.CssSection_new_with_bytes(_file, _bytes, _start, _end)
    end
    function GtkPaperSize(_name::Maybe(Union{AbstractString, Symbol}))
        G_.PaperSize_new(_name)
    end
    function GtkPaperSize(_name::Union{AbstractString, Symbol}, _display_name::Union{AbstractString, Symbol}, _width::Real, _height::Real, _unit)
        G_.PaperSize_new_custom(_name, _display_name, _width, _height, _unit)
    end
    function GtkPaperSize(_variant::GVariant)
        G_.PaperSize_new_from_gvariant(_variant)
    end
    function GtkPaperSize(_ipp_name::Union{AbstractString, Symbol}, _width::Real, _height::Real)
        G_.PaperSize_new_from_ipp(_ipp_name, _width, _height)
    end
    function GtkPaperSize(_key_file::GKeyFile, _group_name::Maybe(Union{AbstractString, Symbol}))
        G_.PaperSize_new_from_key_file(_key_file, _group_name)
    end
    function GtkPaperSize(_ppd_name::Union{AbstractString, Symbol}, _ppd_display_name::Union{AbstractString, Symbol}, _width::Real, _height::Real)
        G_.PaperSize_new_from_ppd(_ppd_name, _ppd_display_name, _width, _height)
    end
    function GtkRequisition()
        G_.Requisition_new()
    end
    function GtkScrollInfo()
        G_.ScrollInfo_new()
    end
    function GtkTreePath()
        G_.TreePath_new()
    end
    function GtkTreePath(_indices)
        G_.TreePath_new_from_indices(_indices)
    end
    function GtkTreePath(_path::Union{AbstractString, Symbol})
        G_.TreePath_new_from_string(_path)
    end
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.ATContext.html)." GtkATContext
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.AboutDialog.html)." GtkAboutDialog
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.ActionBar.html)." GtkActionBar
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.ActivateAction.html)." GtkActivateAction
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.Adjustment.html)." GtkAdjustment
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.AlertDialog.html)." GtkAlertDialog
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.AlternativeTrigger.html)." GtkAlternativeTrigger
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.AnyFilter.html)." GtkAnyFilter
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.AppChooserButton.html)." GtkAppChooserButton
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.AppChooserDialog.html)." GtkAppChooserDialog
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.AppChooserWidget.html)." GtkAppChooserWidget
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.Application.html)." GtkApplication
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.ApplicationWindow.html)." GtkApplicationWindow
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.AspectFrame.html)." GtkAspectFrame
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.Assistant.html)." GtkAssistant
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.AssistantPage.html)." GtkAssistantPage
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.BinLayout.html)." GtkBinLayout
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.BookmarkList.html)." GtkBookmarkList
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.BoolFilter.html)." GtkBoolFilter
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.Box.html)." GtkBox
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.BoxLayout.html)." GtkBoxLayout
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.BuilderCScope.html)." GtkBuilderCScope
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.BuilderListItemFactory.html)." GtkBuilderListItemFactory
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.Button.html)." GtkButton
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.Calendar.html)." GtkCalendar
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.CallbackAction.html)." GtkCallbackAction
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.CellArea.html)." GtkCellArea
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.CellAreaBox.html)." GtkCellAreaBox
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.CellAreaContext.html)." GtkCellAreaContext
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.CellRenderer.html)." GtkCellRenderer
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.CellRendererAccel.html)." GtkCellRendererAccel
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.CellRendererCombo.html)." GtkCellRendererCombo
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.CellRendererPixbuf.html)." GtkCellRendererPixbuf
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.CellRendererProgress.html)." GtkCellRendererProgress
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.CellRendererSpin.html)." GtkCellRendererSpin
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.CellRendererSpinner.html)." GtkCellRendererSpinner
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.CellRendererText.html)." GtkCellRendererText
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.CellRendererToggle.html)." GtkCellRendererToggle
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.CellView.html)." GtkCellView
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.CenterBox.html)." GtkCenterBox
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.CenterLayout.html)." GtkCenterLayout
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.ColorButton.html)." GtkColorButton
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.ColorChooserDialog.html)." GtkColorChooserDialog
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.ColorChooserWidget.html)." GtkColorChooserWidget
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.ColorDialog.html)." GtkColorDialog
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.ColorDialogButton.html)." GtkColorDialogButton
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.ColumnView.html)." GtkColumnView
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.ColumnViewCell.html)." GtkColumnViewCell
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.ColumnViewColumn.html)." GtkColumnViewColumn
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.ColumnViewRow.html)." GtkColumnViewRow
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.ColumnViewSorter.html)." GtkColumnViewSorter
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.ComboBox.html)." GtkComboBox
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.ComboBoxText.html)." GtkComboBoxText
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.ConstantExpression.html)." GtkConstantExpression
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.Constraint.html)." GtkConstraint
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.ConstraintGuide.html)." GtkConstraintGuide
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.ConstraintLayout.html)." GtkConstraintLayout
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.ConstraintLayoutChild.html)." GtkConstraintLayoutChild
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.CssProvider.html)." GtkCssProvider
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.CustomFilter.html)." GtkCustomFilter
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.CustomLayout.html)." GtkCustomLayout
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.CustomSorter.html)." GtkCustomSorter
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.Dialog.html)." GtkDialog
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.DirectoryList.html)." GtkDirectoryList
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.DragIcon.html)." GtkDragIcon
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.DragSource.html)." GtkDragSource
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.DrawingArea.html)." GtkDrawingArea
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.DropControllerMotion.html)." GtkDropControllerMotion
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.DropDown.html)." GtkDropDown
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.DropTarget.html)." GtkDropTarget
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.DropTargetAsync.html)." GtkDropTargetAsync
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.EditableLabel.html)." GtkEditableLabel
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.EmojiChooser.html)." GtkEmojiChooser
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.Entry.html)." GtkEntry
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.EntryBuffer.html)." GtkEntryBuffer
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.EntryCompletion.html)." GtkEntryCompletion
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.EventController.html)." GtkEventController
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.EventControllerFocus.html)." GtkEventControllerFocus
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.EventControllerKey.html)." GtkEventControllerKey
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.EventControllerLegacy.html)." GtkEventControllerLegacy
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.EventControllerMotion.html)." GtkEventControllerMotion
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.EventControllerScroll.html)." GtkEventControllerScroll
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.EveryFilter.html)." GtkEveryFilter
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.Expander.html)." GtkExpander
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.Expression.html)." GtkExpression
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.FileChooserDialog.html)." GtkFileChooserDialog
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.FileChooserNative.html)." GtkFileChooserNative
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.FileChooserWidget.html)." GtkFileChooserWidget
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.FileDialog.html)." GtkFileDialog
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.FileFilter.html)." GtkFileFilter
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.FileLauncher.html)." GtkFileLauncher
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.Filter.html)." GtkFilter
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.FilterListModel.html)." GtkFilterListModel
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.Fixed.html)." GtkFixed
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.FixedLayout.html)." GtkFixedLayout
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.FixedLayoutChild.html)." GtkFixedLayoutChild
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.FlattenListModel.html)." GtkFlattenListModel
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.FlowBox.html)." GtkFlowBox
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.FlowBoxChild.html)." GtkFlowBoxChild
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.FontButton.html)." GtkFontButton
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.FontChooserDialog.html)." GtkFontChooserDialog
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.FontChooserWidget.html)." GtkFontChooserWidget
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.FontDialog.html)." GtkFontDialog
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.FontDialogButton.html)." GtkFontDialogButton
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.Frame.html)." GtkFrame
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.GLArea.html)." GtkGLArea
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.Gesture.html)." GtkGesture
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.GestureClick.html)." GtkGestureClick
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.GestureDrag.html)." GtkGestureDrag
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.GestureLongPress.html)." GtkGestureLongPress
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.GesturePan.html)." GtkGesturePan
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.GestureRotate.html)." GtkGestureRotate
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.GestureSingle.html)." GtkGestureSingle
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.GestureStylus.html)." GtkGestureStylus
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.GestureSwipe.html)." GtkGestureSwipe
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.GestureZoom.html)." GtkGestureZoom
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.GraphicsOffload.html)." GtkGraphicsOffload
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.GridLayout.html)." GtkGridLayout
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.GridLayoutChild.html)." GtkGridLayoutChild
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.GridView.html)." GtkGridView
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.HeaderBar.html)." GtkHeaderBar
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.IMContext.html)." GtkIMContext
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.IMContextSimple.html)." GtkIMContextSimple
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.IMMulticontext.html)." GtkIMMulticontext
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.IconPaintable.html)." GtkIconPaintable
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.IconTheme.html)." GtkIconTheme
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.IconView.html)." GtkIconView
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.InfoBar.html)." GtkInfoBar
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.Inscription.html)." GtkInscription
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.KeyvalTrigger.html)." GtkKeyvalTrigger
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.Label.html)." GtkLabel
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.LayoutChild.html)." GtkLayoutChild
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.LayoutManager.html)." GtkLayoutManager
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.LevelBar.html)." GtkLevelBar
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.LinkButton.html)." GtkLinkButton
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.ListBase.html)." GtkListBase
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.ListBox.html)." GtkListBox
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.ListBoxRow.html)." GtkListBoxRow
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.ListHeader.html)." GtkListHeader
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.ListItem.html)." GtkListItem
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.ListItemFactory.html)." GtkListItemFactory
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.ListStore.html)." GtkListStore
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.ListView.html)." GtkListView
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.LockButton.html)." GtkLockButton
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.MapListModel.html)." GtkMapListModel
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.MediaControls.html)." GtkMediaControls
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.MediaFile.html)." GtkMediaFile
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.MediaStream.html)." GtkMediaStream
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.MenuButton.html)." GtkMenuButton
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.MessageDialog.html)." GtkMessageDialog
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.MnemonicAction.html)." GtkMnemonicAction
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.MnemonicTrigger.html)." GtkMnemonicTrigger
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.MountOperation.html)." GtkMountOperation
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.MultiFilter.html)." GtkMultiFilter
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.MultiSelection.html)." GtkMultiSelection
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.MultiSorter.html)." GtkMultiSorter
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.NamedAction.html)." GtkNamedAction
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.NativeDialog.html)." GtkNativeDialog
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.NeverTrigger.html)." GtkNeverTrigger
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.NoSelection.html)." GtkNoSelection
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.NotebookPage.html)." GtkNotebookPage
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.NothingAction.html)." GtkNothingAction
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.NumericSorter.html)." GtkNumericSorter
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.ObjectExpression.html)." GtkObjectExpression
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.Overlay.html)." GtkOverlay
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.OverlayLayout.html)." GtkOverlayLayout
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.OverlayLayoutChild.html)." GtkOverlayLayoutChild
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.PadController.html)." GtkPadController
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.PageSetup.html)." GtkPageSetup
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.Paned.html)." GtkPaned
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.PasswordEntry.html)." GtkPasswordEntry
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.PasswordEntryBuffer.html)." GtkPasswordEntryBuffer
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.Popover.html)." GtkPopover
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.PopoverMenu.html)." GtkPopoverMenu
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.PopoverMenuBar.html)." GtkPopoverMenuBar
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.PrintContext.html)." GtkPrintContext
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.PrintDialog.html)." GtkPrintDialog
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.PrintJob.html)." GtkPrintJob
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.PrintOperation.html)." GtkPrintOperation
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.PrintSettings.html)." GtkPrintSettings
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.Printer.html)." GtkPrinter
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.PropertyExpression.html)." GtkPropertyExpression
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.Range.html)." GtkRange
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.RecentManager.html)." GtkRecentManager
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.Revealer.html)." GtkRevealer
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.Scale.html)." GtkScale
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.ScaleButton.html)." GtkScaleButton
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.Scrollbar.html)." GtkScrollbar
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.ScrolledWindow.html)." GtkScrolledWindow
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.SearchBar.html)." GtkSearchBar
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.SearchEntry.html)." GtkSearchEntry
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.SelectionFilterModel.html)." GtkSelectionFilterModel
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.Separator.html)." GtkSeparator
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.Settings.html)." GtkSettings
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.Shortcut.html)." GtkShortcut
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.ShortcutAction.html)." GtkShortcutAction
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.ShortcutController.html)." GtkShortcutController
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.ShortcutLabel.html)." GtkShortcutLabel
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.ShortcutTrigger.html)." GtkShortcutTrigger
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.ShortcutsGroup.html)." GtkShortcutsGroup
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.ShortcutsSection.html)." GtkShortcutsSection
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.ShortcutsShortcut.html)." GtkShortcutsShortcut
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.ShortcutsWindow.html)." GtkShortcutsWindow
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.SignalAction.html)." GtkSignalAction
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.SignalListItemFactory.html)." GtkSignalListItemFactory
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.SingleSelection.html)." GtkSingleSelection
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.SizeGroup.html)." GtkSizeGroup
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.SliceListModel.html)." GtkSliceListModel
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.Snapshot.html)." GtkSnapshot
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.SortListModel.html)." GtkSortListModel
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.Sorter.html)." GtkSorter
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.StackPage.html)." GtkStackPage
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.Statusbar.html)." GtkStatusbar
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.StringFilter.html)." GtkStringFilter
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.StringList.html)." GtkStringList
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.StringObject.html)." GtkStringObject
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.StringSorter.html)." GtkStringSorter
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.StyleContext.html)." GtkStyleContext
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.Switch.html)." GtkSwitch
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.Text.html)." GtkText
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.TextBuffer.html)." GtkTextBuffer
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.TextChildAnchor.html)." GtkTextChildAnchor
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.TextMark.html)." GtkTextMark
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.TextTag.html)." GtkTextTag
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.TextTagTable.html)." GtkTextTagTable
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.TextView.html)." GtkTextView
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.Tooltip.html)." GtkTooltip
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.TreeExpander.html)." GtkTreeExpander
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.TreeListModel.html)." GtkTreeListModel
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.TreeListRow.html)." GtkTreeListRow
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.TreeListRowSorter.html)." GtkTreeListRowSorter
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.TreeModelFilter.html)." GtkTreeModelFilter
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.TreeModelSort.html)." GtkTreeModelSort
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.TreeSelection.html)." GtkTreeSelection
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.TreeStore.html)." GtkTreeStore
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.TreeView.html)." GtkTreeView
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.TreeViewColumn.html)." GtkTreeViewColumn
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.UriLauncher.html)." GtkUriLauncher
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.Video.html)." GtkVideo
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.Viewport.html)." GtkViewport
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.VolumeButton.html)." GtkVolumeButton
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.Widget.html)." GtkWidget
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.WidgetPaintable.html)." GtkWidgetPaintable
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.Window.html)." GtkWindow
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.WindowControls.html)." GtkWindowControls
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.WindowGroup.html)." GtkWindowGroup
    @doc "See the [GTK docs](https://docs.gtk.org/gtk4/class.WindowHandle.html)." GtkWindowHandle
    function on_state_change(f, object::GtkATContext, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "state-change", Nothing, (), after, user_data)
    end
    function on_activate_link(f, object::GtkAboutDialog, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "activate-link", Cint, (Cstring,), after, user_data)
    end
    function on_changed(f, object::GtkAdjustment, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "changed", Nothing, (), after, user_data)
    end
    function on_value_changed(f, object::GtkAdjustment, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "value-changed", Nothing, (), after, user_data)
    end
    function on_items_changed(f, object::GtkAnyFilter, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "items-changed", Nothing, (UInt32, UInt32, UInt32), after, user_data)
    end
    function on_activate(f, object::GtkAppChooserButton, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "activate", Nothing, (), after, user_data)
    end
    function on_changed(f, object::GtkAppChooserButton, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "changed", Nothing, (), after, user_data)
    end
    function on_custom_item_activated(f, object::GtkAppChooserButton, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "custom-item-activated", Nothing, (Cstring,), after, user_data)
    end
    function on_application_activated(f, object::GtkAppChooserWidget, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "application-activated", Nothing, (Ptr{GObject},), after, user_data)
    end
    function on_application_selected(f, object::GtkAppChooserWidget, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "application-selected", Nothing, (Ptr{GObject},), after, user_data)
    end
    function on_query_end(f, object::GtkApplication, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "query-end", Nothing, (), after, user_data)
    end
    function on_window_added(f, object::GtkApplication, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "window-added", Nothing, (Ptr{GObject},), after, user_data)
    end
    function on_window_removed(f, object::GtkApplication, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "window-removed", Nothing, (Ptr{GObject},), after, user_data)
    end
    function on_action_added(f, object::GtkApplication, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "action-added", Nothing, (Cstring,), after, user_data)
    end
    function on_action_enabled_changed(f, object::GtkApplication, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "action-enabled-changed", Nothing, (Cstring, Cint), after, user_data)
    end
    function on_action_removed(f, object::GtkApplication, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "action-removed", Nothing, (Cstring,), after, user_data)
    end
    function on_action_state_changed(f, object::GtkApplication, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "action-state-changed", Nothing, (Cstring, GVariant), after, user_data)
    end
    function on_action_added(f, object::GtkApplicationWindow, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "action-added", Nothing, (Cstring,), after, user_data)
    end
    function on_action_enabled_changed(f, object::GtkApplicationWindow, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "action-enabled-changed", Nothing, (Cstring, Cint), after, user_data)
    end
    function on_action_removed(f, object::GtkApplicationWindow, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "action-removed", Nothing, (Cstring,), after, user_data)
    end
    function on_action_state_changed(f, object::GtkApplicationWindow, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "action-state-changed", Nothing, (Cstring, GVariant), after, user_data)
    end
    function on_apply(f, object::GtkAssistant, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "apply", Nothing, (), after, user_data)
    end
    function on_cancel(f, object::GtkAssistant, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "cancel", Nothing, (), after, user_data)
    end
    function on_close(f, object::GtkAssistant, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "close", Nothing, (), after, user_data)
    end
    function on_escape(f, object::GtkAssistant, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "escape", Nothing, (), after, user_data)
    end
    function on_prepare(f, object::GtkAssistant, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "prepare", Nothing, (Ptr{GObject},), after, user_data)
    end
    function on_items_changed(f, object::GtkBookmarkList, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "items-changed", Nothing, (UInt32, UInt32, UInt32), after, user_data)
    end
    function on_activate(f, object::GtkButton, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "activate", Nothing, (), after, user_data)
    end
    function on_clicked(f, object::GtkButton, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "clicked", Nothing, (), after, user_data)
    end
    function on_day_selected(f, object::GtkCalendar, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "day-selected", Nothing, (), after, user_data)
    end
    function on_next_month(f, object::GtkCalendar, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "next-month", Nothing, (), after, user_data)
    end
    function on_next_year(f, object::GtkCalendar, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "next-year", Nothing, (), after, user_data)
    end
    function on_prev_month(f, object::GtkCalendar, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "prev-month", Nothing, (), after, user_data)
    end
    function on_prev_year(f, object::GtkCalendar, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "prev-year", Nothing, (), after, user_data)
    end
    function on_add_editable(f, object::GtkCellArea, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "add-editable", Nothing, (Ptr{GObject}, Ptr{GtkWidget}, _GdkRectangle, Cstring), after, user_data)
    end
    function on_apply_attributes(f, object::GtkCellArea, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "apply-attributes", Nothing, (Ptr{GObject}, _GtkTreeIter, Cint, Cint), after, user_data)
    end
    function on_focus_changed(f, object::GtkCellArea, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "focus-changed", Nothing, (Ptr{GObject}, Cstring), after, user_data)
    end
    function on_remove_editable(f, object::GtkCellArea, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "remove-editable", Nothing, (Ptr{GObject}, Ptr{GtkWidget}), after, user_data)
    end
    function on_editing_canceled(f, object::GtkCellRenderer, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "editing-canceled", Nothing, (), after, user_data)
    end
    function on_editing_started(f, object::GtkCellRenderer, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "editing-started", Nothing, (Ptr{GtkWidget}, Cstring), after, user_data)
    end
    function on_accel_cleared(f, object::GtkCellRendererAccel, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "accel-cleared", Nothing, (Cstring,), after, user_data)
    end
    function on_accel_edited(f, object::GtkCellRendererAccel, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "accel-edited", Nothing, (Cstring, UInt32, UInt32, UInt32), after, user_data)
    end
    function on_changed(f, object::GtkCellRendererCombo, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "changed", Nothing, (Cstring, _GtkTreeIter), after, user_data)
    end
    function on_edited(f, object::GtkCellRendererText, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "edited", Nothing, (Cstring, Cstring), after, user_data)
    end
    function on_toggled(f, object::GtkCellRendererToggle, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "toggled", Nothing, (Cstring,), after, user_data)
    end
    function on_activate(f, object::GtkCheckButton, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "activate", Nothing, (), after, user_data)
    end
    function on_toggled(f, object::GtkCheckButton, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "toggled", Nothing, (), after, user_data)
    end
    function on_activate(f, object::GtkColorButton, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "activate", Nothing, (), after, user_data)
    end
    function on_color_set(f, object::GtkColorButton, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "color-set", Nothing, (), after, user_data)
    end
    function on_color_activated(f, object::GtkColorButton, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "color-activated", Nothing, (_GdkRGBA,), after, user_data)
    end
    function on_color_activated(f, object::GtkColorChooserDialog, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "color-activated", Nothing, (_GdkRGBA,), after, user_data)
    end
    function on_color_activated(f, object::GtkColorChooserWidget, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "color-activated", Nothing, (_GdkRGBA,), after, user_data)
    end
    function on_activate(f, object::GtkColorDialogButton, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "activate", Nothing, (), after, user_data)
    end
    function on_activate(f, object::GtkColumnView, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "activate", Nothing, (UInt32,), after, user_data)
    end
    function on_activate(f, object::GtkComboBox, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "activate", Nothing, (), after, user_data)
    end
    function on_changed(f, object::GtkComboBox, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "changed", Nothing, (), after, user_data)
    end
    function on_format_entry_text(f, object::GtkComboBox, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "format-entry-text", Cstring, (Cstring,), after, user_data)
    end
    function on_move_active(f, object::GtkComboBox, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "move-active", Nothing, (UInt32,), after, user_data)
    end
    function on_popdown(f, object::GtkComboBox, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "popdown", Cint, (), after, user_data)
    end
    function on_popup(f, object::GtkComboBox, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "popup", Nothing, (), after, user_data)
    end
    function on_editing_done(f, object::GtkComboBox, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "editing-done", Nothing, (), after, user_data)
    end
    function on_remove_widget(f, object::GtkComboBox, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "remove-widget", Nothing, (), after, user_data)
    end
    function on_editing_done(f, object::GtkComboBoxText, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "editing-done", Nothing, (), after, user_data)
    end
    function on_remove_widget(f, object::GtkComboBoxText, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "remove-widget", Nothing, (), after, user_data)
    end
    function on_parsing_error(f, object::GtkCssProvider, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "parsing-error", Nothing, (GtkCssSection, Ptr{GError}), after, user_data)
    end
    function on_gtk_private_changed(f, object::GtkCssProvider, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "gtk-private-changed", Nothing, (), after, user_data)
    end
    function on_close(f, object::GtkDialog, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "close", Nothing, (), after, user_data)
    end
    function on_response(f, object::GtkDialog, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "response", Nothing, (Int32,), after, user_data)
    end
    function on_items_changed(f, object::GtkDirectoryList, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "items-changed", Nothing, (UInt32, UInt32, UInt32), after, user_data)
    end
    function on_drag_begin(f, object::GtkDragSource, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "drag-begin", Nothing, (Ptr{GObject},), after, user_data)
    end
    function on_drag_cancel(f, object::GtkDragSource, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "drag-cancel", Cint, (Ptr{GObject}, UInt32), after, user_data)
    end
    function on_drag_end(f, object::GtkDragSource, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "drag-end", Nothing, (Ptr{GObject}, Cint), after, user_data)
    end
    function on_prepare(f, object::GtkDragSource, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "prepare", Ptr{GObject}, (Float64, Float64), after, user_data)
    end
    function on_resize(f, object::GtkDrawingArea, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "resize", Nothing, (Int32, Int32), after, user_data)
    end
    function on_enter(f, object::GtkDropControllerMotion, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "enter", Nothing, (Float64, Float64), after, user_data)
    end
    function on_leave(f, object::GtkDropControllerMotion, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "leave", Nothing, (), after, user_data)
    end
    function on_motion(f, object::GtkDropControllerMotion, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "motion", Nothing, (Float64, Float64), after, user_data)
    end
    function on_activate(f, object::GtkDropDown, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "activate", Nothing, (), after, user_data)
    end
    function on_accept(f, object::GtkDropTarget, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "accept", Cint, (Ptr{GObject},), after, user_data)
    end
    function on_drop(f, object::GtkDropTarget, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "drop", Cint, (_GValue, Float64, Float64), after, user_data)
    end
    function on_enter(f, object::GtkDropTarget, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "enter", UInt32, (Float64, Float64), after, user_data)
    end
    function on_leave(f, object::GtkDropTarget, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "leave", Nothing, (), after, user_data)
    end
    function on_motion(f, object::GtkDropTarget, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "motion", UInt32, (Float64, Float64), after, user_data)
    end
    function on_accept(f, object::GtkDropTargetAsync, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "accept", Cint, (Ptr{GObject},), after, user_data)
    end
    function on_drag_enter(f, object::GtkDropTargetAsync, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "drag-enter", UInt32, (Ptr{GObject}, Float64, Float64), after, user_data)
    end
    function on_drag_leave(f, object::GtkDropTargetAsync, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "drag-leave", Nothing, (Ptr{GObject},), after, user_data)
    end
    function on_drag_motion(f, object::GtkDropTargetAsync, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "drag-motion", UInt32, (Ptr{GObject}, Float64, Float64), after, user_data)
    end
    function on_drop(f, object::GtkDropTargetAsync, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "drop", Cint, (Ptr{GObject}, Float64, Float64), after, user_data)
    end
    function on_changed(f, object::GtkEditableLabel, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "changed", Nothing, (), after, user_data)
    end
    function on_delete_text(f, object::GtkEditableLabel, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "delete-text", Nothing, (Int32, Int32), after, user_data)
    end
    function on_insert_text(f, object::GtkEditableLabel, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "insert-text", Nothing, (Cstring, Int32, Int32), after, user_data)
    end
    function on_emoji_picked(f, object::GtkEmojiChooser, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "emoji-picked", Nothing, (Cstring,), after, user_data)
    end
    function on_activate(f, object::GtkEntry, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "activate", Nothing, (), after, user_data)
    end
    function on_icon_press(f, object::GtkEntry, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "icon-press", Nothing, (UInt32,), after, user_data)
    end
    function on_icon_release(f, object::GtkEntry, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "icon-release", Nothing, (UInt32,), after, user_data)
    end
    function on_editing_done(f, object::GtkEntry, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "editing-done", Nothing, (), after, user_data)
    end
    function on_remove_widget(f, object::GtkEntry, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "remove-widget", Nothing, (), after, user_data)
    end
    function on_changed(f, object::GtkEntry, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "changed", Nothing, (), after, user_data)
    end
    function on_delete_text(f, object::GtkEntry, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "delete-text", Nothing, (Int32, Int32), after, user_data)
    end
    function on_insert_text(f, object::GtkEntry, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "insert-text", Nothing, (Cstring, Int32, Int32), after, user_data)
    end
    function on_deleted_text(f, object::GtkEntryBuffer, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "deleted-text", Nothing, (UInt32, UInt32), after, user_data)
    end
    function on_inserted_text(f, object::GtkEntryBuffer, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "inserted-text", Nothing, (UInt32, Cstring, UInt32), after, user_data)
    end
    function on_cursor_on_match(f, object::GtkEntryCompletion, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "cursor-on-match", Cint, (Ptr{GObject}, _GtkTreeIter), after, user_data)
    end
    function on_insert_prefix(f, object::GtkEntryCompletion, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "insert-prefix", Cint, (Cstring,), after, user_data)
    end
    function on_match_selected(f, object::GtkEntryCompletion, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "match-selected", Cint, (Ptr{GObject}, _GtkTreeIter), after, user_data)
    end
    function on_no_matches(f, object::GtkEntryCompletion, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "no-matches", Nothing, (), after, user_data)
    end
    function on_enter(f, object::GtkEventControllerFocus, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "enter", Nothing, (), after, user_data)
    end
    function on_leave(f, object::GtkEventControllerFocus, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "leave", Nothing, (), after, user_data)
    end
    function on_im_update(f, object::GtkEventControllerKey, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "im-update", Nothing, (), after, user_data)
    end
    function on_key_pressed(f, object::GtkEventControllerKey, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "key-pressed", Cint, (UInt32, UInt32, UInt32), after, user_data)
    end
    function on_key_released(f, object::GtkEventControllerKey, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "key-released", Nothing, (UInt32, UInt32, UInt32), after, user_data)
    end
    function on_modifiers(f, object::GtkEventControllerKey, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "modifiers", Cint, (UInt32,), after, user_data)
    end
    function on_event(f, object::GtkEventControllerLegacy, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "event", Cint, (GdkEvent,), after, user_data)
    end
    function on_enter(f, object::GtkEventControllerMotion, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "enter", Nothing, (Float64, Float64), after, user_data)
    end
    function on_leave(f, object::GtkEventControllerMotion, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "leave", Nothing, (), after, user_data)
    end
    function on_motion(f, object::GtkEventControllerMotion, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "motion", Nothing, (Float64, Float64), after, user_data)
    end
    function on_decelerate(f, object::GtkEventControllerScroll, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "decelerate", Nothing, (Float64, Float64), after, user_data)
    end
    function on_scroll(f, object::GtkEventControllerScroll, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "scroll", Cint, (Float64, Float64), after, user_data)
    end
    function on_scroll_begin(f, object::GtkEventControllerScroll, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "scroll-begin", Nothing, (), after, user_data)
    end
    function on_scroll_end(f, object::GtkEventControllerScroll, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "scroll-end", Nothing, (), after, user_data)
    end
    function on_items_changed(f, object::GtkEveryFilter, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "items-changed", Nothing, (UInt32, UInt32, UInt32), after, user_data)
    end
    function on_activate(f, object::GtkExpander, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "activate", Nothing, (), after, user_data)
    end
    function on_desktop_folder(f, object::GtkFileChooserWidget, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "desktop-folder", Nothing, (), after, user_data)
    end
    function on_down_folder(f, object::GtkFileChooserWidget, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "down-folder", Nothing, (), after, user_data)
    end
    function on_home_folder(f, object::GtkFileChooserWidget, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "home-folder", Nothing, (), after, user_data)
    end
    function on_location_popup(f, object::GtkFileChooserWidget, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "location-popup", Nothing, (Cstring,), after, user_data)
    end
    function on_location_popup_on_paste(f, object::GtkFileChooserWidget, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "location-popup-on-paste", Nothing, (), after, user_data)
    end
    function on_location_toggle_popup(f, object::GtkFileChooserWidget, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "location-toggle-popup", Nothing, (), after, user_data)
    end
    function on_places_shortcut(f, object::GtkFileChooserWidget, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "places-shortcut", Nothing, (), after, user_data)
    end
    function on_quick_bookmark(f, object::GtkFileChooserWidget, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "quick-bookmark", Nothing, (Int32,), after, user_data)
    end
    function on_recent_shortcut(f, object::GtkFileChooserWidget, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "recent-shortcut", Nothing, (), after, user_data)
    end
    function on_search_shortcut(f, object::GtkFileChooserWidget, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "search-shortcut", Nothing, (), after, user_data)
    end
    function on_show_hidden(f, object::GtkFileChooserWidget, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "show-hidden", Nothing, (), after, user_data)
    end
    function on_up_folder(f, object::GtkFileChooserWidget, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "up-folder", Nothing, (), after, user_data)
    end
    function on_changed(f, object::GtkFilter, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "changed", Nothing, (UInt32,), after, user_data)
    end
    function on_items_changed(f, object::GtkFilterListModel, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "items-changed", Nothing, (UInt32, UInt32, UInt32), after, user_data)
    end
    function on_sections_changed(f, object::GtkFilterListModel, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "sections-changed", Nothing, (UInt32, UInt32), after, user_data)
    end
    function on_items_changed(f, object::GtkFlattenListModel, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "items-changed", Nothing, (UInt32, UInt32, UInt32), after, user_data)
    end
    function on_sections_changed(f, object::GtkFlattenListModel, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "sections-changed", Nothing, (UInt32, UInt32), after, user_data)
    end
    function on_activate_cursor_child(f, object::GtkFlowBox, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "activate-cursor-child", Nothing, (), after, user_data)
    end
    function on_child_activated(f, object::GtkFlowBox, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "child-activated", Nothing, (Ptr{GObject},), after, user_data)
    end
    function on_move_cursor(f, object::GtkFlowBox, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "move-cursor", Cint, (UInt32, Int32, Cint, Cint), after, user_data)
    end
    function on_select_all(f, object::GtkFlowBox, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "select-all", Nothing, (), after, user_data)
    end
    function on_selected_children_changed(f, object::GtkFlowBox, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "selected-children-changed", Nothing, (), after, user_data)
    end
    function on_toggle_cursor_child(f, object::GtkFlowBox, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "toggle-cursor-child", Nothing, (), after, user_data)
    end
    function on_unselect_all(f, object::GtkFlowBox, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "unselect-all", Nothing, (), after, user_data)
    end
    function on_activate(f, object::GtkFlowBoxChild, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "activate", Nothing, (), after, user_data)
    end
    function on_activate(f, object::GtkFontButton, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "activate", Nothing, (), after, user_data)
    end
    function on_font_set(f, object::GtkFontButton, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "font-set", Nothing, (), after, user_data)
    end
    function on_font_activated(f, object::GtkFontButton, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "font-activated", Nothing, (Cstring,), after, user_data)
    end
    function on_font_activated(f, object::GtkFontChooserDialog, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "font-activated", Nothing, (Cstring,), after, user_data)
    end
    function on_font_activated(f, object::GtkFontChooserWidget, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "font-activated", Nothing, (Cstring,), after, user_data)
    end
    function on_activate(f, object::GtkFontDialogButton, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "activate", Nothing, (), after, user_data)
    end
    function on_create_context(f, object::GtkGLArea, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "create-context", Ptr{GObject}, (), after, user_data)
    end
    function on_render(f, object::GtkGLArea, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "render", Cint, (Ptr{GObject},), after, user_data)
    end
    function on_resize(f, object::GtkGLArea, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "resize", Nothing, (Int32, Int32), after, user_data)
    end
    function on_begin(f, object::GtkGesture, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "begin", Nothing, (GdkEventSequence,), after, user_data)
    end
    function on_cancel(f, object::GtkGesture, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "cancel", Nothing, (GdkEventSequence,), after, user_data)
    end
    function on_end(f, object::GtkGesture, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "end", Nothing, (GdkEventSequence,), after, user_data)
    end
    function on_sequence_state_changed(f, object::GtkGesture, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "sequence-state-changed", Nothing, (GdkEventSequence, UInt32), after, user_data)
    end
    function on_update(f, object::GtkGesture, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "update", Nothing, (GdkEventSequence,), after, user_data)
    end
    function on_pressed(f, object::GtkGestureClick, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "pressed", Nothing, (Int32, Float64, Float64), after, user_data)
    end
    function on_released(f, object::GtkGestureClick, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "released", Nothing, (Int32, Float64, Float64), after, user_data)
    end
    function on_stopped(f, object::GtkGestureClick, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "stopped", Nothing, (), after, user_data)
    end
    function on_unpaired_release(f, object::GtkGestureClick, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "unpaired-release", Nothing, (Float64, Float64, UInt32, GdkEventSequence), after, user_data)
    end
    function on_drag_begin(f, object::GtkGestureDrag, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "drag-begin", Nothing, (Float64, Float64), after, user_data)
    end
    function on_drag_end(f, object::GtkGestureDrag, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "drag-end", Nothing, (Float64, Float64), after, user_data)
    end
    function on_drag_update(f, object::GtkGestureDrag, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "drag-update", Nothing, (Float64, Float64), after, user_data)
    end
    function on_cancelled(f, object::GtkGestureLongPress, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "cancelled", Nothing, (), after, user_data)
    end
    function on_pressed(f, object::GtkGestureLongPress, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "pressed", Nothing, (Float64, Float64), after, user_data)
    end
    function on_pan(f, object::GtkGesturePan, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "pan", Nothing, (UInt32, Float64), after, user_data)
    end
    function on_angle_changed(f, object::GtkGestureRotate, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "angle-changed", Nothing, (Float64, Float64), after, user_data)
    end
    function on_down(f, object::GtkGestureStylus, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "down", Nothing, (Float64, Float64), after, user_data)
    end
    function on_motion(f, object::GtkGestureStylus, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "motion", Nothing, (Float64, Float64), after, user_data)
    end
    function on_proximity(f, object::GtkGestureStylus, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "proximity", Nothing, (Float64, Float64), after, user_data)
    end
    function on_up(f, object::GtkGestureStylus, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "up", Nothing, (Float64, Float64), after, user_data)
    end
    function on_swipe(f, object::GtkGestureSwipe, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "swipe", Nothing, (Float64, Float64), after, user_data)
    end
    function on_scale_changed(f, object::GtkGestureZoom, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "scale-changed", Nothing, (Float64,), after, user_data)
    end
    function on_activate(f, object::GtkGridView, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "activate", Nothing, (UInt32,), after, user_data)
    end
    function on_commit(f, object::GtkIMContext, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "commit", Nothing, (Cstring,), after, user_data)
    end
    function on_delete_surrounding(f, object::GtkIMContext, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "delete-surrounding", Cint, (Int32, Int32), after, user_data)
    end
    function on_preedit_changed(f, object::GtkIMContext, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "preedit-changed", Nothing, (), after, user_data)
    end
    function on_preedit_end(f, object::GtkIMContext, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "preedit-end", Nothing, (), after, user_data)
    end
    function on_preedit_start(f, object::GtkIMContext, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "preedit-start", Nothing, (), after, user_data)
    end
    function on_retrieve_surrounding(f, object::GtkIMContext, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "retrieve-surrounding", Cint, (), after, user_data)
    end
    function on_invalidate_contents(f, object::GtkIconPaintable, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "invalidate-contents", Nothing, (), after, user_data)
    end
    function on_invalidate_size(f, object::GtkIconPaintable, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "invalidate-size", Nothing, (), after, user_data)
    end
    function on_changed(f, object::GtkIconTheme, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "changed", Nothing, (), after, user_data)
    end
    function on_activate_cursor_item(f, object::GtkIconView, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "activate-cursor-item", Cint, (), after, user_data)
    end
    function on_item_activated(f, object::GtkIconView, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "item-activated", Nothing, (GtkTreePath,), after, user_data)
    end
    function on_move_cursor(f, object::GtkIconView, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "move-cursor", Cint, (UInt32, Int32, Cint, Cint), after, user_data)
    end
    function on_select_all(f, object::GtkIconView, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "select-all", Nothing, (), after, user_data)
    end
    function on_select_cursor_item(f, object::GtkIconView, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "select-cursor-item", Nothing, (), after, user_data)
    end
    function on_selection_changed(f, object::GtkIconView, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "selection-changed", Nothing, (), after, user_data)
    end
    function on_toggle_cursor_item(f, object::GtkIconView, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "toggle-cursor-item", Nothing, (), after, user_data)
    end
    function on_unselect_all(f, object::GtkIconView, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "unselect-all", Nothing, (), after, user_data)
    end
    function on_close(f, object::GtkInfoBar, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "close", Nothing, (), after, user_data)
    end
    function on_response(f, object::GtkInfoBar, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "response", Nothing, (Int32,), after, user_data)
    end
    function on_activate_current_link(f, object::GtkLabel, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "activate-current-link", Nothing, (), after, user_data)
    end
    function on_activate_link(f, object::GtkLabel, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "activate-link", Cint, (Cstring,), after, user_data)
    end
    function on_copy_clipboard(f, object::GtkLabel, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "copy-clipboard", Nothing, (), after, user_data)
    end
    function on_move_cursor(f, object::GtkLabel, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "move-cursor", Nothing, (UInt32, Int32, Cint), after, user_data)
    end
    function on_offset_changed(f, object::GtkLevelBar, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "offset-changed", Nothing, (Cstring,), after, user_data)
    end
    function on_activate_link(f, object::GtkLinkButton, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "activate-link", Cint, (), after, user_data)
    end
    function on_activate_cursor_row(f, object::GtkListBox, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "activate-cursor-row", Nothing, (), after, user_data)
    end
    function on_move_cursor(f, object::GtkListBox, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "move-cursor", Nothing, (UInt32, Int32, Cint, Cint), after, user_data)
    end
    function on_row_activated(f, object::GtkListBox, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "row-activated", Nothing, (Ptr{GObject},), after, user_data)
    end
    function on_row_selected(f, object::GtkListBox, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "row-selected", Nothing, (Ptr{GObject},), after, user_data)
    end
    function on_select_all(f, object::GtkListBox, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "select-all", Nothing, (), after, user_data)
    end
    function on_selected_rows_changed(f, object::GtkListBox, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "selected-rows-changed", Nothing, (), after, user_data)
    end
    function on_toggle_cursor_row(f, object::GtkListBox, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "toggle-cursor-row", Nothing, (), after, user_data)
    end
    function on_unselect_all(f, object::GtkListBox, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "unselect-all", Nothing, (), after, user_data)
    end
    function on_activate(f, object::GtkListBoxRow, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "activate", Nothing, (), after, user_data)
    end
    function on_row_changed(f, object::GtkListStore, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "row-changed", Nothing, (GtkTreePath, _GtkTreeIter), after, user_data)
    end
    function on_row_deleted(f, object::GtkListStore, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "row-deleted", Nothing, (GtkTreePath,), after, user_data)
    end
    function on_row_has_child_toggled(f, object::GtkListStore, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "row-has-child-toggled", Nothing, (GtkTreePath, _GtkTreeIter), after, user_data)
    end
    function on_row_inserted(f, object::GtkListStore, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "row-inserted", Nothing, (GtkTreePath, _GtkTreeIter), after, user_data)
    end
    function on_sort_column_changed(f, object::GtkListStore, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "sort-column-changed", Nothing, (), after, user_data)
    end
    function on_activate(f, object::GtkListView, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "activate", Nothing, (UInt32,), after, user_data)
    end
    function on_items_changed(f, object::GtkMapListModel, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "items-changed", Nothing, (UInt32, UInt32, UInt32), after, user_data)
    end
    function on_sections_changed(f, object::GtkMapListModel, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "sections-changed", Nothing, (UInt32, UInt32), after, user_data)
    end
    function on_invalidate_contents(f, object::GtkMediaFile, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "invalidate-contents", Nothing, (), after, user_data)
    end
    function on_invalidate_size(f, object::GtkMediaFile, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "invalidate-size", Nothing, (), after, user_data)
    end
    function on_invalidate_contents(f, object::GtkMediaStream, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "invalidate-contents", Nothing, (), after, user_data)
    end
    function on_invalidate_size(f, object::GtkMediaStream, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "invalidate-size", Nothing, (), after, user_data)
    end
    function on_activate(f, object::GtkMenuButton, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "activate", Nothing, (), after, user_data)
    end
    function on_items_changed(f, object::GtkMultiFilter, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "items-changed", Nothing, (UInt32, UInt32, UInt32), after, user_data)
    end
    function on_items_changed(f, object::GtkMultiSelection, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "items-changed", Nothing, (UInt32, UInt32, UInt32), after, user_data)
    end
    function on_sections_changed(f, object::GtkMultiSelection, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "sections-changed", Nothing, (UInt32, UInt32), after, user_data)
    end
    function on_selection_changed(f, object::GtkMultiSelection, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "selection-changed", Nothing, (UInt32, UInt32), after, user_data)
    end
    function on_items_changed(f, object::GtkMultiSorter, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "items-changed", Nothing, (UInt32, UInt32, UInt32), after, user_data)
    end
    function on_response(f, object::GtkNativeDialog, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "response", Nothing, (Int32,), after, user_data)
    end
    function on_items_changed(f, object::GtkNoSelection, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "items-changed", Nothing, (UInt32, UInt32, UInt32), after, user_data)
    end
    function on_sections_changed(f, object::GtkNoSelection, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "sections-changed", Nothing, (UInt32, UInt32), after, user_data)
    end
    function on_selection_changed(f, object::GtkNoSelection, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "selection-changed", Nothing, (UInt32, UInt32), after, user_data)
    end
    function on_change_current_page(f, object::GtkNotebook, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "change-current-page", Cint, (Int32,), after, user_data)
    end
    function on_create_window(f, object::GtkNotebook, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "create-window", Ptr{GObject}, (Ptr{GObject},), after, user_data)
    end
    function on_focus_tab(f, object::GtkNotebook, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "focus-tab", Cint, (UInt32,), after, user_data)
    end
    function on_move_focus_out(f, object::GtkNotebook, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "move-focus-out", Nothing, (UInt32,), after, user_data)
    end
    function on_page_added(f, object::GtkNotebook, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "page-added", Nothing, (Ptr{GObject}, UInt32), after, user_data)
    end
    function on_page_removed(f, object::GtkNotebook, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "page-removed", Nothing, (Ptr{GObject}, UInt32), after, user_data)
    end
    function on_page_reordered(f, object::GtkNotebook, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "page-reordered", Nothing, (Ptr{GObject}, UInt32), after, user_data)
    end
    function on_reorder_tab(f, object::GtkNotebook, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "reorder-tab", Cint, (UInt32, Cint), after, user_data)
    end
    function on_select_page(f, object::GtkNotebook, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "select-page", Cint, (Cint,), after, user_data)
    end
    function on_switch_page(f, object::GtkNotebook, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "switch-page", Nothing, (Ptr{GObject}, UInt32), after, user_data)
    end
    function on_get_child_position(f, object::GtkOverlay, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "get-child-position", Cint, (Ptr{GObject}, _GdkRectangle), after, user_data)
    end
    function on_accept_position(f, object::GtkPaned, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "accept-position", Cint, (), after, user_data)
    end
    function on_cancel_position(f, object::GtkPaned, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "cancel-position", Cint, (), after, user_data)
    end
    function on_cycle_child_focus(f, object::GtkPaned, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "cycle-child-focus", Cint, (Cint,), after, user_data)
    end
    function on_cycle_handle_focus(f, object::GtkPaned, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "cycle-handle-focus", Cint, (Cint,), after, user_data)
    end
    function on_move_handle(f, object::GtkPaned, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "move-handle", Cint, (UInt32,), after, user_data)
    end
    function on_toggle_handle_focus(f, object::GtkPaned, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "toggle-handle-focus", Cint, (), after, user_data)
    end
    function on_activate(f, object::GtkPasswordEntry, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "activate", Nothing, (), after, user_data)
    end
    function on_changed(f, object::GtkPasswordEntry, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "changed", Nothing, (), after, user_data)
    end
    function on_delete_text(f, object::GtkPasswordEntry, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "delete-text", Nothing, (Int32, Int32), after, user_data)
    end
    function on_insert_text(f, object::GtkPasswordEntry, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "insert-text", Nothing, (Cstring, Int32, Int32), after, user_data)
    end
    function on_activate_default(f, object::GtkPopover, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "activate-default", Nothing, (), after, user_data)
    end
    function on_closed(f, object::GtkPopover, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "closed", Nothing, (), after, user_data)
    end
    function on_status_changed(f, object::GtkPrintJob, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "status-changed", Nothing, (), after, user_data)
    end
    function on_begin_print(f, object::GtkPrintOperation, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "begin-print", Nothing, (Ptr{GObject},), after, user_data)
    end
    function on_create_custom_widget(f, object::GtkPrintOperation, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "create-custom-widget", Ptr{GObject}, (), after, user_data)
    end
    function on_custom_widget_apply(f, object::GtkPrintOperation, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "custom-widget-apply", Nothing, (Ptr{GObject},), after, user_data)
    end
    function on_done(f, object::GtkPrintOperation, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "done", Nothing, (UInt32,), after, user_data)
    end
    function on_draw_page(f, object::GtkPrintOperation, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "draw-page", Nothing, (Ptr{GObject}, Int32), after, user_data)
    end
    function on_end_print(f, object::GtkPrintOperation, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "end-print", Nothing, (Ptr{GObject},), after, user_data)
    end
    function on_paginate(f, object::GtkPrintOperation, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "paginate", Cint, (Ptr{GObject},), after, user_data)
    end
    function on_preview(f, object::GtkPrintOperation, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "preview", Cint, (Ptr{GObject}, Ptr{GObject}, Ptr{GObject}), after, user_data)
    end
    function on_request_page_setup(f, object::GtkPrintOperation, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "request-page-setup", Nothing, (Ptr{GObject}, Int32, Ptr{GObject}), after, user_data)
    end
    function on_status_changed(f, object::GtkPrintOperation, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "status-changed", Nothing, (), after, user_data)
    end
    function on_update_custom_widget(f, object::GtkPrintOperation, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "update-custom-widget", Nothing, (Ptr{GObject}, Ptr{GObject}, Ptr{GObject}), after, user_data)
    end
    function on_got_page_size(f, object::GtkPrintOperation, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "got-page-size", Nothing, (Ptr{GObject}, Ptr{GObject}), after, user_data)
    end
    function on_ready(f, object::GtkPrintOperation, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "ready", Nothing, (Ptr{GObject},), after, user_data)
    end
    function on_details_acquired(f, object::GtkPrinter, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "details-acquired", Nothing, (Cint,), after, user_data)
    end
    function on_adjust_bounds(f, object::GtkRange, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "adjust-bounds", Nothing, (Float64,), after, user_data)
    end
    function on_change_value(f, object::GtkRange, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "change-value", Cint, (UInt32, Float64), after, user_data)
    end
    function on_move_slider(f, object::GtkRange, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "move-slider", Nothing, (UInt32,), after, user_data)
    end
    function on_value_changed(f, object::GtkRange, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "value-changed", Nothing, (), after, user_data)
    end
    function on_changed(f, object::GtkRecentManager, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "changed", Nothing, (), after, user_data)
    end
    function on_popdown(f, object::GtkScaleButton, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "popdown", Nothing, (), after, user_data)
    end
    function on_popup(f, object::GtkScaleButton, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "popup", Nothing, (), after, user_data)
    end
    function on_value_changed(f, object::GtkScaleButton, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "value-changed", Nothing, (Float64,), after, user_data)
    end
    function on_edge_overshot(f, object::GtkScrolledWindow, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "edge-overshot", Nothing, (UInt32,), after, user_data)
    end
    function on_edge_reached(f, object::GtkScrolledWindow, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "edge-reached", Nothing, (UInt32,), after, user_data)
    end
    function on_move_focus_out(f, object::GtkScrolledWindow, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "move-focus-out", Nothing, (UInt32,), after, user_data)
    end
    function on_scroll_child(f, object::GtkScrolledWindow, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "scroll-child", Cint, (UInt32, Cint), after, user_data)
    end
    function on_activate(f, object::GtkSearchEntry, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "activate", Nothing, (), after, user_data)
    end
    function on_next_match(f, object::GtkSearchEntry, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "next-match", Nothing, (), after, user_data)
    end
    function on_previous_match(f, object::GtkSearchEntry, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "previous-match", Nothing, (), after, user_data)
    end
    function on_search_changed(f, object::GtkSearchEntry, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "search-changed", Nothing, (), after, user_data)
    end
    function on_search_started(f, object::GtkSearchEntry, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "search-started", Nothing, (), after, user_data)
    end
    function on_stop_search(f, object::GtkSearchEntry, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "stop-search", Nothing, (), after, user_data)
    end
    function on_changed(f, object::GtkSearchEntry, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "changed", Nothing, (), after, user_data)
    end
    function on_delete_text(f, object::GtkSearchEntry, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "delete-text", Nothing, (Int32, Int32), after, user_data)
    end
    function on_insert_text(f, object::GtkSearchEntry, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "insert-text", Nothing, (Cstring, Int32, Int32), after, user_data)
    end
    function on_items_changed(f, object::GtkSelectionFilterModel, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "items-changed", Nothing, (UInt32, UInt32, UInt32), after, user_data)
    end
    function on_gtk_private_changed(f, object::GtkSettings, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "gtk-private-changed", Nothing, (), after, user_data)
    end
    function on_items_changed(f, object::GtkShortcutController, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "items-changed", Nothing, (UInt32, UInt32, UInt32), after, user_data)
    end
    function on_change_current_page(f, object::GtkShortcutsSection, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "change-current-page", Cint, (Int32,), after, user_data)
    end
    function on_close(f, object::GtkShortcutsWindow, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "close", Nothing, (), after, user_data)
    end
    function on_search(f, object::GtkShortcutsWindow, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "search", Nothing, (), after, user_data)
    end
    function on_bind(f, object::GtkSignalListItemFactory, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "bind", Nothing, (Ptr{GObject},), after, user_data)
    end
    function on_setup(f, object::GtkSignalListItemFactory, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "setup", Nothing, (Ptr{GObject},), after, user_data)
    end
    function on_teardown(f, object::GtkSignalListItemFactory, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "teardown", Nothing, (Ptr{GObject},), after, user_data)
    end
    function on_unbind(f, object::GtkSignalListItemFactory, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "unbind", Nothing, (Ptr{GObject},), after, user_data)
    end
    function on_items_changed(f, object::GtkSingleSelection, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "items-changed", Nothing, (UInt32, UInt32, UInt32), after, user_data)
    end
    function on_sections_changed(f, object::GtkSingleSelection, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "sections-changed", Nothing, (UInt32, UInt32), after, user_data)
    end
    function on_selection_changed(f, object::GtkSingleSelection, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "selection-changed", Nothing, (UInt32, UInt32), after, user_data)
    end
    function on_items_changed(f, object::GtkSliceListModel, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "items-changed", Nothing, (UInt32, UInt32, UInt32), after, user_data)
    end
    function on_sections_changed(f, object::GtkSliceListModel, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "sections-changed", Nothing, (UInt32, UInt32), after, user_data)
    end
    function on_items_changed(f, object::GtkSortListModel, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "items-changed", Nothing, (UInt32, UInt32, UInt32), after, user_data)
    end
    function on_sections_changed(f, object::GtkSortListModel, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "sections-changed", Nothing, (UInt32, UInt32), after, user_data)
    end
    function on_changed(f, object::GtkSorter, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "changed", Nothing, (UInt32,), after, user_data)
    end
    function on_activate(f, object::GtkSpinButton, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "activate", Nothing, (), after, user_data)
    end
    function on_change_value(f, object::GtkSpinButton, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "change-value", Nothing, (UInt32,), after, user_data)
    end
    function on_input(f, object::GtkSpinButton, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "input", Int32, (Float64,), after, user_data)
    end
    function on_output(f, object::GtkSpinButton, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "output", Cint, (), after, user_data)
    end
    function on_value_changed(f, object::GtkSpinButton, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "value-changed", Nothing, (), after, user_data)
    end
    function on_wrapped(f, object::GtkSpinButton, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "wrapped", Nothing, (), after, user_data)
    end
    function on_editing_done(f, object::GtkSpinButton, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "editing-done", Nothing, (), after, user_data)
    end
    function on_remove_widget(f, object::GtkSpinButton, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "remove-widget", Nothing, (), after, user_data)
    end
    function on_changed(f, object::GtkSpinButton, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "changed", Nothing, (), after, user_data)
    end
    function on_delete_text(f, object::GtkSpinButton, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "delete-text", Nothing, (Int32, Int32), after, user_data)
    end
    function on_insert_text(f, object::GtkSpinButton, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "insert-text", Nothing, (Cstring, Int32, Int32), after, user_data)
    end
    function on_text_popped(f, object::GtkStatusbar, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "text-popped", Nothing, (UInt32, Cstring), after, user_data)
    end
    function on_text_pushed(f, object::GtkStatusbar, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "text-pushed", Nothing, (UInt32, Cstring), after, user_data)
    end
    function on_items_changed(f, object::GtkStringList, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "items-changed", Nothing, (UInt32, UInt32, UInt32), after, user_data)
    end
    function on_activate(f, object::GtkSwitch, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "activate", Nothing, (), after, user_data)
    end
    function on_state_set(f, object::GtkSwitch, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "state-set", Cint, (Cint,), after, user_data)
    end
    function on_activate(f, object::GtkText, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "activate", Nothing, (), after, user_data)
    end
    function on_backspace(f, object::GtkText, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "backspace", Nothing, (), after, user_data)
    end
    function on_copy_clipboard(f, object::GtkText, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "copy-clipboard", Nothing, (), after, user_data)
    end
    function on_cut_clipboard(f, object::GtkText, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "cut-clipboard", Nothing, (), after, user_data)
    end
    function on_delete_from_cursor(f, object::GtkText, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "delete-from-cursor", Nothing, (UInt32, Int32), after, user_data)
    end
    function on_insert_at_cursor(f, object::GtkText, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "insert-at-cursor", Nothing, (Cstring,), after, user_data)
    end
    function on_insert_emoji(f, object::GtkText, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "insert-emoji", Nothing, (), after, user_data)
    end
    function on_move_cursor(f, object::GtkText, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "move-cursor", Nothing, (UInt32, Int32, Cint), after, user_data)
    end
    function on_paste_clipboard(f, object::GtkText, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "paste-clipboard", Nothing, (), after, user_data)
    end
    function on_preedit_changed(f, object::GtkText, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "preedit-changed", Nothing, (Cstring,), after, user_data)
    end
    function on_toggle_overwrite(f, object::GtkText, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "toggle-overwrite", Nothing, (), after, user_data)
    end
    function on_changed(f, object::GtkText, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "changed", Nothing, (), after, user_data)
    end
    function on_delete_text(f, object::GtkText, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "delete-text", Nothing, (Int32, Int32), after, user_data)
    end
    function on_insert_text(f, object::GtkText, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "insert-text", Nothing, (Cstring, Int32, Int32), after, user_data)
    end
    function on_apply_tag(f, object::GtkTextBuffer, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "apply-tag", Nothing, (Ptr{GObject}, _GtkTextIter, _GtkTextIter), after, user_data)
    end
    function on_begin_user_action(f, object::GtkTextBuffer, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "begin-user-action", Nothing, (), after, user_data)
    end
    function on_changed(f, object::GtkTextBuffer, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "changed", Nothing, (), after, user_data)
    end
    function on_delete_range(f, object::GtkTextBuffer, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "delete-range", Nothing, (_GtkTextIter, _GtkTextIter), after, user_data)
    end
    function on_end_user_action(f, object::GtkTextBuffer, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "end-user-action", Nothing, (), after, user_data)
    end
    function on_insert_child_anchor(f, object::GtkTextBuffer, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "insert-child-anchor", Nothing, (_GtkTextIter, Ptr{GObject}), after, user_data)
    end
    function on_insert_paintable(f, object::GtkTextBuffer, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "insert-paintable", Nothing, (_GtkTextIter, Ptr{GObject}), after, user_data)
    end
    function on_insert_text(f, object::GtkTextBuffer, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "insert-text", Nothing, (_GtkTextIter, Cstring, Int32), after, user_data)
    end
    function on_mark_deleted(f, object::GtkTextBuffer, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "mark-deleted", Nothing, (Ptr{GObject},), after, user_data)
    end
    function on_mark_set(f, object::GtkTextBuffer, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "mark-set", Nothing, (_GtkTextIter, Ptr{GObject}), after, user_data)
    end
    function on_modified_changed(f, object::GtkTextBuffer, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "modified-changed", Nothing, (), after, user_data)
    end
    function on_paste_done(f, object::GtkTextBuffer, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "paste-done", Nothing, (Ptr{GObject},), after, user_data)
    end
    function on_redo(f, object::GtkTextBuffer, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "redo", Nothing, (), after, user_data)
    end
    function on_remove_tag(f, object::GtkTextBuffer, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "remove-tag", Nothing, (Ptr{GObject}, _GtkTextIter, _GtkTextIter), after, user_data)
    end
    function on_undo(f, object::GtkTextBuffer, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "undo", Nothing, (), after, user_data)
    end
    function on_tag_added(f, object::GtkTextTagTable, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "tag-added", Nothing, (Ptr{GObject},), after, user_data)
    end
    function on_tag_changed(f, object::GtkTextTagTable, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "tag-changed", Nothing, (Ptr{GObject}, Cint), after, user_data)
    end
    function on_tag_removed(f, object::GtkTextTagTable, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "tag-removed", Nothing, (Ptr{GObject},), after, user_data)
    end
    function on_backspace(f, object::GtkTextView, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "backspace", Nothing, (), after, user_data)
    end
    function on_copy_clipboard(f, object::GtkTextView, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "copy-clipboard", Nothing, (), after, user_data)
    end
    function on_cut_clipboard(f, object::GtkTextView, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "cut-clipboard", Nothing, (), after, user_data)
    end
    function on_delete_from_cursor(f, object::GtkTextView, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "delete-from-cursor", Nothing, (UInt32, Int32), after, user_data)
    end
    function on_extend_selection(f, object::GtkTextView, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "extend-selection", Cint, (UInt32, _GtkTextIter, _GtkTextIter, _GtkTextIter), after, user_data)
    end
    function on_insert_at_cursor(f, object::GtkTextView, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "insert-at-cursor", Nothing, (Cstring,), after, user_data)
    end
    function on_insert_emoji(f, object::GtkTextView, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "insert-emoji", Nothing, (), after, user_data)
    end
    function on_move_cursor(f, object::GtkTextView, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "move-cursor", Nothing, (UInt32, Int32, Cint), after, user_data)
    end
    function on_move_viewport(f, object::GtkTextView, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "move-viewport", Nothing, (UInt32, Int32), after, user_data)
    end
    function on_paste_clipboard(f, object::GtkTextView, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "paste-clipboard", Nothing, (), after, user_data)
    end
    function on_preedit_changed(f, object::GtkTextView, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "preedit-changed", Nothing, (Cstring,), after, user_data)
    end
    function on_select_all(f, object::GtkTextView, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "select-all", Nothing, (Cint,), after, user_data)
    end
    function on_set_anchor(f, object::GtkTextView, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "set-anchor", Nothing, (), after, user_data)
    end
    function on_toggle_cursor_visible(f, object::GtkTextView, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "toggle-cursor-visible", Nothing, (), after, user_data)
    end
    function on_toggle_overwrite(f, object::GtkTextView, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "toggle-overwrite", Nothing, (), after, user_data)
    end
    function on_toggled(f, object::GtkToggleButton, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "toggled", Nothing, (), after, user_data)
    end
    function on_items_changed(f, object::GtkTreeListModel, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "items-changed", Nothing, (UInt32, UInt32, UInt32), after, user_data)
    end
    function on_row_changed(f, object::GtkTreeModelFilter, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "row-changed", Nothing, (GtkTreePath, _GtkTreeIter), after, user_data)
    end
    function on_row_deleted(f, object::GtkTreeModelFilter, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "row-deleted", Nothing, (GtkTreePath,), after, user_data)
    end
    function on_row_has_child_toggled(f, object::GtkTreeModelFilter, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "row-has-child-toggled", Nothing, (GtkTreePath, _GtkTreeIter), after, user_data)
    end
    function on_row_inserted(f, object::GtkTreeModelFilter, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "row-inserted", Nothing, (GtkTreePath, _GtkTreeIter), after, user_data)
    end
    function on_row_changed(f, object::GtkTreeModelSort, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "row-changed", Nothing, (GtkTreePath, _GtkTreeIter), after, user_data)
    end
    function on_row_deleted(f, object::GtkTreeModelSort, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "row-deleted", Nothing, (GtkTreePath,), after, user_data)
    end
    function on_row_has_child_toggled(f, object::GtkTreeModelSort, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "row-has-child-toggled", Nothing, (GtkTreePath, _GtkTreeIter), after, user_data)
    end
    function on_row_inserted(f, object::GtkTreeModelSort, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "row-inserted", Nothing, (GtkTreePath, _GtkTreeIter), after, user_data)
    end
    function on_sort_column_changed(f, object::GtkTreeModelSort, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "sort-column-changed", Nothing, (), after, user_data)
    end
    function on_changed(f, object::GtkTreeSelection, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "changed", Nothing, (), after, user_data)
    end
    function on_row_changed(f, object::GtkTreeStore, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "row-changed", Nothing, (GtkTreePath, _GtkTreeIter), after, user_data)
    end
    function on_row_deleted(f, object::GtkTreeStore, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "row-deleted", Nothing, (GtkTreePath,), after, user_data)
    end
    function on_row_has_child_toggled(f, object::GtkTreeStore, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "row-has-child-toggled", Nothing, (GtkTreePath, _GtkTreeIter), after, user_data)
    end
    function on_row_inserted(f, object::GtkTreeStore, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "row-inserted", Nothing, (GtkTreePath, _GtkTreeIter), after, user_data)
    end
    function on_sort_column_changed(f, object::GtkTreeStore, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "sort-column-changed", Nothing, (), after, user_data)
    end
    function on_columns_changed(f, object::GtkTreeView, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "columns-changed", Nothing, (), after, user_data)
    end
    function on_cursor_changed(f, object::GtkTreeView, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "cursor-changed", Nothing, (), after, user_data)
    end
    function on_expand_collapse_cursor_row(f, object::GtkTreeView, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "expand-collapse-cursor-row", Cint, (Cint, Cint, Cint), after, user_data)
    end
    function on_move_cursor(f, object::GtkTreeView, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "move-cursor", Cint, (UInt32, Int32, Cint, Cint), after, user_data)
    end
    function on_row_activated(f, object::GtkTreeView, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "row-activated", Nothing, (GtkTreePath, Ptr{GObject}), after, user_data)
    end
    function on_row_collapsed(f, object::GtkTreeView, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "row-collapsed", Nothing, (_GtkTreeIter, GtkTreePath), after, user_data)
    end
    function on_row_expanded(f, object::GtkTreeView, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "row-expanded", Nothing, (_GtkTreeIter, GtkTreePath), after, user_data)
    end
    function on_select_all(f, object::GtkTreeView, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "select-all", Cint, (), after, user_data)
    end
    function on_select_cursor_parent(f, object::GtkTreeView, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "select-cursor-parent", Cint, (), after, user_data)
    end
    function on_select_cursor_row(f, object::GtkTreeView, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "select-cursor-row", Cint, (Cint,), after, user_data)
    end
    function on_start_interactive_search(f, object::GtkTreeView, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "start-interactive-search", Cint, (), after, user_data)
    end
    function on_test_collapse_row(f, object::GtkTreeView, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "test-collapse-row", Cint, (_GtkTreeIter, GtkTreePath), after, user_data)
    end
    function on_test_expand_row(f, object::GtkTreeView, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "test-expand-row", Cint, (_GtkTreeIter, GtkTreePath), after, user_data)
    end
    function on_toggle_cursor_row(f, object::GtkTreeView, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "toggle-cursor-row", Cint, (), after, user_data)
    end
    function on_unselect_all(f, object::GtkTreeView, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "unselect-all", Cint, (), after, user_data)
    end
    function on_clicked(f, object::GtkTreeViewColumn, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "clicked", Nothing, (), after, user_data)
    end
    function on_destroy(f, object::GtkWidget, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "destroy", Nothing, (), after, user_data)
    end
    function on_direction_changed(f, object::GtkWidget, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "direction-changed", Nothing, (UInt32,), after, user_data)
    end
    function on_hide(f, object::GtkWidget, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "hide", Nothing, (), after, user_data)
    end
    function on_keynav_failed(f, object::GtkWidget, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "keynav-failed", Cint, (UInt32,), after, user_data)
    end
    function on_map(f, object::GtkWidget, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "map", Nothing, (), after, user_data)
    end
    function on_mnemonic_activate(f, object::GtkWidget, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "mnemonic-activate", Cint, (Cint,), after, user_data)
    end
    function on_move_focus(f, object::GtkWidget, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "move-focus", Nothing, (UInt32,), after, user_data)
    end
    function on_query_tooltip(f, object::GtkWidget, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "query-tooltip", Cint, (Int32, Int32, Cint, Ptr{GObject}), after, user_data)
    end
    function on_realize(f, object::GtkWidget, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "realize", Nothing, (), after, user_data)
    end
    function on_show(f, object::GtkWidget, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "show", Nothing, (), after, user_data)
    end
    function on_state_flags_changed(f, object::GtkWidget, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "state-flags-changed", Nothing, (UInt32,), after, user_data)
    end
    function on_unmap(f, object::GtkWidget, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "unmap", Nothing, (), after, user_data)
    end
    function on_unrealize(f, object::GtkWidget, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "unrealize", Nothing, (), after, user_data)
    end
    function on_invalidate_contents(f, object::GtkWidgetPaintable, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "invalidate-contents", Nothing, (), after, user_data)
    end
    function on_invalidate_size(f, object::GtkWidgetPaintable, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "invalidate-size", Nothing, (), after, user_data)
    end
    function on_activate_default(f, object::GtkWindow, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "activate-default", Nothing, (), after, user_data)
    end
    function on_activate_focus(f, object::GtkWindow, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "activate-focus", Nothing, (), after, user_data)
    end
    function on_close_request(f, object::GtkWindow, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "close-request", Cint, (), after, user_data)
    end
    function on_enable_debugging(f, object::GtkWindow, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "enable-debugging", Cint, (Cint,), after, user_data)
    end
    function on_keys_changed(f, object::GtkWindow, user_data = object, after = false)
        GLib.signal_connect_generic(f, object, "keys-changed", Nothing, (), after, user_data)
    end
    function GtkAssistantPageFunc(current_page, data)
        f = data
        ret = f(current_page)
        convert(Int32, ret)
    end
    function GtkCellAllocCallback(renderer, cell_area, cell_background, data)
        renderer = convert(GtkCellRenderer, renderer, false)
        cell_area = convert(GdkRectangleLike, cell_area, false)
        cell_background = convert(GdkRectangleLike, cell_background, false)
        f = data
        ret = f(renderer, cell_area, cell_background)
        convert(Cint, ret)
    end
    function GtkCellCallback(renderer, data)
        renderer = convert(GtkCellRenderer, renderer, false)
        f = data
        ret = f(renderer)
        convert(Cint, ret)
    end
    function GtkCellLayoutDataFunc(cell_layout, cell, tree_model, iter, data)
        cell_layout = begin
                leaftype = GLib.find_leaf_type(cell_layout)
                convert(leaftype, cell_layout, false)
            end
        cell = convert(GtkCellRenderer, cell, false)
        tree_model = begin
                leaftype = GLib.find_leaf_type(tree_model)
                convert(leaftype, tree_model, false)
            end
        iter = convert(GtkTreeIterLike, iter, false)
        f = data
        ret = f(cell_layout, cell, tree_model, iter)
        nothing
    end
    function GtkCustomFilterFunc(item, user_data)
        item = convert(GObject, item, false)
        f = user_data
        ret = f(item)
        convert(Cint, ret)
    end
    function GtkDrawingAreaDrawFunc(drawing_area, cr, width, height, user_data)
        drawing_area = convert(GtkDrawingArea, drawing_area, false)
        cr = convert(cairoContext, cr, false)
        f = user_data
        ret = f(drawing_area, cr, width, height)
        nothing
    end
    function GtkEntryCompletionMatchFunc(completion, key, iter, user_data)
        completion = convert(GtkEntryCompletion, completion, false)
        key = string_or_nothing(key, false)
        iter = convert(GtkTreeIterLike, iter, false)
        f = user_data
        ret = f(completion, key, iter)
        convert(Cint, ret)
    end
    function GtkExpressionNotify(user_data)
        f = user_data
        ret = f()
        nothing
    end
    function GtkFlowBoxCreateWidgetFunc(item, user_data)
        item = convert(GObject, item, false)
        f = user_data
        ret = f(item)
        ret != C_NULL && GLib.glib_ref(ret)
        convert(Ptr{GObject}, GLib.get_pointer(ret))
    end
    function GtkFlowBoxFilterFunc(child, user_data)
        child = convert(GtkFlowBoxChild, child, false)
        f = user_data
        ret = f(child)
        convert(Cint, ret)
    end
    function GtkFlowBoxForeachFunc(box, child, user_data)
        box = convert(GtkFlowBox, box, false)
        child = convert(GtkFlowBoxChild, child, false)
        f = user_data
        ret = f(box, child)
        nothing
    end
    function GtkFlowBoxSortFunc(child1, child2, user_data)
        child1 = convert(GtkFlowBoxChild, child1, false)
        child2 = convert(GtkFlowBoxChild, child2, false)
        f = user_data
        ret = f(child1, child2)
        convert(Int32, ret)
    end
    function GtkFontFilterFunc(family, face, data)
        family = convert(PangoFontFamily, family, false)
        face = convert(PangoFontFace, face, false)
        f = data
        ret = f(family, face)
        convert(Cint, ret)
    end
    function GtkIconViewForeachFunc(icon_view, path, data)
        icon_view = convert(GtkIconView, icon_view, false)
        path = convert(GtkTreePath, path, false)
        f = data
        ret = f(icon_view, path)
        nothing
    end
    function GtkListBoxCreateWidgetFunc(item, user_data)
        item = convert(GObject, item, false)
        f = user_data
        ret = f(item)
        ret != C_NULL && GLib.glib_ref(ret)
        convert(Ptr{GObject}, GLib.get_pointer(ret))
    end
    function GtkListBoxFilterFunc(row, user_data)
        row = convert(GtkListBoxRow, row, false)
        f = user_data
        ret = f(row)
        convert(Cint, ret)
    end
    function GtkListBoxForeachFunc(box, row, user_data)
        box = convert(GtkListBox, box, false)
        row = convert(GtkListBoxRow, row, false)
        f = user_data
        ret = f(box, row)
        nothing
    end
    function GtkListBoxSortFunc(row1, row2, user_data)
        row1 = convert(GtkListBoxRow, row1, false)
        row2 = convert(GtkListBoxRow, row2, false)
        f = user_data
        ret = f(row1, row2)
        convert(Int32, ret)
    end
    function GtkListBoxUpdateHeaderFunc(row, before, user_data)
        row = convert(GtkListBoxRow, row, false)
        before = convert_if_not_null(GtkListBoxRow, before, false)
        f = user_data
        ret = f(row, before)
        nothing
    end
    function GtkMapListModelMapFunc(item, user_data)
        item = convert(GObject, item, true)
        f = user_data
        ret = f(item)
        ret != C_NULL && GLib.glib_ref(ret)
        convert(Ptr{GObject}, GLib.get_pointer(ret))
    end
    function GtkMenuButtonCreatePopupFunc(menu_button, user_data)
        menu_button = convert(GtkMenuButton, menu_button, false)
        f = user_data
        ret = f(menu_button)
        nothing
    end
    function GtkPageSetupDoneFunc(page_setup, data)
        page_setup = convert(GtkPageSetup, page_setup, false)
        f = data
        ret = f(page_setup)
        nothing
    end
    function GtkPrintSettingsFunc(key, value, user_data)
        key = string_or_nothing(key, false)
        value = string_or_nothing(value, false)
        f = user_data
        ret = f(key, value)
        nothing
    end
    function GtkPrinterFunc(printer, data)
        printer = convert(GtkPrinter, printer, false)
        f = data
        ret = f(printer)
        convert(Cint, ret)
    end
    function GtkScaleFormatValueFunc(scale, value, user_data)
        scale = convert(GtkScale, scale, false)
        f = user_data
        ret = f(scale, value)
        convert(Cstring, ret)
    end
    function GtkShortcutFunc(widget, args, user_data)
        widget = convert(GtkWidget, widget, false)
        args = convert(Maybe(GVariant), args)
        f = user_data
        ret = f(widget, args)
        convert(Cint, ret)
    end
    function GtkTextBufferCommitNotify(buffer, flags, position, length, user_data)
        buffer = convert(GtkTextBuffer, buffer, false)
        flags = TextBufferNotifyFlags(flags)
        f = user_data
        ret = f(buffer, flags, position, length)
        nothing
    end
    function GtkTextCharPredicate(ch, user_data)
        f = user_data
        ret = f(ch)
        convert(Cint, ret)
    end
    function GtkTextTagTableForeach(tag, data)
        tag = convert(GtkTextTag, tag, false)
        f = data
        ret = f(tag)
        nothing
    end
    function GtkTickCallback(widget, frame_clock, user_data)
        widget = convert(GtkWidget, widget, false)
        frame_clock = convert(GdkFrameClock, frame_clock, false)
        f = user_data
        ret = f(widget, frame_clock)
        convert(Cint, ret)
    end
    function GtkTreeCellDataFunc(tree_column, cell, tree_model, iter, data)
        tree_column = convert(GtkTreeViewColumn, tree_column, false)
        cell = convert(GtkCellRenderer, cell, false)
        tree_model = begin
                leaftype = GLib.find_leaf_type(tree_model)
                convert(leaftype, tree_model, false)
            end
        iter = convert(GtkTreeIterLike, iter, false)
        f = data
        ret = f(tree_column, cell, tree_model, iter)
        nothing
    end
    function GtkTreeIterCompareFunc(model, a, b, user_data)
        model = begin
                leaftype = GLib.find_leaf_type(model)
                convert(leaftype, model, false)
            end
        a = convert(GtkTreeIterLike, a, false)
        b = convert(GtkTreeIterLike, b, false)
        f = user_data
        ret = f(model, a, b)
        convert(Int32, ret)
    end
    function GtkTreeListModelCreateModelFunc(item, user_data)
        item = convert(GObject, item, false)
        f = user_data
        ret = f(item)
        ret != C_NULL && GLib.glib_ref(ret)
        convert(Ptr{GObject}, GLib.get_pointer(ret))
    end
    function GtkTreeModelFilterModifyFunc(model, iter, value, column, data)
        model = begin
                leaftype = GLib.find_leaf_type(model)
                convert(leaftype, model, false)
            end
        iter = convert(GtkTreeIterLike, iter, false)
        f = data
        ret = f(model, iter, value, column)
        nothing
    end
    function GtkTreeModelFilterVisibleFunc(model, iter, data)
        model = begin
                leaftype = GLib.find_leaf_type(model)
                convert(leaftype, model, false)
            end
        iter = convert(GtkTreeIterLike, iter, false)
        f = data
        ret = f(model, iter)
        convert(Cint, ret)
    end
    function GtkTreeModelForeachFunc(model, path, iter, data)
        model = begin
                leaftype = GLib.find_leaf_type(model)
                convert(leaftype, model, false)
            end
        path = convert(GtkTreePath, path, false)
        iter = convert(GtkTreeIterLike, iter, false)
        f = data
        ret = f(model, path, iter)
        convert(Cint, ret)
    end
    function GtkTreeSelectionForeachFunc(model, path, iter, data)
        model = begin
                leaftype = GLib.find_leaf_type(model)
                convert(leaftype, model, false)
            end
        path = convert(GtkTreePath, path, false)
        iter = convert(GtkTreeIterLike, iter, false)
        f = data
        ret = f(model, path, iter)
        nothing
    end
    function GtkTreeSelectionFunc(selection, model, path, path_currently_selected, data)
        selection = convert(GtkTreeSelection, selection, false)
        model = begin
                leaftype = GLib.find_leaf_type(model)
                convert(leaftype, model, false)
            end
        path = convert(GtkTreePath, path, false)
        path_currently_selected = convert(Bool, path_currently_selected)
        f = data
        ret = f(selection, model, path, path_currently_selected)
        convert(Cint, ret)
    end
    function GtkTreeViewColumnDropFunc(tree_view, column, prev_column, next_column, data)
        tree_view = convert(GtkTreeView, tree_view, false)
        column = convert(GtkTreeViewColumn, column, false)
        prev_column = convert(GtkTreeViewColumn, prev_column, false)
        next_column = convert(GtkTreeViewColumn, next_column, false)
        f = data
        ret = f(tree_view, column, prev_column, next_column)
        convert(Cint, ret)
    end
    function GtkTreeViewMappingFunc(tree_view, path, user_data)
        tree_view = convert(GtkTreeView, tree_view, false)
        path = convert(GtkTreePath, path, false)
        f = user_data
        ret = f(tree_view, path)
        nothing
    end
    function GtkTreeViewRowSeparatorFunc(model, iter, data)
        model = begin
                leaftype = GLib.find_leaf_type(model)
                convert(leaftype, model, false)
            end
        iter = convert(GtkTreeIterLike, iter, false)
        f = data
        ret = f(model, iter)
        convert(Cint, ret)
    end
    function GtkTreeViewSearchEqualFunc(model, column, key, iter, search_data)
        model = begin
                leaftype = GLib.find_leaf_type(model)
                convert(leaftype, model, false)
            end
        key = string_or_nothing(key, false)
        iter = convert(GtkTreeIterLike, iter, false)
        f = search_data
        ret = f(model, column, key, iter)
        convert(Cint, ret)
    end
    export GtkAccessibleList, GtkAccessibleTextRange, GtkAccessibleTextRangeLike, _GtkAccessibleTextRange, GtkBitset, GtkBitsetIter, GtkBitsetIterLike, _GtkBitsetIter, GtkBorder, GtkBorderLike, _GtkBorder, GtkBuildableParseContext, GtkBuildableParser, GtkBuildableParserLike, _GtkBuildableParser, GtkCssLocation, GtkCssLocationLike, _GtkCssLocation, GtkCssSection, GtkCssStyleChange, GtkExpressionWatch, GtkPadActionEntry, GtkPadActionEntryLike, _GtkPadActionEntry, GtkPaperSize, GtkPrintBackend, GtkPrintSetup, GtkRecentData, GtkRecentDataLike, _GtkRecentData, GtkRecentInfo, GtkRequestedSize, GtkRequestedSizeLike, _GtkRequestedSize, GtkRequisition, GtkRequisitionLike, _GtkRequisition, GtkScrollInfo, GtkTextIter, GtkTextIterLike, _GtkTextIter, GtkTreeIter, GtkTreeIterLike, _GtkTreeIter, GtkTreePath, GtkAccessible, GtkAccessibleRange, GtkAccessibleText, GtkActionable, GtkAppChooser, GtkBuildable, GtkBuilderScope, GtkCellEditable, GtkCellLayout, GtkColorChooser, GtkConstraintTarget, GtkEditable, GtkFileChooser, GtkFontChooser, GtkNative, GtkOrientable, GtkPrintOperationPreview, GtkRoot, GtkScrollable, GtkSectionModel, GtkSelectionModel, GtkShortcutManager, GtkStyleProvider, GtkSymbolicPaintable, GtkTreeDragDest, GtkTreeDragSource, GtkTreeModel, GtkTreeSortable, GtkATContext, GtkAboutDialog, GtkAboutDialogLeaf, GtkActionBar, GtkActionBarLeaf, GtkActivateAction, GtkActivateActionLeaf, GtkAdjustment, GtkAdjustmentLeaf, GtkAlertDialog, GtkAlertDialogLeaf, GtkAlternativeTrigger, GtkAlternativeTriggerLeaf, GtkAnyFilter, GtkAnyFilterLeaf, GtkAppChooserButton, GtkAppChooserButtonLeaf, GtkAppChooserDialog, GtkAppChooserDialogLeaf, GtkAppChooserWidget, GtkAppChooserWidgetLeaf, GtkApplication, GtkApplicationLeaf, GtkApplicationWindow, GtkApplicationWindowLeaf, GtkAspectFrame, GtkAspectFrameLeaf, GtkAssistant, GtkAssistantLeaf, GtkAssistantPage, GtkAssistantPageLeaf, GtkBinLayout, GtkBinLayoutLeaf, GtkBookmarkList, GtkBookmarkListLeaf, GtkBoolFilter, GtkBoolFilterLeaf, GtkBox, GtkBoxLeaf, GtkBoxLayout, GtkBoxLayoutLeaf, GtkBuilder, GtkBuilderLeaf, GtkBuilderCScope, GtkBuilderCScopeLeaf, GtkBuilderListItemFactory, GtkBuilderListItemFactoryLeaf, GtkButton, GtkButtonLeaf, GtkCalendar, GtkCalendarLeaf, GtkCallbackAction, GtkCallbackActionLeaf, GtkCellArea, GtkCellAreaBox, GtkCellAreaBoxLeaf, GtkCellAreaContext, GtkCellAreaContextLeaf, GtkCellRenderer, GtkCellRendererAccel, GtkCellRendererAccelLeaf, GtkCellRendererCombo, GtkCellRendererComboLeaf, GtkCellRendererPixbuf, GtkCellRendererPixbufLeaf, GtkCellRendererProgress, GtkCellRendererProgressLeaf, GtkCellRendererSpin, GtkCellRendererSpinLeaf, GtkCellRendererSpinner, GtkCellRendererSpinnerLeaf, GtkCellRendererText, GtkCellRendererTextLeaf, GtkCellRendererToggle, GtkCellRendererToggleLeaf, GtkCellView, GtkCellViewLeaf, GtkCenterBox, GtkCenterBoxLeaf, GtkCenterLayout, GtkCenterLayoutLeaf, GtkCheckButton, GtkCheckButtonLeaf, GtkColorButton, GtkColorButtonLeaf, GtkColorChooserDialog, GtkColorChooserDialogLeaf, GtkColorChooserWidget, GtkColorChooserWidgetLeaf, GtkColorDialog, GtkColorDialogLeaf, GtkColorDialogButton, GtkColorDialogButtonLeaf, GtkColumnView, GtkColumnViewLeaf, GtkColumnViewCell, GtkColumnViewCellLeaf, GtkColumnViewColumn, GtkColumnViewColumnLeaf, GtkColumnViewRow, GtkColumnViewRowLeaf, GtkColumnViewSorter, GtkColumnViewSorterLeaf, GtkComboBox, GtkComboBoxLeaf, GtkComboBoxText, GtkComboBoxTextLeaf, GtkConstantExpression, GtkConstantExpressionLeaf, GtkConstraint, GtkConstraintLeaf, GtkConstraintGuide, GtkConstraintGuideLeaf, GtkConstraintLayout, GtkConstraintLayoutLeaf, GtkConstraintLayoutChild, GtkConstraintLayoutChildLeaf, GtkCssProvider, GtkCssProviderLeaf, GtkCustomFilter, GtkCustomFilterLeaf, GtkCustomLayout, GtkCustomLayoutLeaf, GtkCustomSorter, GtkCustomSorterLeaf, GtkDialog, GtkDialogLeaf, GtkDirectoryList, GtkDirectoryListLeaf, GtkDragIcon, GtkDragIconLeaf, GtkDragSource, GtkDragSourceLeaf, GtkDrawingArea, GtkDrawingAreaLeaf, GtkDropControllerMotion, GtkDropControllerMotionLeaf, GtkDropDown, GtkDropDownLeaf, GtkDropTarget, GtkDropTargetLeaf, GtkDropTargetAsync, GtkDropTargetAsyncLeaf, GtkEditableLabel, GtkEditableLabelLeaf, GtkEmojiChooser, GtkEmojiChooserLeaf, GtkEntry, GtkEntryLeaf, GtkEntryBuffer, GtkEntryBufferLeaf, GtkEntryCompletion, GtkEntryCompletionLeaf, GtkEventController, GtkEventControllerFocus, GtkEventControllerFocusLeaf, GtkEventControllerKey, GtkEventControllerKeyLeaf, GtkEventControllerLegacy, GtkEventControllerLegacyLeaf, GtkEventControllerMotion, GtkEventControllerMotionLeaf, GtkEventControllerScroll, GtkEventControllerScrollLeaf, GtkEveryFilter, GtkEveryFilterLeaf, GtkExpander, GtkExpanderLeaf, GtkExpression, GtkFileChooserDialog, GtkFileChooserDialogLeaf, GtkFileChooserNative, GtkFileChooserNativeLeaf, GtkFileChooserWidget, GtkFileChooserWidgetLeaf, GtkFileDialog, GtkFileDialogLeaf, GtkFileFilter, GtkFileFilterLeaf, GtkFileLauncher, GtkFileLauncherLeaf, GtkFilter, GtkFilterLeaf, GtkFilterListModel, GtkFilterListModelLeaf, GtkFixed, GtkFixedLeaf, GtkFixedLayout, GtkFixedLayoutLeaf, GtkFixedLayoutChild, GtkFixedLayoutChildLeaf, GtkFlattenListModel, GtkFlattenListModelLeaf, GtkFlowBox, GtkFlowBoxLeaf, GtkFlowBoxChild, GtkFlowBoxChildLeaf, GtkFontButton, GtkFontButtonLeaf, GtkFontChooserDialog, GtkFontChooserDialogLeaf, GtkFontChooserWidget, GtkFontChooserWidgetLeaf, GtkFontDialog, GtkFontDialogLeaf, GtkFontDialogButton, GtkFontDialogButtonLeaf, GtkFrame, GtkFrameLeaf, GtkGLArea, GtkGLAreaLeaf, GtkGesture, GtkGestureClick, GtkGestureClickLeaf, GtkGestureDrag, GtkGestureDragLeaf, GtkGestureLongPress, GtkGestureLongPressLeaf, GtkGesturePan, GtkGesturePanLeaf, GtkGestureRotate, GtkGestureRotateLeaf, GtkGestureSingle, GtkGestureSingleLeaf, GtkGestureStylus, GtkGestureStylusLeaf, GtkGestureSwipe, GtkGestureSwipeLeaf, GtkGestureZoom, GtkGestureZoomLeaf, GtkGraphicsOffload, GtkGraphicsOffloadLeaf, GtkGrid, GtkGridLeaf, GtkGridLayout, GtkGridLayoutLeaf, GtkGridLayoutChild, GtkGridLayoutChildLeaf, GtkGridView, GtkGridViewLeaf, GtkHeaderBar, GtkHeaderBarLeaf, GtkIMContext, GtkIMContextSimple, GtkIMContextSimpleLeaf, GtkIMMulticontext, GtkIMMulticontextLeaf, GtkIconPaintable, GtkIconPaintableLeaf, GtkIconTheme, GtkIconThemeLeaf, GtkIconView, GtkIconViewLeaf, GtkImage, GtkImageLeaf, GtkInfoBar, GtkInfoBarLeaf, GtkInscription, GtkInscriptionLeaf, GtkKeyvalTrigger, GtkKeyvalTriggerLeaf, GtkLabel, GtkLabelLeaf, GtkLayoutChild, GtkLayoutManager, GtkLevelBar, GtkLevelBarLeaf, GtkLinkButton, GtkLinkButtonLeaf, GtkListBase, GtkListBox, GtkListBoxLeaf, GtkListBoxRow, GtkListBoxRowLeaf, GtkListHeader, GtkListHeaderLeaf, GtkListItem, GtkListItemLeaf, GtkListItemFactory, GtkListItemFactoryLeaf, GtkListStore, GtkListStoreLeaf, GtkListView, GtkListViewLeaf, GtkLockButton, GtkLockButtonLeaf, GtkMapListModel, GtkMapListModelLeaf, GtkMediaControls, GtkMediaControlsLeaf, GtkMediaFile, GtkMediaStream, GtkMenuButton, GtkMenuButtonLeaf, GtkMessageDialog, GtkMessageDialogLeaf, GtkMnemonicAction, GtkMnemonicActionLeaf, GtkMnemonicTrigger, GtkMnemonicTriggerLeaf, GtkMountOperation, GtkMountOperationLeaf, GtkMultiFilter, GtkMultiSelection, GtkMultiSelectionLeaf, GtkMultiSorter, GtkMultiSorterLeaf, GtkNamedAction, GtkNamedActionLeaf, GtkNativeDialog, GtkNeverTrigger, GtkNeverTriggerLeaf, GtkNoSelection, GtkNoSelectionLeaf, GtkNotebook, GtkNotebookLeaf, GtkNotebookPage, GtkNotebookPageLeaf, GtkNothingAction, GtkNothingActionLeaf, GtkNumericSorter, GtkNumericSorterLeaf, GtkObjectExpression, GtkObjectExpressionLeaf, GtkOverlay, GtkOverlayLeaf, GtkOverlayLayout, GtkOverlayLayoutLeaf, GtkOverlayLayoutChild, GtkOverlayLayoutChildLeaf, GtkPadController, GtkPadControllerLeaf, GtkPageSetup, GtkPageSetupLeaf, GtkPaned, GtkPanedLeaf, GtkPasswordEntry, GtkPasswordEntryLeaf, GtkPasswordEntryBuffer, GtkPasswordEntryBufferLeaf, GtkPicture, GtkPictureLeaf, GtkPopover, GtkPopoverLeaf, GtkPopoverMenu, GtkPopoverMenuLeaf, GtkPopoverMenuBar, GtkPopoverMenuBarLeaf, GtkPrintContext, GtkPrintContextLeaf, GtkPrintDialog, GtkPrintDialogLeaf, GtkPrintJob, GtkPrintJobLeaf, GtkPrintOperation, GtkPrintOperationLeaf, GtkPrintSettings, GtkPrintSettingsLeaf, GtkPrinter, GtkPrinterLeaf, GtkProgressBar, GtkProgressBarLeaf, GtkPropertyExpression, GtkPropertyExpressionLeaf, GtkRange, GtkRangeLeaf, GtkRecentManager, GtkRecentManagerLeaf, GtkRevealer, GtkRevealerLeaf, GtkScale, GtkScaleLeaf, GtkScaleButton, GtkScaleButtonLeaf, GtkScrollbar, GtkScrollbarLeaf, GtkScrolledWindow, GtkScrolledWindowLeaf, GtkSearchBar, GtkSearchBarLeaf, GtkSearchEntry, GtkSearchEntryLeaf, GtkSelectionFilterModel, GtkSelectionFilterModelLeaf, GtkSeparator, GtkSeparatorLeaf, GtkSettings, GtkSettingsLeaf, GtkShortcut, GtkShortcutLeaf, GtkShortcutAction, GtkShortcutController, GtkShortcutControllerLeaf, GtkShortcutLabel, GtkShortcutLabelLeaf, GtkShortcutTrigger, GtkShortcutsGroup, GtkShortcutsGroupLeaf, GtkShortcutsSection, GtkShortcutsSectionLeaf, GtkShortcutsShortcut, GtkShortcutsShortcutLeaf, GtkShortcutsWindow, GtkShortcutsWindowLeaf, GtkSignalAction, GtkSignalActionLeaf, GtkSignalListItemFactory, GtkSignalListItemFactoryLeaf, GtkSingleSelection, GtkSingleSelectionLeaf, GtkSizeGroup, GtkSizeGroupLeaf, GtkSliceListModel, GtkSliceListModelLeaf, GtkSnapshot, GtkSnapshotLeaf, GtkSortListModel, GtkSortListModelLeaf, GtkSorter, GtkSorterLeaf, GtkSpinButton, GtkSpinButtonLeaf, GtkSpinner, GtkSpinnerLeaf, GtkStack, GtkStackLeaf, GtkStackPage, GtkStackPageLeaf, GtkStackSidebar, GtkStackSidebarLeaf, GtkStackSwitcher, GtkStackSwitcherLeaf, GtkStatusbar, GtkStatusbarLeaf, GtkStringFilter, GtkStringFilterLeaf, GtkStringList, GtkStringListLeaf, GtkStringObject, GtkStringObjectLeaf, GtkStringSorter, GtkStringSorterLeaf, GtkStyleContext, GtkStyleContextLeaf, GtkSwitch, GtkSwitchLeaf, GtkText, GtkTextLeaf, GtkTextBuffer, GtkTextBufferLeaf, GtkTextChildAnchor, GtkTextChildAnchorLeaf, GtkTextMark, GtkTextMarkLeaf, GtkTextTag, GtkTextTagLeaf, GtkTextTagTable, GtkTextTagTableLeaf, GtkTextView, GtkTextViewLeaf, GtkToggleButton, GtkToggleButtonLeaf, GtkTooltip, GtkTooltipLeaf, GtkTreeExpander, GtkTreeExpanderLeaf, GtkTreeListModel, GtkTreeListModelLeaf, GtkTreeListRow, GtkTreeListRowLeaf, GtkTreeListRowSorter, GtkTreeListRowSorterLeaf, GtkTreeModelFilter, GtkTreeModelFilterLeaf, GtkTreeModelSort, GtkTreeModelSortLeaf, GtkTreeSelection, GtkTreeSelectionLeaf, GtkTreeStore, GtkTreeStoreLeaf, GtkTreeView, GtkTreeViewLeaf, GtkTreeViewColumn, GtkTreeViewColumnLeaf, GtkUriLauncher, GtkUriLauncherLeaf, GtkVideo, GtkVideoLeaf, GtkViewport, GtkViewportLeaf, GtkVolumeButton, GtkVolumeButtonLeaf, GtkWidget, GtkWidgetPaintable, GtkWidgetPaintableLeaf, GtkWindow, GtkWindowLeaf, GtkWindowControls, GtkWindowControlsLeaf, GtkWindowGroup, GtkWindowGroupLeaf, GtkWindowHandle, GtkWindowHandleLeaf, GtkAssistantPageFunc, GtkCellAllocCallback, GtkCellCallback, GtkCellLayoutDataFunc, GtkCustomFilterFunc, GtkDrawingAreaDrawFunc, GtkEntryCompletionMatchFunc, GtkExpressionNotify, GtkFlowBoxCreateWidgetFunc, GtkFlowBoxFilterFunc, GtkFlowBoxForeachFunc, GtkFlowBoxSortFunc, GtkFontFilterFunc, GtkIconViewForeachFunc, GtkListBoxCreateWidgetFunc, GtkListBoxFilterFunc, GtkListBoxForeachFunc, GtkListBoxSortFunc, GtkListBoxUpdateHeaderFunc, GtkMapListModelMapFunc, GtkMenuButtonCreatePopupFunc, GtkPageSetupDoneFunc, GtkPrintSettingsFunc, GtkPrinterFunc, GtkScaleFormatValueFunc, GtkShortcutFunc, GtkTextBufferCommitNotify, GtkTextCharPredicate, GtkTextTagTableForeach, GtkTickCallback, GtkTreeCellDataFunc, GtkTreeIterCompareFunc, GtkTreeListModelCreateModelFunc, GtkTreeModelFilterModifyFunc, GtkTreeModelFilterVisibleFunc, GtkTreeModelForeachFunc, GtkTreeSelectionForeachFunc, GtkTreeSelectionFunc, GtkTreeViewColumnDropFunc, GtkTreeViewMappingFunc, GtkTreeViewRowSeparatorFunc, GtkTreeViewSearchEqualFunc
end
