quote
$(Expr(:toplevel, quote
    mutable struct GBookmarkFile <: GBoxed
        handle::Ptr{GBookmarkFile}
        begin
            (GLib.g_type(::Type{T}) where T <: GBookmarkFile) = begin
                    ccall(("g_bookmark_file_get_type", libgobject), GType, ())
                end
            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
    end
    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{Cvoid}
            unref::Ptr{Cvoid}
            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
    gboxed_cache_init() = begin
            append!(GLib.gboxed_types, gboxed_types)
        end
    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 GMainContext(_flags)
        G_.MainContext_new_with_flags(_flags)
    end
    function GMappedFile(_fd::Integer, _writable::Bool)
        G_.MappedFile_new_from_fd(_fd, _writable)
    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
    @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.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.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.TimeZone.html)." GTimeZone
    @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 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(Union{GHook, Ref{_GHook}}, hook)
        f = marshal_data
        ret = f(hook)
        convert(Cint, ret)
    end
    function GHookFindFunc(hook, data)
        hook = convert(Union{GHook, Ref{_GHook}}, 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(Union{GHook, Ref{_GHook}}, hook)
        f = marshal_data
        ret = f(hook)
        nothing
    end
    function GIOFunc(source, condition, data)
        source = convert(Union{GIOChannel, Ref{_GIOChannel}}, 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 GLogWriterFunc(log_level, fields, n_fields, user_data)
        log_level = LogLevelFlags(log_level)
        fields = collect(unsafe_wrap(Vector{_GLogField}, fields, m_n_fields[]))
        f = user_data
        ret = f(log_level, fields, n_fields)
        convert(UInt32, ret)
    end
    function GNodeForeachFunc(node, data)
        node = convert(Union{GNode, Ref{_GNode}}, node)
        f = data
        ret = f(node)
        nothing
    end
    function GNodeTraverseFunc(node, data)
        node = convert(Union{GNode, Ref{_GNode}}, 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(Union{GString, Ref{_GString}}, 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, _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, GChildWatchFunc, GCompareDataFunc, GCopyFunc, GDataForeachFunc, GDestroyNotify, GDuplicateFunc, GEqualFuncFull, GFreeFunc, GFunc, GHFunc, GHRFunc, GHookCheckFunc, GHookCheckMarshaller, GHookFindFunc, GHookFunc, GHookMarshaller, GIOFunc, GLogFunc, GLogWriterFunc, GNodeForeachFunc, GNodeTraverseFunc, GOptionArgFunc, GOptionErrorFunc, GOptionParseFunc, GRegexEvalCallback, GSequenceIterCompareFunc, GSourceFunc, GSourceOnceFunc, GSpawnChildSetupFunc, GTestDataFunc, GTestFixtureFunc, GTestLogFatalFunc, GThreadFunc, GTranslateFunc, GTraverseFunc, GTraverseNodeFunc, GUnixFDSourceFunc
end))
end
