begin
    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
    const GBookmarkFileLike = GBookmarkFile
end
begin
    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
    const GBytesLike = GBytes
end
begin
    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
    const GChecksumLike = GChecksum
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 GDateLike = GDate
    const _GDate = GDate
end
begin
    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
    const GDateTimeLike = GDateTime
end
begin
    struct _GDebugKey
        key::Cstring
        value::UInt32
    end
    mutable struct GDebugKey
        handle::Ptr{_GDebugKey}
    end
    begin
        unsafe_convert(::Type{Ptr{_GDebugKey}}, box::GDebugKey) = begin
                convert(Ptr{_GDebugKey}, box.handle)
            end
        convert(::Type{GDebugKey}, p::Ptr{_GDebugKey}, owns = false) = begin
                GDebugKey(p, owns)
            end
        const GDebugKeyLike = Union{Ref{_GDebugKey}, GDebugKey}
        convert(::Type{GDebugKeyLike}, p, owns) = begin
                convert(GDebugKey, p, owns)
            end
    end
end
begin
    mutable struct GDir <: GBoxed
        handle::Ptr{GDir}
        begin
            (GLib.g_type(::Type{T}) where T <: GDir) = begin
                    ccall(("g_dir_get_type", libgobject), GType, ())
                end
            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
    end
    const GDirLike = GDir
end
begin
    mutable struct GHmac <: GBoxed
        handle::Ptr{GHmac}
        begin
            (GLib.g_type(::Type{T}) where T <: GHmac) = begin
                    ccall(("g_hmac_get_type", libgobject), GType, ())
                end
            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
    end
    const GHmacLike = GHmac
end
begin
    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
    const GKeyFileLike = GKeyFile
end
begin
    struct _GLogField
        key::Cstring
        value::Ptr{Nothing}
        length::Int64
    end
    mutable struct GLogField
        handle::Ptr{_GLogField}
    end
    begin
        unsafe_convert(::Type{Ptr{_GLogField}}, box::GLogField) = begin
                convert(Ptr{_GLogField}, box.handle)
            end
        convert(::Type{GLogField}, p::Ptr{_GLogField}, owns = false) = begin
                GLogField(p, owns)
            end
        const GLogFieldLike = Union{Ref{_GLogField}, GLogField}
        convert(::Type{GLogFieldLike}, p, owns) = begin
                convert(GLogField, p, owns)
            end
    end
end
begin
    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
    const GMainContextLike = GMainContext
end
begin
    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
    const GMainLoopLike = GMainLoop
end
begin
    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
    const GMappedFileLike = GMappedFile
end
begin
    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
    const GMarkupParseContextLike = GMarkupParseContext
end
begin
    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
    const GMatchInfoLike = GMatchInfo
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
    begin
        unsafe_convert(::Type{Ptr{_GOptionEntry}}, box::GOptionEntry) = begin
                convert(Ptr{_GOptionEntry}, box.handle)
            end
        convert(::Type{GOptionEntry}, p::Ptr{_GOptionEntry}, owns = false) = begin
                GOptionEntry(p, owns)
            end
        const GOptionEntryLike = Union{Ref{_GOptionEntry}, GOptionEntry}
        convert(::Type{GOptionEntryLike}, p, owns) = begin
                convert(GOptionEntry, p, owns)
            end
    end
end
begin
    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
    const GPatternSpecLike = GPatternSpec
end
begin
    mutable struct GRand <: GBoxed
        handle::Ptr{GRand}
        begin
            (GLib.g_type(::Type{T}) where T <: GRand) = begin
                    ccall(("g_rand_get_type", libgobject), GType, ())
                end
            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
    end
    const GRandLike = GRand
end
begin
    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
    const GRegexLike = GRegex
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
    begin
        unsafe_convert(::Type{Ptr{_GScannerConfig}}, box::GScannerConfig) = begin
                convert(Ptr{_GScannerConfig}, box.handle)
            end
        convert(::Type{GScannerConfig}, p::Ptr{_GScannerConfig}, owns = false) = begin
                GScannerConfig(p, owns)
            end
        const GScannerConfigLike = Union{Ref{_GScannerConfig}, GScannerConfig}
        convert(::Type{GScannerConfigLike}, p, owns) = begin
                convert(GScannerConfig, p, owns)
            end
    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 GSourceLike = GSource
    const _GSource = GSource
