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 GPatternSpec <: GBoxed
        handle::Ptr{GPatternSpec}
        begin
            (GLib.g_type(::Type{T}) where T <: GPatternSpec) = begin
                    ccall(("g_pattern_spec_get_type", libgobject), GType, ())
                end
            function GPatternSpec(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, GPatternSpec)
        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
    @doc "A simple refcounted data type representing an immutable sequence of zero or\nmore bytes from an unspecified origin.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/glib/struct.Bytes.html)." GBytes
    @doc "An opaque structure representing a checksumming operation.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/glib/struct.Checksum.html)." GChecksum
    @doc "Represents a day between January 1, Year 1 and a few thousand years in\nthe future. None of its members should be accessed directly.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/glib/struct.Date.html)." GDate
    @doc "An opaque structure that represents a date and time, including a time zone.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/glib/struct.DateTime.html)." GDateTime
    @doc "Associates a string with a bit flag.\nUsed in g_parse_debug_string().\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/glib/struct.DebugKey.html)." GDebugKey
    @doc "The GKeyFile struct contains only private data\nand should not be accessed directly.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/glib/struct.KeyFile.html)." GKeyFile
    @doc "Structure representing a single field in a structured log entry. See\ng_log_structured() for details.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/glib/struct.LogField.html)." GLogField
    @doc "The `GMainContext` struct is an opaque data\ntype representing a set of sources to be handled in a main loop.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/glib/struct.MainContext.html)." GMainContext
    @doc "The `GMainLoop` struct is an opaque data type\nrepresenting the main event loop of a GLib or GTK+ application.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/glib/struct.MainLoop.html)." GMainLoop
    @doc "The #GMappedFile represents a file mapping created with\ng_mapped_file_new(). It has only private members and should\nnot be accessed directly.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/glib/struct.MappedFile.html)." GMappedFile
    @doc "A parse context is used to parse a stream of bytes that\nyou expect to contain marked-up text.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/glib/struct.MarkupParseContext.html)." GMarkupParseContext
    @doc "A GMatchInfo is an opaque struct used to return information about\nmatches.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/glib/struct.MatchInfo.html)." GMatchInfo
    @doc "A GOptionEntry struct defines a single option. To have an effect, they\nmust be added to a #GOptionGroup with g_option_context_add_main_entries()\nor g_option_group_add_entries().\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/glib/struct.OptionEntry.html)." GOptionEntry
    @doc "A GPatternSpec struct is the 'compiled' form of a pattern. This\nstructure is opaque and its fields cannot be accessed directly.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/glib/struct.PatternSpec.html)." GPatternSpec
    @doc "The g_regex_*() functions implement regular\nexpression pattern matching using syntax and semantics similar to\nPerl regular expression.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/glib/struct.Regex.html)." GRegex
    @doc "Specifies the #GScanner parser configuration. Most settings can\nbe changed during the parsing phase and will affect the lexical\nparsing of the next unpeeked token.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/glib/struct.ScannerConfig.html)." GScannerConfig
    @doc "The `GSource` struct is an opaque data type\nrepresenting an event source.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/glib/struct.Source.html)." GSource
    @doc "The `GSourceCallbackFuncs` struct contains\nfunctions for managing callback objects.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/glib/struct.SourceCallbackFuncs.html)." GSourceCallbackFuncs
    @doc "The GString struct contains the public fields of a GString.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/glib/struct.String.html)." GString
    @doc "#GTimeZone is an opaque structure whose members cannot be accessed\ndirectly.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/glib/struct.TimeZone.html)." GTimeZone
    @doc "The #GUri type and related functions can be used to parse URIs into\ntheir components, and build valid URIs from individual components.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/glib/struct.Uri.html)." GUri
    @doc "A utility type for constructing container-type #GVariant instances.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/glib/struct.VariantBuilder.html)." GVariantBuilder
    @doc "#GVariantDict is a mutable interface to #GVariant dictionaries.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/glib/struct.VariantDict.html)." GVariantDict
    @doc "This section introduces the GVariant type system. It is based, in\nlarge part, on the D-Bus type system, with two major changes and\nsome minor lifting of restrictions. The\n[D-Bus specification](http://dbus.freedesktop.org/doc/dbus-specification.html),\ntherefore, provides a significant amount of\ninformation that is useful when working with GVariant.\n \nDetails can be found in the [GTK docs](https://docs.gtk.org/glib/struct.VariantType.html)." GVariantType
    export GBytes, GChecksum, GDate, _GDate, GDateTime, GDebugKey, _GDebugKey, GKeyFile, GLogField, _GLogField, GMainContext, GMainLoop, GMappedFile, GMarkupParseContext, GMatchInfo, GOptionEntry, _GOptionEntry, GPatternSpec, GRegex, GScannerConfig, _GScannerConfig, GSource, _GSource, GSourceCallbackFuncs, _GSourceCallbackFuncs, GString, _GString, GTestConfig, _GTestConfig, GTimeZone, GUri, GVariantBuilder, GVariantDict, GVariantType
end))
end
