begin
    mutable struct GBookmarkFile <: GBoxed
        handle::Ptr{GBookmarkFile}
        (GLib.g_type(::Type{T}) where T <: GBookmarkFile) = ccall(("g_bookmark_file_get_type", libgobject), GType, ())
        function GBookmarkFile(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, GBookmarkFile)
    end
    const GBookmarkFileLike = GBookmarkFile
    mutable struct GBytes <: GBoxed
        handle::Ptr{GBytes}
        (GLib.g_type(::Type{T}) where T <: GBytes) = ccall(("g_bytes_get_type", libgobject), GType, ())
        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
    const GBytesLike = GBytes
    mutable struct GChecksum <: GBoxed
        handle::Ptr{GChecksum}
        (GLib.g_type(::Type{T}) where T <: GChecksum) = ccall(("g_checksum_get_type", libgobject), GType, ())
        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
    const GChecksumLike = GChecksum
    mutable struct GDate <: GBoxed
        handle::Ptr{GDate}
        (GLib.g_type(::Type{T}) where T <: GDate) = ccall(("g_date_get_type", libgobject), GType, ())
        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
    const GDateLike = GDate
    const _GDate = GDate
    mutable struct GDateTime <: GBoxed
        handle::Ptr{GDateTime}
        (GLib.g_type(::Type{T}) where T <: GDateTime) = ccall(("g_date_time_get_type", libgobject), GType, ())
        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
    const GDateTimeLike = GDateTime
    struct _GDebugKey
        key::Cstring
        value::UInt32
    end
    mutable struct GDebugKey
        handle::Ptr{_GDebugKey}
    end
    unsafe_convert(::Type{Ptr{_GDebugKey}}, box::GDebugKey) = convert(Ptr{_GDebugKey}, box.handle)
    convert(::Type{GDebugKey}, p::Ptr{_GDebugKey}, owns = false) = GDebugKey(p, owns)
    const GDebugKeyLike = Union{Ref{_GDebugKey}, GDebugKey}
    convert(::Type{GDebugKeyLike}, p, owns) = convert(GDebugKey, p, owns)
    mutable struct GDir <: GBoxed
        handle::Ptr{GDir}
        (GLib.g_type(::Type{T}) where T <: GDir) = ccall(("g_dir_get_type", libgobject), GType, ())
        function GDir(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, GDir)
    end
    const GDirLike = GDir
    mutable struct GHmac <: GBoxed
        handle::Ptr{GHmac}
        (GLib.g_type(::Type{T}) where T <: GHmac) = ccall(("g_hmac_get_type", libgobject), GType, ())
        function GHmac(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, GHmac)
    end
    const GHmacLike = GHmac
    mutable struct GKeyFile <: GBoxed
        handle::Ptr{GKeyFile}
        (GLib.g_type(::Type{T}) where T <: GKeyFile) = ccall(("g_key_file_get_type", libgobject), GType, ())
        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
    const GKeyFileLike = GKeyFile
    struct _GLogField
        key::Cstring
        value::Ptr{Nothing}
        length::Int64
    end
    mutable struct GLogField
        handle::Ptr{_GLogField}
    end
    unsafe_convert(::Type{Ptr{_GLogField}}, box::GLogField) = convert(Ptr{_GLogField}, box.handle)
    convert(::Type{GLogField}, p::Ptr{_GLogField}, owns = false) = GLogField(p, owns)
    const GLogFieldLike = Union{Ref{_GLogField}, GLogField}
    convert(::Type{GLogFieldLike}, p, owns) = convert(GLogField, p, owns)
    mutable struct GMainContext <: GBoxed
        handle::Ptr{GMainContext}
        (GLib.g_type(::Type{T}) where T <: GMainContext) = ccall(("g_main_context_get_type", libgobject), GType, ())
        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
    const GMainContextLike = GMainContext
    mutable struct GMainLoop <: GBoxed
        handle::Ptr{GMainLoop}
        (GLib.g_type(::Type{T}) where T <: GMainLoop) = ccall(("g_main_loop_get_type", libgobject), GType, ())
        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
    const GMainLoopLike = GMainLoop
    mutable struct GMappedFile <: GBoxed
        handle::Ptr{GMappedFile}
        (GLib.g_type(::Type{T}) where T <: GMappedFile) = ccall(("g_mapped_file_get_type", libgobject), GType, ())
        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
    const GMappedFileLike = GMappedFile
    mutable struct GMarkupParseContext <: GBoxed
        handle::Ptr{GMarkupParseContext}
        (GLib.g_type(::Type{T}) where T <: GMarkupParseContext) = ccall(("g_markup_parse_context_get_type", libgobject), GType, ())
        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
    const GMarkupParseContextLike = GMarkupParseContext
    mutable struct GMatchInfo <: GBoxed
        handle::Ptr{GMatchInfo}
        (GLib.g_type(::Type{T}) where T <: GMatchInfo) = ccall(("g_match_info_get_type", libgobject), GType, ())
        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
    const GMatchInfoLike = GMatchInfo
    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) = convert(Ptr{_GOptionEntry}, box.handle)
    convert(::Type{GOptionEntry}, p::Ptr{_GOptionEntry}, owns = false) = GOptionEntry(p, owns)
    const GOptionEntryLike = Union{Ref{_GOptionEntry}, GOptionEntry}
    convert(::Type{GOptionEntryLike}, p, owns) = convert(GOptionEntry, p, owns)
    mutable struct GPatternSpec <: GBoxed
        handle::Ptr{GPatternSpec}
        (GLib.g_type(::Type{T}) where T <: GPatternSpec) = ccall(("g_pattern_spec_get_type", libgobject), GType, ())
        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
    const GPatternSpecLike = GPatternSpec
    mutable struct GRand <: GBoxed
        handle::Ptr{GRand}
        (GLib.g_type(::Type{T}) where T <: GRand) = ccall(("g_rand_get_type", libgobject), GType, ())
        function GRand(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, GRand)
    end
    const GRandLike = GRand
    mutable struct GRegex <: GBoxed
        handle::Ptr{GRegex}
        (GLib.g_type(::Type{T}) where T <: GRegex) = ccall(("g_regex_get_type", libgobject), GType, ())
        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
    const GRegexLike = GRegex
    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) = convert(Ptr{_GScannerConfig}, box.handle)
    convert(::Type{GScannerConfig}, p::Ptr{_GScannerConfig}, owns = false) = GScannerConfig(p, owns)
    const GScannerConfigLike = Union{Ref{_GScannerConfig}, GScannerConfig}
    convert(::Type{GScannerConfigLike}, p, owns) = convert(GScannerConfig, p, owns)
    mutable struct GSource <: GBoxed
        handle::Ptr{GSource}
        (GLib.g_type(::Type{T}) where T <: GSource) = ccall(("g_source_get_type", libgobject), GType, ())
        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
    const GSourceLike = GSource
    const _GSource = GSource
    struct _GSourceCallbackFuncs
        ref::Ptr{Cvoid}
        unref::Ptr{Cvoid}
        get::Ptr{Nothing}
    end
    mutable struct GSourceCallbackFuncs
        handle::Ptr{_GSourceCallbackFuncs}
    end
    unsafe_convert(::Type{Ptr{_GSourceCallbackFuncs}}, box::GSourceCallbackFuncs) = convert(Ptr{_GSourceCallbackFuncs}, box.handle)
    convert(::Type{GSourceCallbackFuncs}, p::Ptr{_GSourceCallbackFuncs}, owns = false) = GSourceCallbackFuncs(p, owns)
    const GSourceCallbackFuncsLike = Union{Ref{_GSourceCallbackFuncs}, GSourceCallbackFuncs}
    convert(::Type{GSourceCallbackFuncsLike}, p, owns) = convert(GSourceCallbackFuncs, p, owns)
    struct _GString
        str::Cstring
        len::UInt64
        allocated_len::UInt64
    end
    mutable struct GString <: GBoxed
        handle::Ptr{_GString}
        (GLib.g_type(::Type{T}) where T <: GString) = ccall(("g_gstring_get_type", libgobject), GType, ())
        function GString(ref::Ptr{T}, own::Bool = false) where T <: Union{GBoxed, _GString}
            x = new(ref)
            if own
                finalizer(x) do x
                    GLib.delboxed
                    x
                end
            end
            x
        end
        push!(gboxed_types, GString)
    end
    unsafe_convert(::Type{Ptr{_GString}}, box::GString) = convert(Ptr{_GString}, box.handle)
    convert(::Type{GString}, p::Ptr{_GString}, owns = false) = GString(p, owns)
    const GStringLike = Union{Ref{_GString}, GString}
    convert(::Type{GStringLike}, p, owns) = convert(GString, p, owns)
    mutable struct GStrvBuilder <: GBoxed
        handle::Ptr{GStrvBuilder}
        (GLib.g_type(::Type{T}) where T <: GStrvBuilder) = ccall(("g_strv_builder_get_type", libgobject), GType, ())
        function GStrvBuilder(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, GStrvBuilder)
    end
    const GStrvBuilderLike = GStrvBuilder
    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) = convert(Ptr{_GTestConfig}, box.handle)
    convert(::Type{GTestConfig}, p::Ptr{_GTestConfig}, owns = false) = GTestConfig(p, owns)
    const GTestConfigLike = Union{Ref{_GTestConfig}, GTestConfig}
    convert(::Type{GTestConfigLike}, p, owns) = convert(GTestConfig, p, owns)
    mutable struct GTimeZone <: GBoxed
        handle::Ptr{GTimeZone}
        (GLib.g_type(::Type{T}) where T <: GTimeZone) = ccall(("g_time_zone_get_type", libgobject), GType, ())
        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
    const GTimeZoneLike = GTimeZone
    struct _GUnixPipe
        fds::Ptr{Int32}
    end
    mutable struct GUnixPipe
        handle::Ptr{_GUnixPipe}
    end
    unsafe_convert(::Type{Ptr{_GUnixPipe}}, box::GUnixPipe) = convert(Ptr{_GUnixPipe}, box.handle)
    convert(::Type{GUnixPipe}, p::Ptr{_GUnixPipe}, owns = false) = GUnixPipe(p, owns)
    const GUnixPipeLike = Union{Ref{_GUnixPipe}, GUnixPipe}
    convert(::Type{GUnixPipeLike}, p, owns) = convert(GUnixPipe, p, owns)
    mutable struct GUri <: GBoxed
        handle::Ptr{GUri}
        (GLib.g_type(::Type{T}) where T <: GUri) = ccall(("g_uri_get_type", libgobject), GType, ())
        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
    const GUriLike = GUri
    mutable struct GVariantBuilder <: GBoxed
        handle::Ptr{GVariantBuilder}
        (GLib.g_type(::Type{T}) where T <: GVariantBuilder) = ccall(("g_variant_builder_get_type", libgobject), GType, ())
        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
    const GVariantBuilderLike = GVariantBuilder
    mutable struct GVariantDict <: GBoxed
        handle::Ptr{GVariantDict}
        (GLib.g_type(::Type{T}) where T <: GVariantDict) = ccall(("g_variant_dict_get_type", libgobject), GType, ())
        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
    const GVariantDictLike = GVariantDict
    mutable struct GVariantType <: GBoxed
        handle::Ptr{GVariantType}
        (GLib.g_type(::Type{T}) where T <: GVariantType) = ccall(("g_variant_type_get_gtype", libgobject), GType, ())
        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
    const GVariantTypeLike = GVariantType
    gboxed_cache_init() = append!(GLib.gboxed_types, gboxed_types)
    @doc "See the [GTK docs](https://docs.gtk.org/glib/struct.BookmarkFile.html)." GBookmarkFile
    @doc "See the [GTK docs](https://docs.gtk.org/glib/struct.Bytes.html)." GBytes
    @doc "See the [GTK docs](https://docs.gtk.org/glib/struct.Checksum.html)." GChecksum
    @doc "See the [GTK docs](https://docs.gtk.org/glib/struct.Date.html)." GDate
    @doc "See the [GTK docs](https://docs.gtk.org/glib/struct.DateTime.html)." GDateTime
    @doc "See the [GTK docs](https://docs.gtk.org/glib/struct.DebugKey.html)." GDebugKey
    @doc "See the [GTK docs](https://docs.gtk.org/glib/struct.Dir.html)." GDir
    @doc "See the [GTK docs](https://docs.gtk.org/glib/struct.KeyFile.html)." GKeyFile
    @doc "See the [GTK docs](https://docs.gtk.org/glib/struct.LogField.html)." GLogField
    @doc "See the [GTK docs](https://docs.gtk.org/glib/struct.MainContext.html)." GMainContext
    @doc "See the [GTK docs](https://docs.gtk.org/glib/struct.MainLoop.html)." GMainLoop
    @doc "See the [GTK docs](https://docs.gtk.org/glib/struct.MappedFile.html)." GMappedFile
    @doc "See the [GTK docs](https://docs.gtk.org/glib/struct.MarkupParseContext.html)." GMarkupParseContext
    @doc "See the [GTK docs](https://docs.gtk.org/glib/struct.MatchInfo.html)." GMatchInfo
    @doc "See the [GTK docs](https://docs.gtk.org/glib/struct.OptionEntry.html)." GOptionEntry
    @doc "See the [GTK docs](https://docs.gtk.org/glib/struct.PatternSpec.html)." GPatternSpec
    @doc "See the [GTK docs](https://docs.gtk.org/glib/struct.Rand.html)." GRand
    @doc "See the [GTK docs](https://docs.gtk.org/glib/struct.Regex.html)." GRegex
    @doc "See the [GTK docs](https://docs.gtk.org/glib/struct.ScannerConfig.html)." GScannerConfig
    @doc "See the [GTK docs](https://docs.gtk.org/glib/struct.Source.html)." GSource
    @doc "See the [GTK docs](https://docs.gtk.org/glib/struct.SourceCallbackFuncs.html)." GSourceCallbackFuncs
    @doc "See the [GTK docs](https://docs.gtk.org/glib/struct.String.html)." GString
    @doc "See the [GTK docs](https://docs.gtk.org/glib/struct.StrvBuilder.html)." GStrvBuilder
    @doc "See the [GTK docs](https://docs.gtk.org/glib/struct.TimeZone.html)." GTimeZone
    @doc "See the [GTK docs](https://docs.gtk.org/glib/struct.UnixPipe.html)." GUnixPipe
    @doc "See the [GTK docs](https://docs.gtk.org/glib/struct.Uri.html)." GUri
    @doc "See the [GTK docs](https://docs.gtk.org/glib/struct.VariantBuilder.html)." GVariantBuilder
    @doc "See the [GTK docs](https://docs.gtk.org/glib/struct.VariantDict.html)." GVariantDict
    @doc "See the [GTK docs](https://docs.gtk.org/glib/struct.VariantType.html)." GVariantType
    function GDate(_day::Integer, _month, _year::Integer)
        G_.Date_new_dmy(_day, _month, _year)
    end
    function GDate(_julian_day::Integer)
        G_.Date_new_julian(_julian_day)
    end
    function GDateTime(_text::Union{AbstractString, Symbol}, _default_tz::Maybe(GTimeZone))
        G_.DateTime_new_from_iso8601(_text, _default_tz)
    end
    function GDateTime(_t::Integer)
        G_.DateTime_new_from_unix_local(_t)
    end
    function GDateTime(_year::Integer, _month::Integer, _day::Integer, _hour::Integer, _minute::Integer, _seconds::Real)
        G_.DateTime_new_local(_year, _month, _day, _hour, _minute, _seconds)
    end
    function GDateTime(_tz::GTimeZone)
        G_.DateTime_new_now(_tz)
    end
    function GDateTime()
        G_.DateTime_new_now_local()
    end
    function GDir(_path::Union{AbstractString, Symbol}, _flags::Integer)
        G_.Dir_open(_path, _flags)
    end
    function GMainContext(_flags)
        G_.MainContext_new_with_flags(_flags)
    end
    function GMappedFile(_fd::Integer, _writable::Bool)
        G_.MappedFile_new_from_fd(_fd, _writable)
    end
    function GRand(_seed::Integer)
        G_.Rand_new_with_seed(_seed)
    end
    function GRand(_seed::UInt32, _seed_length::Integer)
        G_.Rand_new_with_seed_array(_seed, _seed_length)
    end
    function GString(_init::Union{AbstractString, Symbol}, _len::Integer)
        G_.String_new_len(_init, _len)
    end
    function GString(_dfl_size::Integer)
        G_.String_sized_new(_dfl_size)
    end
    function GTimeZone(_identifier::Maybe(Union{AbstractString, Symbol}))
        G_.TimeZone_new_identifier(_identifier)
    end
    function GTimeZone()
        G_.TimeZone_new_local()
    end
    function GTimeZone(_seconds::Integer)
        G_.TimeZone_new_offset(_seconds)
    end
    function GVariantType(_element::GVariantType)
        G_.VariantType_new_array(_element)
    end
    function GVariantType(_key::GVariantType, _value::GVariantType)
        G_.VariantType_new_dict_entry(_key, _value)
    end
    function GVariantType(_items)
        G_.VariantType_new_tuple(_items)
    end
    function GChildWatchFunc(pid, wait_status, user_data)
        f = user_data
        ret = f(pid, wait_status)
        nothing
    end
    function GCompareDataFunc(a, b, user_data)
        a = convert(Maybe(Nothing), a)
        b = convert(Maybe(Nothing), b)
        f = user_data
        ret = f(a, b)
        convert(Int32, ret)
    end
    function GCopyFunc(src, data)
        src = convert(Nothing, src)
        f = data
        ret = f(src)
        convert(Ptr{Nothing}, ret)
    end
    function GDataForeachFunc(key_id, data, user_data)
        data = convert(Maybe(Nothing), data)
        f = user_data
        ret = f(key_id, data)
        nothing
    end
    function GDestroyNotify(data)
        f = data
        ret = f()
        nothing
    end
    function GDuplicateFunc(data, user_data)
        data = convert(Maybe(Nothing), data)
        f = user_data
        ret = f(data)
        convert(Ptr{Nothing}, ret)
    end
    function GEqualFuncFull(a, b, user_data)
        a = convert(Maybe(Nothing), a)
        b = convert(Maybe(Nothing), b)
        f = user_data
        ret = f(a, b)
        convert(Cint, ret)
    end
    function GFreeFunc(data)
        f = data
        ret = f()
        nothing
    end
    function GFunc(data, user_data)
        data = convert(Maybe(Nothing), data)
        f = user_data
        ret = f(data)
        nothing
    end
    function GHFunc(key, value, user_data)
        key = convert(Maybe(Nothing), key)
        value = convert(Maybe(Nothing), value)
        f = user_data
        ret = f(key, value)
        nothing
    end
    function GHRFunc(key, value, user_data)
        key = convert(Maybe(Nothing), key)
        value = convert(Maybe(Nothing), value)
        f = user_data
        ret = f(key, value)
        convert(Cint, ret)
    end
    function GHookCheckFunc(data)
        f = data
        ret = f()
        convert(Cint, ret)
    end
    function GHookCheckMarshaller(hook, marshal_data)
        hook = convert(GHookLike, hook)
        f = marshal_data
        ret = f(hook)
        convert(Cint, ret)
    end
    function GHookFindFunc(hook, data)
        hook = convert(GHookLike, hook)
        f = data
        ret = f(hook)
        convert(Cint, ret)
    end
    function GHookFunc(data)
        f = data
        ret = f()
        nothing
    end
    function GHookMarshaller(hook, marshal_data)
        hook = convert(GHookLike, hook)
        f = marshal_data
        ret = f(hook)
        nothing
    end
    function GIOFunc(source, condition, data)
        source = convert(GIOChannelLike, source, false)
        condition = IOCondition(condition)
        f = data
        ret = f(source, condition)
        convert(Cint, ret)
    end
    function GLogFunc(log_domain, log_level, message, user_data)
        log_domain = string_or_nothing(log_domain, false)
        log_level = LogLevelFlags(log_level)
        message = string_or_nothing(message, false)
        f = user_data
        ret = f(log_domain, log_level, message)
        nothing
    end
    function GNodeForeachFunc(node, data)
        node = convert(GNodeLike, node)
        f = data
        ret = f(node)
        nothing
    end
    function GNodeTraverseFunc(node, data)
        node = convert(GNodeLike, node)
        f = data
        ret = f(node)
        convert(Cint, ret)
    end
    function GOptionArgFunc(option_name, value, data)
        option_name = string_or_nothing(option_name, false)
        value = string_or_nothing(value, false)
        f = data
        ret = f(option_name, value)
        convert(Cint, ret)
    end
    function GOptionErrorFunc(context, group, data)
        context = convert(GOptionContext, context)
        group = convert(GOptionGroup, group, false)
        f = data
        ret = f(context, group)
        nothing
    end
    function GOptionParseFunc(context, group, data)
        context = convert(GOptionContext, context)
        group = convert(GOptionGroup, group, false)
        f = data
        ret = f(context, group)
        convert(Cint, ret)
    end
    function GRegexEvalCallback(match_info, result, user_data)
        match_info = convert(GMatchInfo, match_info, false)
        result = convert(GStringLike, result, false)
        f = user_data
        ret = f(match_info, result)
        convert(Cint, ret)
    end
    function GSequenceIterCompareFunc(a, b, data)
        a = convert(GSequenceIter, a)
        b = convert(GSequenceIter, b)
        f = data
        ret = f(a, b)
        convert(Int32, ret)
    end
    function GSourceFunc(user_data)
        f = user_data
        ret = f()
        convert(Cint, ret)
    end
    function GSourceOnceFunc(user_data)
        f = user_data
        ret = f()
        nothing
    end
    function GSpawnChildSetupFunc(data)
        f = data
        ret = f()
        nothing
    end
    function GTestDataFunc(user_data)
        f = user_data
        ret = f()
        nothing
    end
    function GTestFixtureFunc(fixture, user_data)
        fixture = convert(Nothing, fixture)
        f = user_data
        ret = f(fixture)
        nothing
    end
    function GTestLogFatalFunc(log_domain, log_level, message, user_data)
        log_domain = string_or_nothing(log_domain, false)
        log_level = LogLevelFlags(log_level)
        message = string_or_nothing(message, false)
        f = user_data
        ret = f(log_domain, log_level, message)
        convert(Cint, ret)
    end
    function GThreadFunc(data)
        f = data
        ret = f()
        convert(Ptr{Nothing}, ret)
    end
    function GTranslateFunc(str, data)
        str = string_or_nothing(str, false)
        f = data
        ret = f(str)
        convert(Cstring, ret)
    end
    function GTraverseFunc(key, value, data)
        key = convert(Maybe(Nothing), key)
        value = convert(Maybe(Nothing), value)
        f = data
        ret = f(key, value)
        convert(Cint, ret)
    end
    function GTraverseNodeFunc(node, data)
        node = convert(GTreeNode, node)
        f = data
        ret = f(node)
        convert(Cint, ret)
    end
    function GUnixFDSourceFunc(fd, condition, user_data)
        condition = IOCondition(condition)
        f = user_data
        ret = f(fd, condition)
        convert(Cint, ret)
    end
    export GBookmarkFile, GBytes, GChecksum, GDate, GDateLike, _GDate, GDateTime, GDebugKey, GDebugKeyLike, _GDebugKey, GDir, GHmac, GKeyFile, GLogField, GLogFieldLike, _GLogField, GMainContext, GMainLoop, GMappedFile, GMarkupParseContext, GMatchInfo, GOptionEntry, GOptionEntryLike, _GOptionEntry, GPatternSpec, GRand, GRegex, GScannerConfig, GScannerConfigLike, _GScannerConfig, GSource, GSourceLike, _GSource, GSourceCallbackFuncs, GSourceCallbackFuncsLike, _GSourceCallbackFuncs, GString, GStringLike, _GString, GStrvBuilder, GTestConfig, GTestConfigLike, _GTestConfig, GTimeZone, GUnixPipe, GUnixPipeLike, _GUnixPipe, GUri, GVariantBuilder, GVariantDict, GVariantType, GChildWatchFunc, GCompareDataFunc, GCopyFunc, GDataForeachFunc, GDestroyNotify, GDuplicateFunc, GEqualFuncFull, GFreeFunc, GFunc, GHFunc, GHRFunc, GHookCheckFunc, GHookCheckMarshaller, GHookFindFunc, GHookFunc, GHookMarshaller, GIOFunc, GLogFunc, GNodeForeachFunc, GNodeTraverseFunc, GOptionArgFunc, GOptionErrorFunc, GOptionParseFunc, GRegexEvalCallback, GSequenceIterCompareFunc, GSourceFunc, GSourceOnceFunc, GSpawnChildSetupFunc, GTestDataFunc, GTestFixtureFunc, GTestLogFatalFunc, GThreadFunc, GTranslateFunc, GTraverseFunc, GTraverseNodeFunc, GUnixFDSourceFunc
end
