quote
$(Expr(:toplevel, quote
    mutable struct GBytes <: GBoxed
        handle::Ptr{GBytes}
        begin
            (GLib.g_type(::Type{T}) where T <: GBytes) = begin
                    ccall(("g_bytes_get_type", libgobject), GType, ())
                end
            function GBytes(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, GBytes)
        end
    end
    mutable struct GChecksum <: GBoxed
        handle::Ptr{GChecksum}
        begin
            (GLib.g_type(::Type{T}) where T <: GChecksum) = begin
                    ccall(("g_checksum_get_type", libgobject), GType, ())
                end
            function GChecksum(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, GChecksum)
        end
    end
    begin
        mutable struct GDate <: GBoxed
            handle::Ptr{GDate}
            begin
                (GLib.g_type(::Type{T}) where T <: GDate) = begin
                        ccall(("g_date_get_type", libgobject), GType, ())
                    end
                function GDate(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, GDate)
            end
        end
        const _GDate = GDate
    end
    mutable struct GDateTime <: GBoxed
        handle::Ptr{GDateTime}
        begin
            (GLib.g_type(::Type{T}) where T <: GDateTime) = begin
                    ccall(("g_date_time_get_type", libgobject), GType, ())
                end
            function GDateTime(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, GDateTime)
        end
    end
    begin
        struct _GDebugKey
            key::Cstring
            value::UInt32
        end
        mutable struct GDebugKey
            handle::Ptr{_GDebugKey}
        end
        unsafe_convert(::Type{Ptr{_GDebugKey}}, box::GDebugKey) = begin
                convert(Ptr{_GDebugKey}, box.handle)
            end
    end
    mutable struct GKeyFile <: GBoxed
        handle::Ptr{GKeyFile}
        begin
            (GLib.g_type(::Type{T}) where T <: GKeyFile) = begin
                    ccall(("g_key_file_get_type", libgobject), GType, ())
                end
            function GKeyFile(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, GKeyFile)
        end
    end
    begin
        struct _GLogField
            key::Cstring
            value::Ptr{Nothing}
            length::Int64
        end
        mutable struct GLogField
            handle::Ptr{_GLogField}
        end
        unsafe_convert(::Type{Ptr{_GLogField}}, box::GLogField) = begin
                convert(Ptr{_GLogField}, box.handle)
            end
    end
    mutable struct GMainContext <: GBoxed
        handle::Ptr{GMainContext}
        begin
            (GLib.g_type(::Type{T}) where T <: GMainContext) = begin
                    ccall(("g_main_context_get_type", libgobject), GType, ())
                end
            function GMainContext(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, GMainContext)
        end
    end
    mutable struct GMainLoop <: GBoxed
        handle::Ptr{GMainLoop}
        begin
            (GLib.g_type(::Type{T}) where T <: GMainLoop) = begin
                    ccall(("g_main_loop_get_type", libgobject), GType, ())
                end
            function GMainLoop(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, GMainLoop)
        end
    end
    mutable struct GMappedFile <: GBoxed
        handle::Ptr{GMappedFile}
        begin
            (GLib.g_type(::Type{T}) where T <: GMappedFile) = begin
                    ccall(("g_mapped_file_get_type", libgobject), GType, ())
                end
            function GMappedFile(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, GMappedFile)
        end
    end
    mutable struct GMarkupParseContext <: GBoxed
        handle::Ptr{GMarkupParseContext}
        begin
            (GLib.g_type(::Type{T}) where T <: GMarkupParseContext) = begin
                    ccall(("g_markup_parse_context_get_type", libgobject), GType, ())
                end
            function GMarkupParseContext(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, GMarkupParseContext)
        end
    end
    mutable struct GMatchInfo <: GBoxed
        handle::Ptr{GMatchInfo}
        begin
            (GLib.g_type(::Type{T}) where T <: GMatchInfo) = begin
                    ccall(("g_match_info_get_type", libgobject), GType, ())
                end
            function GMatchInfo(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, GMatchInfo)
        end
    end
    begin
        struct _GOptionEntry
            long_name::Cstring
            short_name::Int8
            flags::Int32
            arg::UInt32
            arg_data::Ptr{Nothing}
            description::Cstring
            arg_description::Cstring
        end
        mutable struct GOptionEntry
            handle::Ptr{_GOptionEntry}
        end
        unsafe_convert(::Type{Ptr{_GOptionEntry}}, box::GOptionEntry) = begin
                convert(Ptr{_GOptionEntry}, box.handle)
            end
    end
    mutable struct GRegex <: GBoxed
        handle::Ptr{GRegex}
        begin
            (GLib.g_type(::Type{T}) where T <: GRegex) = begin
                    ccall(("g_regex_get_type", libgobject), GType, ())
                end
            function GRegex(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, GRegex)
        end
    end
    begin
        struct _GScannerConfig
            cset_skip_characters::Cstring
            cset_identifier_first::Cstring
            cset_identifier_nth::Cstring
            cpair_comment_single::Cstring
            case_sensitive::UInt32
            skip_comment_multi::UInt32
            skip_comment_single::UInt32
            scan_comment_multi::UInt32
            scan_identifier::UInt32
            scan_identifier_1char::UInt32
            scan_identifier_NULL::UInt32
            scan_symbols::UInt32
            scan_binary::UInt32
            scan_octal::UInt32
            scan_float::UInt32
            scan_hex::UInt32
            scan_hex_dollar::UInt32
            scan_string_sq::UInt32
            scan_string_dq::UInt32
            numbers_2_int::UInt32
            int_2_float::UInt32
            identifier_2_string::UInt32
            char_2_token::UInt32
            symbol_2_token::UInt32
            scope_0_fallback::UInt32
            store_int64::UInt32
            padding_dummy::UInt32
        end
        mutable struct GScannerConfig
            handle::Ptr{_GScannerConfig}
        end
        unsafe_convert(::Type{Ptr{_GScannerConfig}}, box::GScannerConfig) = begin
                convert(Ptr{_GScannerConfig}, box.handle)
            end
    end
    begin
        mutable struct GSource <: GBoxed
            handle::Ptr{GSource}
            begin
                (GLib.g_type(::Type{T}) where T <: GSource) = begin
                        ccall(("g_source_get_type", libgobject), GType, ())
                    end
                function GSource(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, GSource)
            end
        end
        const _GSource = GSource
    end
    begin
        struct _GSourceCallbackFuncs
            ref::Ptr{Nothing}
            unref::Ptr{Nothing}
            get::Ptr{Nothing}
        end
        mutable struct GSourceCallbackFuncs
            handle::Ptr{_GSourceCallbackFuncs}
        end
        unsafe_convert(::Type{Ptr{_GSourceCallbackFuncs}}, box::GSourceCallbackFuncs) = begin
                convert(Ptr{_GSourceCallbackFuncs}, box.handle)
            end
    end
    begin
        struct _GString
            str::Cstring
            len::UInt64
            allocated_len::UInt64
        end
        mutable struct GString <: GBoxed
            handle::Ptr{_GString}
            begin
                (GLib.g_type(::Type{T}) where T <: GString) = begin
                        ccall(("g_gstring_get_type", libgobject), GType, ())
                    end
                function GString(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, GString)
            end
        end
        unsafe_convert(::Type{Ptr{_GString}}, box::GString) = begin
                convert(Ptr{_GString}, box.handle)
            end
    end
    begin
        struct _GTestConfig
            test_initialized::Cint
            test_quick::Cint
            test_perf::Cint
            test_verbose::Cint
            test_quiet::Cint
            test_undefined::Cint
        end
        mutable struct GTestConfig
            handle::Ptr{_GTestConfig}
        end
        unsafe_convert(::Type{Ptr{_GTestConfig}}, box::GTestConfig) = begin
                convert(Ptr{_GTestConfig}, box.handle)
            end
    end
    mutable struct GTimeZone <: GBoxed
        handle::Ptr{GTimeZone}
        begin
            (GLib.g_type(::Type{T}) where T <: GTimeZone) = begin
                    ccall(("g_time_zone_get_type", libgobject), GType, ())
                end
            function GTimeZone(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, GTimeZone)
        end
    end
    mutable struct GUri <: GBoxed
        handle::Ptr{GUri}
        begin
            (GLib.g_type(::Type{T}) where T <: GUri) = begin
                    ccall(("g_uri_get_type", libgobject), GType, ())
                end
            function GUri(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, GUri)
        end
    end
    mutable struct GVariantBuilder <: GBoxed
        handle::Ptr{GVariantBuilder}
        begin
            (GLib.g_type(::Type{T}) where T <: GVariantBuilder) = begin
                    ccall(("g_variant_builder_get_type", libgobject), GType, ())
                end
            function GVariantBuilder(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, GVariantBuilder)
        end
    end
    mutable struct GVariantDict <: GBoxed
        handle::Ptr{GVariantDict}
        begin
            (GLib.g_type(::Type{T}) where T <: GVariantDict) = begin
                    ccall(("g_variant_dict_get_type", libgobject), GType, ())
                end
            function GVariantDict(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, GVariantDict)
        end
    end
    mutable struct GVariantType <: GBoxed
        handle::Ptr{GVariantType}
        begin
            (GLib.g_type(::Type{T}) where T <: GVariantType) = begin
                    ccall(("g_variant_type_get_gtype", libgobject), GType, ())
                end
            function GVariantType(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, GVariantType)
        end
    end
    begin
        gboxed_cache_init() = begin
                append!(GLib.gboxed_types, gboxed_types)
            end
    end
    export GBytes, GChecksum, GDate, _GDate, GDateTime, GDebugKey, _GDebugKey, GKeyFile, GLogField, _GLogField, GMainContext, GMainLoop, GMappedFile, GMarkupParseContext, GMatchInfo, GOptionEntry, _GOptionEntry, GRegex, GScannerConfig, _GScannerConfig, GSource, _GSource, GSourceCallbackFuncs, _GSourceCallbackFuncs, GString, _GString, GTestConfig, _GTestConfig, GTimeZone, GUri, GVariantBuilder, GVariantDict, GVariantType
end))
end