end
begin
    struct _GSourceCallbackFuncs
        ref::Ptr{Cvoid}
        unref::Ptr{Cvoid}
        get::Ptr{Nothing}
    end
    mutable struct GSourceCallbackFuncs
        handle::Ptr{_GSourceCallbackFuncs}
    end
    begin
        unsafe_convert(::Type{Ptr{_GSourceCallbackFuncs}}, box::GSourceCallbackFuncs) = begin
                convert(Ptr{_GSourceCallbackFuncs}, box.handle)
            end
        convert(::Type{GSourceCallbackFuncs}, p::Ptr{_GSourceCallbackFuncs}, owns = false) = begin
                GSourceCallbackFuncs(p, owns)
            end
        const GSourceCallbackFuncsLike = Union{Ref{_GSourceCallbackFuncs}, GSourceCallbackFuncs}
        convert(::Type{GSourceCallbackFuncsLike}, p, owns) = begin
                convert(GSourceCallbackFuncs, p, owns)
            end
    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 <: Union{GBoxed, _GString}
                x = new(ref)
                if own
                    finalizer(x) do x
                        GLib.delboxed(x)
                    end
                end
                x
            end
            push!(gboxed_types, GString)
        end
    end
    begin
        unsafe_convert(::Type{Ptr{_GString}}, box::GString) = begin
                convert(Ptr{_GString}, box.handle)
            end
        convert(::Type{GString}, p::Ptr{_GString}, owns = false) = begin
                GString(p, owns)
            end
        const GStringLike = Union{Ref{_GString}, GString}
        convert(::Type{GStringLike}, p, owns) = begin
                convert(GString, p, owns)
            end
    end
end
begin
    mutable struct GStrvBuilder <: GBoxed
        handle::Ptr{GStrvBuilder}
        begin
            (GLib.g_type(::Type{T}) where T <: GStrvBuilder) = begin
                    ccall(("g_strv_builder_get_type", libgobject), GType, ())
                end
            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
    end
    const GStrvBuilderLike = GStrvBuilder
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
    begin
        unsafe_convert(::Type{Ptr{_GTestConfig}}, box::GTestConfig) = begin
                convert(Ptr{_GTestConfig}, box.handle)
            end
        convert(::Type{GTestConfig}, p::Ptr{_GTestConfig}, owns = false) = begin
                GTestConfig(p, owns)
            end
        const GTestConfigLike = Union{Ref{_GTestConfig}, GTestConfig}
        convert(::Type{GTestConfigLike}, p, owns) = begin
                convert(GTestConfig, p, owns)
            end
    end
end
begin
    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
    const GTimeZoneLike = GTimeZone
end
begin
    struct _GUnixPipe
        fds::Ptr{Int32}
    end
    mutable struct GUnixPipe
        handle::Ptr{_GUnixPipe}
    end
    begin
        unsafe_convert(::Type{Ptr{_GUnixPipe}}, box::GUnixPipe) = begin
                convert(Ptr{_GUnixPipe}, box.handle)
            end
        convert(::Type{GUnixPipe}, p::Ptr{_GUnixPipe}, owns = false) = begin
                GUnixPipe(p, owns)
            end
        const GUnixPipeLike = Union{Ref{_GUnixPipe}, GUnixPipe}
        convert(::Type{GUnixPipeLike}, p, owns) = begin
                convert(GUnixPipe, p, owns)
            end
    end
end
begin
    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
    const GUriLike = GUri
end
begin
    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
    const GVariantBuilderLike = GVariantBuilder
end
begin
    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
    const GVariantDictLike = GVariantDict
end
begin
    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
    const GVariantTypeLike = GVariantType
end
gboxed_cache_init() = begin
        append!(GLib.gboxed_types, gboxed_types)
    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.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
