quote
$(Expr(:toplevel, quote
    begin
        struct _GEnumValue
            value::Int32
            value_name::Cstring
            value_nick::Cstring
        end
        mutable struct GEnumValue
            handle::Ptr{_GEnumValue}
        end
        begin
            unsafe_convert(::Type{Ptr{_GEnumValue}}, box::GEnumValue) = begin
                    convert(Ptr{_GEnumValue}, box.handle)
                end
            convert(::Type{GEnumValue}, p::Ptr{_GEnumValue}, owns = false) = begin
                    GEnumValue(p, owns)
                end
            const GEnumValueLike = Union{Ref{_GEnumValue}, GEnumValue}
        end
    end
    begin
        struct _GTypeClass
            g_type::UInt64
        end
        mutable struct GTypeClass
            handle::Ptr{_GTypeClass}
        end
        begin
            unsafe_convert(::Type{Ptr{_GTypeClass}}, box::GTypeClass) = begin
                    convert(Ptr{_GTypeClass}, box.handle)
                end
            convert(::Type{GTypeClass}, p::Ptr{_GTypeClass}, owns = false) = begin
                    GTypeClass(p, owns)
                end
            const GTypeClassLike = Union{Ref{_GTypeClass}, GTypeClass}
        end
    end
    begin
        struct _GTypeInterface
            g_type::UInt64
            g_instance_type::UInt64
        end
        mutable struct GTypeInterface
            handle::Ptr{_GTypeInterface}
        end
        begin
            unsafe_convert(::Type{Ptr{_GTypeInterface}}, box::GTypeInterface) = begin
                    convert(Ptr{_GTypeInterface}, box.handle)
                end
            convert(::Type{GTypeInterface}, p::Ptr{_GTypeInterface}, owns = false) = begin
                    GTypeInterface(p, owns)
                end
            const GTypeInterfaceLike = Union{Ref{_GTypeInterface}, GTypeInterface}
        end
    end
    begin
        struct _GFlagsValue
            value::UInt32
            value_name::Cstring
            value_nick::Cstring
        end
        mutable struct GFlagsValue
            handle::Ptr{_GFlagsValue}
        end
        begin
            unsafe_convert(::Type{Ptr{_GFlagsValue}}, box::GFlagsValue) = begin
                    convert(Ptr{_GFlagsValue}, box.handle)
                end
            convert(::Type{GFlagsValue}, p::Ptr{_GFlagsValue}, owns = false) = begin
                    GFlagsValue(p, owns)
                end
            const GFlagsValueLike = Union{Ref{_GFlagsValue}, GFlagsValue}
        end
    end
    begin
        struct _GTypeValueTable
            value_init::Ptr{Cvoid}
            value_free::Ptr{Cvoid}
            value_copy::Ptr{Cvoid}
            value_peek_pointer::Ptr{Cvoid}
            collect_format::Cstring
            collect_value::Ptr{Cvoid}
            lcopy_format::Cstring
            lcopy_value::Ptr{Cvoid}
        end
        mutable struct GTypeValueTable
            handle::Ptr{_GTypeValueTable}
        end
        begin
            unsafe_convert(::Type{Ptr{_GTypeValueTable}}, box::GTypeValueTable) = begin
                    convert(Ptr{_GTypeValueTable}, box.handle)
                end
            convert(::Type{GTypeValueTable}, p::Ptr{_GTypeValueTable}, owns = false) = begin
                    GTypeValueTable(p, owns)
                end
            const GTypeValueTableLike = Union{Ref{_GTypeValueTable}, GTypeValueTable}
        end
    end
    begin
        struct _GEnumClass
            g_type_class::_GTypeClass
            minimum::Int32
            maximum::Int32
            n_values::UInt32
            values::Ptr{_GEnumValue}
        end
        mutable struct GEnumClass
            handle::Ptr{_GEnumClass}
        end
        begin
            unsafe_convert(::Type{Ptr{_GEnumClass}}, box::GEnumClass) = begin
                    convert(Ptr{_GEnumClass}, box.handle)
                end
            convert(::Type{GEnumClass}, p::Ptr{_GEnumClass}, owns = false) = begin
                    GEnumClass(p, owns)
                end
            const GEnumClassLike = Union{Ref{_GEnumClass}, GEnumClass}
        end
    end
    begin
        struct _GFlagsClass
            g_type_class::_GTypeClass
            mask::UInt32
            n_values::UInt32
            values::Ptr{_GFlagsValue}
        end
        mutable struct GFlagsClass
            handle::Ptr{_GFlagsClass}
        end
        begin
            unsafe_convert(::Type{Ptr{_GFlagsClass}}, box::GFlagsClass) = begin
                    convert(Ptr{_GFlagsClass}, box.handle)
                end
            convert(::Type{GFlagsClass}, p::Ptr{_GFlagsClass}, owns = false) = begin
                    GFlagsClass(p, owns)
                end
            const GFlagsClassLike = Union{Ref{_GFlagsClass}, GFlagsClass}
        end
    end
    begin
        struct _GInterfaceInfo
            interface_init::Ptr{Cvoid}
            interface_finalize::Ptr{Cvoid}
            interface_data::Ptr{Nothing}
        end
        mutable struct GInterfaceInfo
            handle::Ptr{_GInterfaceInfo}
        end
        begin
            unsafe_convert(::Type{Ptr{_GInterfaceInfo}}, box::GInterfaceInfo) = begin
                    convert(Ptr{_GInterfaceInfo}, box.handle)
                end
            convert(::Type{GInterfaceInfo}, p::Ptr{_GInterfaceInfo}, owns = false) = begin
                    GInterfaceInfo(p, owns)
                end
            const GInterfaceInfoLike = Union{Ref{_GInterfaceInfo}, GInterfaceInfo}
        end
    end
    begin
        struct _GParamSpecTypeInfo
            instance_size::UInt16
            n_preallocs::UInt16
            instance_init::Ptr{Cvoid}
            value_type::UInt64
            finalize::Ptr{Cvoid}
            value_set_default::Ptr{Cvoid}
            value_validate::Ptr{Cvoid}
            values_cmp::Ptr{Cvoid}
        end
        mutable struct GParamSpecTypeInfo
            handle::Ptr{_GParamSpecTypeInfo}
        end
        begin
            unsafe_convert(::Type{Ptr{_GParamSpecTypeInfo}}, box::GParamSpecTypeInfo) = begin
                    convert(Ptr{_GParamSpecTypeInfo}, box.handle)
                end
            convert(::Type{GParamSpecTypeInfo}, p::Ptr{_GParamSpecTypeInfo}, owns = false) = begin
                    GParamSpecTypeInfo(p, owns)
                end
            const GParamSpecTypeInfoLike = Union{Ref{_GParamSpecTypeInfo}, GParamSpecTypeInfo}
        end
    end
    begin
        struct _GSignalInvocationHint
            signal_id::UInt32
            detail::UInt32
            run_type::UInt32
        end
        mutable struct GSignalInvocationHint
            handle::Ptr{_GSignalInvocationHint}
        end
        begin
            unsafe_convert(::Type{Ptr{_GSignalInvocationHint}}, box::GSignalInvocationHint) = begin
                    convert(Ptr{_GSignalInvocationHint}, box.handle)
                end
            convert(::Type{GSignalInvocationHint}, p::Ptr{_GSignalInvocationHint}, owns = false) = begin
                    GSignalInvocationHint(p, owns)
                end
            const GSignalInvocationHintLike = Union{Ref{_GSignalInvocationHint}, GSignalInvocationHint}
        end
    end
    begin
        struct _GSignalQuery
            signal_id::UInt32
            signal_name::Cstring
            itype::UInt64
            signal_flags::UInt32
            return_type::UInt64
            n_params::UInt32
            param_types::Ptr{UInt64}
        end
        mutable struct GSignalQuery
            handle::Ptr{_GSignalQuery}
        end
        begin
            unsafe_convert(::Type{Ptr{_GSignalQuery}}, box::GSignalQuery) = begin
                    convert(Ptr{_GSignalQuery}, box.handle)
                end
            convert(::Type{GSignalQuery}, p::Ptr{_GSignalQuery}, owns = false) = begin
                    GSignalQuery(p, owns)
                end
            const GSignalQueryLike = Union{Ref{_GSignalQuery}, GSignalQuery}
        end
    end
    begin
        struct _GTypeFundamentalInfo
            type_flags::UInt32
        end
        mutable struct GTypeFundamentalInfo
            handle::Ptr{_GTypeFundamentalInfo}
        end
        begin
            unsafe_convert(::Type{Ptr{_GTypeFundamentalInfo}}, box::GTypeFundamentalInfo) = begin
                    convert(Ptr{_GTypeFundamentalInfo}, box.handle)
                end
            convert(::Type{GTypeFundamentalInfo}, p::Ptr{_GTypeFundamentalInfo}, owns = false) = begin
                    GTypeFundamentalInfo(p, owns)
                end
            const GTypeFundamentalInfoLike = Union{Ref{_GTypeFundamentalInfo}, GTypeFundamentalInfo}
        end
    end
    begin
        struct _GTypeInfo
            class_size::UInt16
            base_init::Ptr{Cvoid}
            base_finalize::Ptr{Cvoid}
            class_init::Ptr{Cvoid}
            class_finalize::Ptr{Cvoid}
            class_data::Ptr{Nothing}
            instance_size::UInt16
            n_preallocs::UInt16
            instance_init::Ptr{Cvoid}
            value_table::Ptr{_GTypeValueTable}
        end
        mutable struct GTypeInfo
            handle::Ptr{_GTypeInfo}
        end
        begin
            unsafe_convert(::Type{Ptr{_GTypeInfo}}, box::GTypeInfo) = begin
                    convert(Ptr{_GTypeInfo}, box.handle)
                end
            convert(::Type{GTypeInfo}, p::Ptr{_GTypeInfo}, owns = false) = begin
                    GTypeInfo(p, owns)
                end
            const GTypeInfoLike = Union{Ref{_GTypeInfo}, GTypeInfo}
        end
    end
    begin
        struct _GTypePluginClass
            base_iface::_GTypeInterface
            use_plugin::Ptr{Cvoid}
            unuse_plugin::Ptr{Cvoid}
            complete_type_info::Ptr{Cvoid}
            complete_interface_info::Ptr{Cvoid}
        end
        mutable struct GTypePluginClass
            handle::Ptr{_GTypePluginClass}
        end
        begin
            unsafe_convert(::Type{Ptr{_GTypePluginClass}}, box::GTypePluginClass) = begin
                    convert(Ptr{_GTypePluginClass}, box.handle)
                end
            convert(::Type{GTypePluginClass}, p::Ptr{_GTypePluginClass}, owns = false) = begin
                    GTypePluginClass(p, owns)
                end
            const GTypePluginClassLike = Union{Ref{_GTypePluginClass}, GTypePluginClass}
        end
    end
    begin
        struct _GTypeQuery
            type::UInt64
            type_name::Cstring
            class_size::UInt32
            instance_size::UInt32
        end
        mutable struct GTypeQuery
            handle::Ptr{_GTypeQuery}
        end
        begin
            unsafe_convert(::Type{Ptr{_GTypeQuery}}, box::GTypeQuery) = begin
                    convert(Ptr{_GTypeQuery}, box.handle)
                end
            convert(::Type{GTypeQuery}, p::Ptr{_GTypeQuery}, owns = false) = begin
                    GTypeQuery(p, owns)
                end
            const GTypeQueryLike = Union{Ref{_GTypeQuery}, GTypeQuery}
        end
    end
    begin
        struct _GValueArray
            n_values::UInt32
            values::Ptr{_GValue}
            n_prealloced::UInt32
        end
        mutable struct GValueArray <: GBoxed
            handle::Ptr{_GValueArray}
            begin
                (GLib.g_type(::Type{T}) where T <: GValueArray) = begin
                        ccall(("g_value_array_get_type", libgobject), GType, ())
                    end
                function GValueArray(ref::Ptr{T}, own::Bool = false) where T <: Union{GBoxed, _GValueArray}
                    x = new(ref)
                    if own
                        finalizer(x) do x
                            GLib.delboxed(x)
                        end
                    end
                    x
                end
                push!(gboxed_types, GValueArray)
            end
        end
        begin
            unsafe_convert(::Type{Ptr{_GValueArray}}, box::GValueArray) = begin
                    convert(Ptr{_GValueArray}, box.handle)
                end
            convert(::Type{GValueArray}, p::Ptr{_GValueArray}, owns = false) = begin
                    GValueArray(p, owns)
                end
            const GValueArrayLike = Union{Ref{_GValueArray}, GValueArray}
        end
    end
    @doc "See the [GTK docs](https://docs.gtk.org/gobject/struct.EnumClass.html)." GEnumClass
    @doc "See the [GTK docs](https://docs.gtk.org/gobject/struct.FlagsClass.html)." GFlagsClass
    @doc "See the [GTK docs](https://docs.gtk.org/gobject/struct.InterfaceInfo.html)." GInterfaceInfo
    @doc "See the [GTK docs](https://docs.gtk.org/gobject/struct.ParamSpecTypeInfo.html)." GParamSpecTypeInfo
    @doc "See the [GTK docs](https://docs.gtk.org/gobject/struct.SignalInvocationHint.html)." GSignalInvocationHint
    @doc "See the [GTK docs](https://docs.gtk.org/gobject/struct.SignalQuery.html)." GSignalQuery
    @doc "See the [GTK docs](https://docs.gtk.org/gobject/struct.TypeFundamentalInfo.html)." GTypeFundamentalInfo
    @doc "See the [GTK docs](https://docs.gtk.org/gobject/struct.TypeInfo.html)." GTypeInfo
    @doc "See the [GTK docs](https://docs.gtk.org/gobject/struct.TypePluginClass.html)." GTypePluginClass
    @doc "See the [GTK docs](https://docs.gtk.org/gobject/struct.TypeQuery.html)." GTypeQuery
    @doc "See the [GTK docs](https://docs.gtk.org/gobject/struct.ValueArray.html)." GValueArray
    struct GTypePlugin <: GInterface
        handle::Ptr{GObject}
        gc::Any
        GTypePlugin(x::GObject) = begin
                new(unsafe_convert(Ptr{GObject}, x), x)
            end
    end
    const gtype_wrapper_cache = Dict{Symbol, Type}()
    begin
        abstract type GBinding <: GObject end
        mutable struct GBindingLeaf <: GBinding
            handle::Ptr{GObject}
            function GBindingLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GBindingLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        gtype_wrapper_cache[:GBinding] = GBindingLeaf
        (GLib.g_type(::Type{T}) where T <: GBinding) = begin
                ccall(("g_binding_get_type", libgobject), GType, ())
            end
    end
    begin
        function GLib.signalnames(::Type{GBinding})
            signalnames(supertype(GBinding))
        end
    end
    begin
        abstract type GInitiallyUnowned <: GObject end
        mutable struct GInitiallyUnownedLeaf <: GInitiallyUnowned
            handle::Ptr{GObject}
            function GInitiallyUnownedLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GInitiallyUnownedLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        gtype_wrapper_cache[:GInitiallyUnowned] = GInitiallyUnownedLeaf
        (GLib.g_type(::Type{T}) where T <: GInitiallyUnowned) = begin
                ccall(("g_initially_unowned_get_type", libgobject), GType, ())
            end
    end
    begin
        function GLib.signalnames(::Type{GInitiallyUnowned})
            signalnames(supertype(GInitiallyUnowned))
        end
    end
    begin
        abstract type GTypeModule <: GObject end
        mutable struct GTypeModuleLeaf <: GTypeModule
            handle::Ptr{GObject}
            function GTypeModuleLeaf(handle::Ptr{GObject}, owns = false)
                if handle == C_NULL
                    error("Cannot construct GTypeModuleLeaf with a NULL pointer")
                end
                GLib.gobject_maybe_sink(handle, owns)
                return gobject_ref(new(handle))
            end
        end
        gtype_wrapper_cache[:GTypeModule] = GTypeModuleLeaf
        (GLib.g_type(::Type{T}) where T <: GTypeModule) = begin
                ccall(("g_type_module_get_type", libgobject), GType, ())
            end
    end
    begin
        function GLib.signalnames(::Type{GTypeModule})
            signalnames(supertype(GTypeModule))
        end
    end
    begin
        gtype_wrapper_cache_init() = begin
                merge!(GLib.gtype_wrappers, gtype_wrapper_cache)
            end
    end
    @doc "See the [GTK docs](https://docs.gtk.org/gobject/class.Binding.html)." GBinding
    @doc "See the [GTK docs](https://docs.gtk.org/gobject/class.InitiallyUnowned.html)." GInitiallyUnowned
    @doc "See the [GTK docs](https://docs.gtk.org/gobject/class.TypeModule.html)." GTypeModule
    gtype_wrapper_cache[:GObject] = GObjectLeaf
    function GBindingTransformFunc(binding, from_value, to_value, user_data)
        binding = convert(GBinding, binding, false)
        from_value = convert(GValueLike, from_value, false)
        to_value = convert(GValueLike, to_value, false)
        f = user_data
        ret = f(binding, from_value, to_value)
        convert(Cint, ret)
    end
    function GClassFinalizeFunc(g_class, class_data)
        g_class = convert(GTypeClassLike, g_class)
        f = class_data
        ret = f(g_class)
        nothing
    end
    function GClassInitFunc(g_class, class_data)
        g_class = convert(GTypeClassLike, g_class)
        f = class_data
        ret = f(g_class)
        nothing
    end
    function GClosureMarshal(closure, return_value, n_param_values, param_values, invocation_hint, marshal_data)
        closure = convert(GClosureLike, closure, false)
        return_value = convert_if_not_null(GValueLike, return_value, false)
        param_values = collect(unsafe_wrap(Vector{_GValue}, param_values, m_n_param_values[]))
        invocation_hint = convert(Maybe(Nothing), invocation_hint)
        f = marshal_data
        ret = f(closure, return_value, n_param_values, param_values, invocation_hint)
        nothing
    end
    function GInterfaceFinalizeFunc(g_iface, iface_data)
        g_iface = convert(GTypeInterfaceLike, g_iface)
        f = iface_data
        ret = f(g_iface)
        nothing
    end
    function GInterfaceInitFunc(g_iface, iface_data)
        g_iface = convert(GTypeInterfaceLike, g_iface)
        f = iface_data
        ret = f(g_iface)
        nothing
    end
    function GSignalAccumulator(ihint, return_accu, handler_return, data)
        ihint = convert(GSignalInvocationHintLike, ihint)
        return_accu = convert(GValueLike, return_accu, false)
        handler_return = convert(GValueLike, handler_return, false)
        f = data
        ret = f(ihint, return_accu, handler_return)
        convert(Cint, ret)
    end
    function GSignalEmissionHook(ihint, n_param_values, param_values, data)
        ihint = convert(GSignalInvocationHintLike, ihint)
        param_values = collect(unsafe_wrap(Vector{_GValue}, param_values, m_n_param_values[]))
        f = data
        ret = f(ihint, n_param_values, param_values)
        convert(Cint, ret)
    end
    export GEnumValue, _GEnumValue, GEnumValueLike, GTypeClass, _GTypeClass, GTypeClassLike, GTypeInterface, _GTypeInterface, GTypeInterfaceLike, GFlagsValue, _GFlagsValue, GFlagsValueLike, GTypeValueTable, _GTypeValueTable, GTypeValueTableLike, GEnumClass, GEnumClassLike, _GEnumClass, GFlagsClass, GFlagsClassLike, _GFlagsClass, GInterfaceInfo, GInterfaceInfoLike, _GInterfaceInfo, GParamSpecTypeInfo, GParamSpecTypeInfoLike, _GParamSpecTypeInfo, GSignalInvocationHint, GSignalInvocationHintLike, _GSignalInvocationHint, GSignalQuery, GSignalQueryLike, _GSignalQuery, GTypeFundamentalInfo, GTypeFundamentalInfoLike, _GTypeFundamentalInfo, GTypeInfo, GTypeInfoLike, _GTypeInfo, GTypePluginClass, GTypePluginClassLike, _GTypePluginClass, GTypeQuery, GTypeQueryLike, _GTypeQuery, GValueArray, GValueArrayLike, _GValueArray, GTypePlugin, GBinding, GBindingLeaf, GInitiallyUnowned, GInitiallyUnownedLeaf, GTypeModule, GBindingTransformFunc, GClassFinalizeFunc, GClassInitFunc, GClosureMarshal, GInterfaceFinalizeFunc, GInterfaceInitFunc, GSignalAccumulator, GSignalEmissionHook
end))
end
