begin
    function BookmarkFile_new()
        ret = ccall(("g_bookmark_file_new", libglib), Ptr{GBookmarkFile}, ())
        ret2 = convert(GBookmarkFile, ret, true)
        ret2
    end
    function add_application(instance::GBookmarkFile, _uri::Union{AbstractString, Symbol}, _name::Maybe(Union{AbstractString, Symbol}), _exec::Maybe(Union{AbstractString, Symbol}))
        _name_maybe = nothing_to_null(_name)
        _exec_maybe = nothing_to_null(_exec)
        ret = ccall(("g_bookmark_file_add_application", libglib), Nothing, (Ptr{GBookmarkFile}, Cstring, Cstring, Cstring), instance, _uri, _name_maybe, _exec_maybe)
        nothing
    end
    function add_group(instance::GBookmarkFile, _uri::Union{AbstractString, Symbol}, _group::Union{AbstractString, Symbol})
        ret = ccall(("g_bookmark_file_add_group", libglib), Nothing, (Ptr{GBookmarkFile}, Cstring, Cstring), instance, _uri, _group)
        nothing
    end
    function copy(instance::GBookmarkFile)
        ret = ccall(("g_bookmark_file_copy", libglib), Ptr{GBookmarkFile}, (Ptr{GBookmarkFile},), instance)
        ret2 = convert(GBookmarkFile, ret, true)
        ret2
    end
    function free(instance::GBookmarkFile)
        ret = ccall(("g_bookmark_file_free", libglib), Nothing, (Ptr{GBookmarkFile},), instance)
        nothing
    end
    function get_added_date_time(instance::GBookmarkFile, _uri::Union{AbstractString, Symbol})
        err = err_buf()
        ret = ccall(("g_bookmark_file_get_added_date_time", libglib), Ptr{GDateTime}, (Ptr{GBookmarkFile}, Cstring, Ptr{Ptr{GError}}), instance, _uri, err)
        check_err(err)
        ret2 = convert(GDateTime, ret, false)
        ret2
    end
    function get_application_info(instance::GBookmarkFile, _uri::Union{AbstractString, Symbol}, _name::Union{AbstractString, Symbol})
        m_exec = Ref{Cstring}()
        m_count = Ref{UInt32}()
        m_stamp = Ref{Ptr{GDateTime}}()
        err = err_buf()
        ret = ccall(("g_bookmark_file_get_application_info", libglib), Cint, (Ptr{GBookmarkFile}, Cstring, Cstring, Ptr{Cstring}, Ptr{UInt32}, Ptr{Ptr{GDateTime}}, Ptr{Ptr{GError}}), instance, _uri, _name, m_exec, m_count, m_stamp, err)
        check_err(err)
        ret2 = convert(Bool, ret)
        _exec = m_exec[]
        _exec = string_or_nothing(_exec, true)
        _count = m_count[]
        _stamp = m_stamp[]
        _stamp = convert(GDateTime, _stamp, false)
        (ret2, _exec, _count, _stamp)
    end
    function get_applications(instance::GBookmarkFile, _uri::Union{AbstractString, Symbol})
        m_length = Ref{UInt64}()
        err = err_buf()
        ret = ccall(("g_bookmark_file_get_applications", libglib), Ptr{Cstring}, (Ptr{GBookmarkFile}, Cstring, Ptr{UInt64}, Ptr{Ptr{GError}}), instance, _uri, m_length, err)
        check_err(err)
        ret2 = begin
                arrtemp = bytestring.(unsafe_wrap(Vector{Cstring}, ret, m_length[]))
                GLib.g_free(ret)
                arrtemp
            end
        _length = m_length[]
        ret2
    end
    function get_description(instance::GBookmarkFile, _uri::Union{AbstractString, Symbol})
        err = err_buf()
        ret = ccall(("g_bookmark_file_get_description", libglib), Cstring, (Ptr{GBookmarkFile}, Cstring, Ptr{Ptr{GError}}), instance, _uri, err)
        check_err(err)
        ret2 = string_or_nothing(ret, true)
        ret2
    end
    function get_groups(instance::GBookmarkFile, _uri::Union{AbstractString, Symbol})
        m_length = Ref{UInt64}()
        err = err_buf()
        ret = ccall(("g_bookmark_file_get_groups", libglib), Ptr{Cstring}, (Ptr{GBookmarkFile}, Cstring, Ptr{UInt64}, Ptr{Ptr{GError}}), instance, _uri, m_length, err)
        check_err(err)
        ret2 = begin
                arrtemp = bytestring.(unsafe_wrap(Vector{Cstring}, ret, m_length[]))
                GLib.g_free(ret)
                arrtemp
            end
        _length = m_length[]
        ret2
    end
    function get_icon(instance::GBookmarkFile, _uri::Union{AbstractString, Symbol})
        m_href = Ref{Cstring}()
        m_mime_type = Ref{Cstring}()
        err = err_buf()
        ret = ccall(("g_bookmark_file_get_icon", libglib), Cint, (Ptr{GBookmarkFile}, Cstring, Ptr{Cstring}, Ptr{Cstring}, Ptr{Ptr{GError}}), instance, _uri, m_href, m_mime_type, err)
        check_err(err)
        ret2 = convert(Bool, ret)
        _href = m_href[]
        _href = string_or_nothing(_href, true)
        _mime_type = m_mime_type[]
        _mime_type = string_or_nothing(_mime_type, true)
        (ret2, _href, _mime_type)
    end
    function get_is_private(instance::GBookmarkFile, _uri::Union{AbstractString, Symbol})
        err = err_buf()
        ret = ccall(("g_bookmark_file_get_is_private", libglib), Cint, (Ptr{GBookmarkFile}, Cstring, Ptr{Ptr{GError}}), instance, _uri, err)
        check_err(err)
        ret2 = convert(Bool, ret)
        ret2
    end
    function get_mime_type(instance::GBookmarkFile, _uri::Union{AbstractString, Symbol})
        err = err_buf()
        ret = ccall(("g_bookmark_file_get_mime_type", libglib), Cstring, (Ptr{GBookmarkFile}, Cstring, Ptr{Ptr{GError}}), instance, _uri, err)
        check_err(err)
        ret2 = string_or_nothing(ret, true)
        ret2
    end
    function get_modified_date_time(instance::GBookmarkFile, _uri::Union{AbstractString, Symbol})
        err = err_buf()
        ret = ccall(("g_bookmark_file_get_modified_date_time", libglib), Ptr{GDateTime}, (Ptr{GBookmarkFile}, Cstring, Ptr{Ptr{GError}}), instance, _uri, err)
        check_err(err)
        ret2 = convert(GDateTime, ret, false)
        ret2
    end
    function get_size(instance::GBookmarkFile)
        ret = ccall(("g_bookmark_file_get_size", libglib), Int32, (Ptr{GBookmarkFile},), instance)
        ret
    end
    function get_title(instance::GBookmarkFile, _uri::Maybe(Union{AbstractString, Symbol}))
        _uri_maybe = nothing_to_null(_uri)
        err = err_buf()
        ret = ccall(("g_bookmark_file_get_title", libglib), Cstring, (Ptr{GBookmarkFile}, Cstring, Ptr{Ptr{GError}}), instance, _uri_maybe, err)
        check_err(err)
        ret2 = string_or_nothing(ret, true)
        ret2
    end
    function get_uris(instance::GBookmarkFile)
        m_length = Ref{UInt64}()
        ret = ccall(("g_bookmark_file_get_uris", libglib), Ptr{Cstring}, (Ptr{GBookmarkFile}, Ptr{UInt64}), instance, m_length)
        ret2 = begin
                arrtemp = bytestring.(unsafe_wrap(Vector{Cstring}, ret, m_length[]))
                GLib.g_free(ret)
                arrtemp
            end
        _length = m_length[]
        ret2
    end
    function get_visited_date_time(instance::GBookmarkFile, _uri::Union{AbstractString, Symbol})
        err = err_buf()
        ret = ccall(("g_bookmark_file_get_visited_date_time", libglib), Ptr{GDateTime}, (Ptr{GBookmarkFile}, Cstring, Ptr{Ptr{GError}}), instance, _uri, err)
        check_err(err)
        ret2 = convert(GDateTime, ret, false)
        ret2
    end
    function has_application(instance::GBookmarkFile, _uri::Union{AbstractString, Symbol}, _name::Union{AbstractString, Symbol})
        err = err_buf()
        ret = ccall(("g_bookmark_file_has_application", libglib), Cint, (Ptr{GBookmarkFile}, Cstring, Cstring, Ptr{Ptr{GError}}), instance, _uri, _name, err)
        check_err(err)
        ret2 = convert(Bool, ret)
        ret2
    end
    function has_group(instance::GBookmarkFile, _uri::Union{AbstractString, Symbol}, _group::Union{AbstractString, Symbol})
        err = err_buf()
        ret = ccall(("g_bookmark_file_has_group", libglib), Cint, (Ptr{GBookmarkFile}, Cstring, Cstring, Ptr{Ptr{GError}}), instance, _uri, _group, err)
        check_err(err)
        ret2 = convert(Bool, ret)
        ret2
    end
    function has_item(instance::GBookmarkFile, _uri::Union{AbstractString, Symbol})
        ret = ccall(("g_bookmark_file_has_item", libglib), Cint, (Ptr{GBookmarkFile}, Cstring), instance, _uri)
        ret2 = convert(Bool, ret)
        ret2
    end
    function load_from_data(instance::GBookmarkFile, _data)
        _data_arr = convert(Vector{UInt8}, _data)
        _length = length(_data)
        err = err_buf()
        ret = ccall(("g_bookmark_file_load_from_data", libglib), Cint, (Ptr{GBookmarkFile}, Ptr{UInt8}, UInt64, Ptr{Ptr{GError}}), instance, _data_arr, _length, err)
        check_err(err)
        ret2 = convert(Bool, ret)
        ret2
    end
    function load_from_data_dirs(instance::GBookmarkFile, _file::Union{AbstractString, Symbol})
        m_full_path = Ref{Cstring}()
        err = err_buf()
        ret = ccall(("g_bookmark_file_load_from_data_dirs", libglib), Cint, (Ptr{GBookmarkFile}, Cstring, Ptr{Cstring}, Ptr{Ptr{GError}}), instance, _file, m_full_path, err)
        check_err(err)
        ret2 = convert(Bool, ret)
        _full_path = m_full_path[]
        _full_path = string_or_nothing(_full_path, true)
        (ret2, _full_path)
    end
    function load_from_file(instance::GBookmarkFile, _filename::Union{AbstractString, Symbol})
        err = err_buf()
        ret = ccall(("g_bookmark_file_load_from_file", libglib), Cint, (Ptr{GBookmarkFile}, Cstring, Ptr{Ptr{GError}}), instance, _filename, err)
        check_err(err)
        ret2 = convert(Bool, ret)
        ret2
    end
    function move_item(instance::GBookmarkFile, _old_uri::Union{AbstractString, Symbol}, _new_uri::Maybe(Union{AbstractString, Symbol}))
        _new_uri_maybe = nothing_to_null(_new_uri)
        err = err_buf()
        ret = ccall(("g_bookmark_file_move_item", libglib), Cint, (Ptr{GBookmarkFile}, Cstring, Cstring, Ptr{Ptr{GError}}), instance, _old_uri, _new_uri_maybe, err)
        check_err(err)
        ret2 = convert(Bool, ret)
        ret2
    end
    function remove_application(instance::GBookmarkFile, _uri::Union{AbstractString, Symbol}, _name::Union{AbstractString, Symbol})
        err = err_buf()
        ret = ccall(("g_bookmark_file_remove_application", libglib), Cint, (Ptr{GBookmarkFile}, Cstring, Cstring, Ptr{Ptr{GError}}), instance, _uri, _name, err)
        check_err(err)
        ret2 = convert(Bool, ret)
        ret2
    end
    function remove_group(instance::GBookmarkFile, _uri::Union{AbstractString, Symbol}, _group::Union{AbstractString, Symbol})
        err = err_buf()
        ret = ccall(("g_bookmark_file_remove_group", libglib), Cint, (Ptr{GBookmarkFile}, Cstring, Cstring, Ptr{Ptr{GError}}), instance, _uri, _group, err)
        check_err(err)
        ret2 = convert(Bool, ret)
        ret2
    end
    function remove_item(instance::GBookmarkFile, _uri::Union{AbstractString, Symbol})
        err = err_buf()
        ret = ccall(("g_bookmark_file_remove_item", libglib), Cint, (Ptr{GBookmarkFile}, Cstring, Ptr{Ptr{GError}}), instance, _uri, err)
        check_err(err)
        ret2 = convert(Bool, ret)
        ret2
    end
    function set_added_date_time(instance::GBookmarkFile, _uri::Union{AbstractString, Symbol}, _added::GDateTime)
        ret = ccall(("g_bookmark_file_set_added_date_time", libglib), Nothing, (Ptr{GBookmarkFile}, Cstring, Ptr{GDateTime}), instance, _uri, _added)
        nothing
    end
    function set_application_info(instance::GBookmarkFile, _uri::Union{AbstractString, Symbol}, _name::Union{AbstractString, Symbol}, _exec::Union{AbstractString, Symbol}, _count::Integer, _stamp::Maybe(GDateTime))
        _stamp_maybe = nothing_to_null(_stamp)
        err = err_buf()
        ret = ccall(("g_bookmark_file_set_application_info", libglib), Cint, (Ptr{GBookmarkFile}, Cstring, Cstring, Cstring, Int32, Ptr{GDateTime}, Ptr{Ptr{GError}}), instance, _uri, _name, _exec, _count, _stamp_maybe, err)
        check_err(err)
        ret2 = convert(Bool, ret)
        ret2
    end
    function set_description(instance::GBookmarkFile, _uri::Maybe(Union{AbstractString, Symbol}), _description::Union{AbstractString, Symbol})
        _uri_maybe = nothing_to_null(_uri)
        ret = ccall(("g_bookmark_file_set_description", libglib), Nothing, (Ptr{GBookmarkFile}, Cstring, Cstring), instance, _uri_maybe, _description)
        nothing
    end
    function set_groups(instance::GBookmarkFile, _uri::Union{AbstractString, Symbol}, _groups)
        _groups_maybe = nothing_to_null(_groups)
        _length = length(_groups)
        ret = ccall(("g_bookmark_file_set_groups", libglib), Nothing, (Ptr{GBookmarkFile}, Cstring, Ptr{Cstring}, UInt64), instance, _uri, _groups_maybe, _length)
        nothing
    end
    function set_icon(instance::GBookmarkFile, _uri::Union{AbstractString, Symbol}, _href::Maybe(Union{AbstractString, Symbol}), _mime_type::Union{AbstractString, Symbol})
        _href_maybe = nothing_to_null(_href)
        ret = ccall(("g_bookmark_file_set_icon", libglib), Nothing, (Ptr{GBookmarkFile}, Cstring, Cstring, Cstring), instance, _uri, _href_maybe, _mime_type)
        nothing
    end
    function set_is_private(instance::GBookmarkFile, _uri::Union{AbstractString, Symbol}, _is_private::Bool)
        ret = ccall(("g_bookmark_file_set_is_private", libglib), Nothing, (Ptr{GBookmarkFile}, Cstring, Cint), instance, _uri, _is_private)
        nothing
    end
    function set_mime_type(instance::GBookmarkFile, _uri::Union{AbstractString, Symbol}, _mime_type::Union{AbstractString, Symbol})
        ret = ccall(("g_bookmark_file_set_mime_type", libglib), Nothing, (Ptr{GBookmarkFile}, Cstring, Cstring), instance, _uri, _mime_type)
        nothing
    end
    function set_modified_date_time(instance::GBookmarkFile, _uri::Union{AbstractString, Symbol}, _modified::GDateTime)
        ret = ccall(("g_bookmark_file_set_modified_date_time", libglib), Nothing, (Ptr{GBookmarkFile}, Cstring, Ptr{GDateTime}), instance, _uri, _modified)
        nothing
    end
    function set_title(instance::GBookmarkFile, _uri::Maybe(Union{AbstractString, Symbol}), _title::Union{AbstractString, Symbol})
        _uri_maybe = nothing_to_null(_uri)
        ret = ccall(("g_bookmark_file_set_title", libglib), Nothing, (Ptr{GBookmarkFile}, Cstring, Cstring), instance, _uri_maybe, _title)
        nothing
    end
    function set_visited_date_time(instance::GBookmarkFile, _uri::Union{AbstractString, Symbol}, _visited::GDateTime)
        ret = ccall(("g_bookmark_file_set_visited_date_time", libglib), Nothing, (Ptr{GBookmarkFile}, Cstring, Ptr{GDateTime}), instance, _uri, _visited)
        nothing
    end
    function to_data(instance::GBookmarkFile)
        m_length = Ref{UInt64}()
        err = err_buf()
        ret = ccall(("g_bookmark_file_to_data", libglib), Ptr{UInt8}, (Ptr{GBookmarkFile}, Ptr{UInt64}, Ptr{Ptr{GError}}), instance, m_length, err)
        check_err(err)
        ret2 = begin
                arrtemp = copy(unsafe_wrap(Vector{UInt8}, ret, m_length[]))
                GLib.g_free(ret)
                arrtemp
            end
        _length = m_length[]
        ret2
    end
    function to_file(instance::GBookmarkFile, _filename::Union{AbstractString, Symbol})
        err = err_buf()
        ret = ccall(("g_bookmark_file_to_file", libglib), Cint, (Ptr{GBookmarkFile}, Cstring, Ptr{Ptr{GError}}), instance, _filename, err)
        check_err(err)
        ret2 = convert(Bool, ret)
        ret2
    end
    function Bytes_new(_data)
        _data_arr = convert(Vector{UInt8}, _data)
        _size = length(_data)
        ret = ccall(("g_bytes_new", libglib), Ptr{GBytes}, (Ptr{UInt8}, UInt64), _data_arr, _size)
        ret2 = convert(GBytes, ret, true)
        ret2
    end
    function Bytes_new_take(_data)
        _data_arr = convert(Vector{UInt8}, _data)
        _size = length(_data)
        ret = ccall(("g_bytes_new_take", libglib), Ptr{GBytes}, (Ptr{UInt8}, UInt64), _data_arr, _size)
        ret2 = convert(GBytes, ret, true)
        ret2
    end
    function compare(instance::GBytes, _bytes2::GBytes)
        ret = ccall(("g_bytes_compare", libglib), Int32, (Ptr{GBytes}, Ptr{GBytes}), instance, _bytes2)
        ret
    end
    function equal(instance::GBytes, _bytes2::GBytes)
        ret = ccall(("g_bytes_equal", libglib), Cint, (Ptr{GBytes}, Ptr{GBytes}), instance, _bytes2)
        ret2 = convert(Bool, ret)
        ret2
    end
    function get_data(instance::GBytes)
        m_size = Ref{UInt64}()
        ret = ccall(("g_bytes_get_data", libglib), Ptr{UInt8}, (Ptr{GBytes}, Ptr{UInt64}), instance, m_size)
        ret2 = collect(unsafe_wrap(Vector{UInt8}, ret, m_size[]))
        _size = m_size[]
        ret2
    end
    function get_size(instance::GBytes)
        ret = ccall(("g_bytes_get_size", libglib), UInt64, (Ptr{GBytes},), instance)
        ret
    end
    function hash(instance::GBytes)
        ret = ccall(("g_bytes_hash", libglib), UInt32, (Ptr{GBytes},), instance)
        ret
    end
    function new_from_bytes(instance::GBytes, _offset::Integer, _length::Integer)
        ret = ccall(("g_bytes_new_from_bytes", libglib), Ptr{GBytes}, (Ptr{GBytes}, UInt64, UInt64), instance, _offset, _length)
        ret2 = convert(GBytes, ret, true)
        ret2
    end
    function ref(instance::GBytes)
        ret = ccall(("g_bytes_ref", libglib), Ptr{GBytes}, (Ptr{GBytes},), instance)
        ret2 = convert(GBytes, ret, true)
        ret2
    end
    function unref(instance::GBytes)
        ret = ccall(("g_bytes_unref", libglib), Nothing, (Ptr{GBytes},), instance)
        nothing
    end
    function unref_to_array(instance::GBytes)
        reffed_instance = GLib.glib_ref(instance)
        ret = ccall(("g_bytes_unref_to_array", libglib), Ptr{GByteArray}, (Ptr{GBytes},), reffed_instance)
        ret2 = convert(GByteArray, ret, true)
        ret2
    end
    function unref_to_data(instance::GBytes)
        reffed_instance = GLib.glib_ref(instance)
        m_size = Ref{UInt64}()
        ret = ccall(("g_bytes_unref_to_data", libglib), Ptr{UInt8}, (Ptr{GBytes}, Ptr{UInt64}), reffed_instance, m_size)
        ret2 = begin
                arrtemp = copy(unsafe_wrap(Vector{UInt8}, ret, m_size[]))
                GLib.g_free(ret)
                arrtemp
            end
        _size = m_size[]
        ret2
    end
    function Checksum_new(_checksum_type)
        ret = ccall(("g_checksum_new", libglib), Ptr{GChecksum}, (UInt32,), _checksum_type)
        ret2 = convert_if_not_null(GChecksum, ret, true)
        ret2
    end
    function copy(instance::GChecksum)
        ret = ccall(("g_checksum_copy", libglib), Ptr{GChecksum}, (Ptr{GChecksum},), instance)
        ret2 = convert(GChecksum, ret, true)
        ret2
    end
    function free(instance::GChecksum)
        ret = ccall(("g_checksum_free", libglib), Nothing, (Ptr{GChecksum},), instance)
        nothing
    end
    function get_string(instance::GChecksum)
        ret = ccall(("g_checksum_get_string", libglib), Cstring, (Ptr{GChecksum},), instance)
        ret2 = string_or_nothing(ret, false)
        ret2
    end
    function reset(instance::GChecksum)
        ret = ccall(("g_checksum_reset", libglib), Nothing, (Ptr{GChecksum},), instance)
        nothing
    end
    function update(instance::GChecksum, _data)
        _data_arr = convert(Vector{UInt8}, _data)
        _length = length(_data)
        ret = ccall(("g_checksum_update", libglib), Nothing, (Ptr{GChecksum}, Ptr{UInt8}, Int64), instance, _data_arr, _length)
        nothing
    end
    function Date_new()
        ret = ccall(("g_date_new", libglib), Ptr{_GDate}, ())
        ret2 = convert(GDateLike, ret, true)
        ret2
    end
    function Date_new_dmy(_day::Integer, _month, _year::Integer)
        ret = ccall(("g_date_new_dmy", libglib), Ptr{_GDate}, (UInt8, UInt32, UInt16), _day, _month, _year)
        ret2 = convert(GDateLike, ret, true)
        ret2
    end
    function Date_new_julian(_julian_day::Integer)
        ret = ccall(("g_date_new_julian", libglib), Ptr{_GDate}, (UInt32,), _julian_day)
        ret2 = convert(GDateLike, ret, true)
        ret2
    end
    function add_days(instance::GDateLike, _n_days::Integer)
        ret = ccall(("g_date_add_days", libglib), Nothing, (Ptr{_GDate}, UInt32), instance, _n_days)
        nothing
    end
    function add_months(instance::GDateLike, _n_months::Integer)
        ret = ccall(("g_date_add_months", libglib), Nothing, (Ptr{_GDate}, UInt32), instance, _n_months)
        nothing
    end
    function add_years(instance::GDateLike, _n_years::Integer)
        ret = ccall(("g_date_add_years", libglib), Nothing, (Ptr{_GDate}, UInt32), instance, _n_years)
        nothing
    end
    function clamp(instance::GDateLike, _min_date::GDateLike, _max_date::GDateLike)
        ret = ccall(("g_date_clamp", libglib), Nothing, (Ptr{_GDate}, Ptr{_GDate}, Ptr{_GDate}), instance, _min_date, _max_date)
        nothing
    end
    function clear(instance::GDateLike, _n_dates::Integer)
        ret = ccall(("g_date_clear", libglib), Nothing, (Ptr{_GDate}, UInt32), instance, _n_dates)
        nothing
    end
    function compare(instance::GDateLike, _rhs::GDateLike)
        ret = ccall(("g_date_compare", libglib), Int32, (Ptr{_GDate}, Ptr{_GDate}), instance, _rhs)
        ret
    end
    function copy(instance::GDateLike)
        ret = ccall(("g_date_copy", libglib), Ptr{_GDate}, (Ptr{_GDate},), instance)
        ret2 = convert(GDateLike, ret, true)
        ret2
    end
    function days_between(instance::GDateLike, _date2::GDateLike)
        ret = ccall(("g_date_days_between", libglib), Int32, (Ptr{_GDate}, Ptr{_GDate}), instance, _date2)
        ret
    end
    function free(instance::GDateLike)
        ret = ccall(("g_date_free", libglib), Nothing, (Ptr{_GDate},), instance)
        nothing
    end
    function get_day(instance::GDateLike)
        ret = ccall(("g_date_get_day", libglib), UInt8, (Ptr{_GDate},), instance)
        ret
    end
    function get_day_of_year(instance::GDateLike)
        ret = ccall(("g_date_get_day_of_year", libglib), UInt32, (Ptr{_GDate},), instance)
        ret
    end
    function get_iso8601_week_of_year(instance::GDateLike)
        ret = ccall(("g_date_get_iso8601_week_of_year", libglib), UInt32, (Ptr{_GDate},), instance)
        ret
    end
    function get_julian(instance::GDateLike)
        ret = ccall(("g_date_get_julian", libglib), UInt32, (Ptr{_GDate},), instance)
        ret
    end
    function get_monday_week_of_year(instance::GDateLike)
        ret = ccall(("g_date_get_monday_week_of_year", libglib), UInt32, (Ptr{_GDate},), instance)
        ret
    end
    function get_month(instance::GDateLike)
        ret = ccall(("g_date_get_month", libglib), UInt32, (Ptr{_GDate},), instance)
        ret2 = DateMonth(ret)
        ret2
    end
    function get_sunday_week_of_year(instance::GDateLike)
        ret = ccall(("g_date_get_sunday_week_of_year", libglib), UInt32, (Ptr{_GDate},), instance)
        ret
    end
    function get_weekday(instance::GDateLike)
        ret = ccall(("g_date_get_weekday", libglib), UInt32, (Ptr{_GDate},), instance)
        ret2 = DateWeekday(ret)
        ret2
    end
    function get_year(instance::GDateLike)
        ret = ccall(("g_date_get_year", libglib), UInt16, (Ptr{_GDate},), instance)
        ret
    end
    function is_first_of_month(instance::GDateLike)
        ret = ccall(("g_date_is_first_of_month", libglib), Cint, (Ptr{_GDate},), instance)
        ret2 = convert(Bool, ret)
        ret2
    end
    function is_last_of_month(instance::GDateLike)
        ret = ccall(("g_date_is_last_of_month", libglib), Cint, (Ptr{_GDate},), instance)
        ret2 = convert(Bool, ret)
        ret2
    end
    function order(instance::GDateLike, _date2::GDateLike)
        ret = ccall(("g_date_order", libglib), Nothing, (Ptr{_GDate}, Ptr{_GDate}), instance, _date2)
        nothing
    end
    function set_day(instance::GDateLike, _day::Integer)
        ret = ccall(("g_date_set_day", libglib), Nothing, (Ptr{_GDate}, UInt8), instance, _day)
        nothing
    end
    function set_dmy(instance::GDateLike, _day::Integer, _month, _y::Integer)
        ret = ccall(("g_date_set_dmy", libglib), Nothing, (Ptr{_GDate}, UInt8, UInt32, UInt16), instance, _day, _month, _y)
        nothing
    end
    function set_julian(instance::GDateLike, _julian_date::Integer)
        ret = ccall(("g_date_set_julian", libglib), Nothing, (Ptr{_GDate}, UInt32), instance, _julian_date)
        nothing
    end
    function set_month(instance::GDateLike, _month)
        ret = ccall(("g_date_set_month", libglib), Nothing, (Ptr{_GDate}, UInt32), instance, _month)
        nothing
    end
    function set_parse(instance::GDateLike, _str::Union{AbstractString, Symbol})
        ret = ccall(("g_date_set_parse", libglib), Nothing, (Ptr{_GDate}, Cstring), instance, _str)
        nothing
    end
    function set_time_t(instance::GDateLike, _timet::Integer)
        ret = ccall(("g_date_set_time_t", libglib), Nothing, (Ptr{_GDate}, Int64), instance, _timet)
        nothing
    end
    function set_year(instance::GDateLike, _year::Integer)
        ret = ccall(("g_date_set_year", libglib), Nothing, (Ptr{_GDate}, UInt16), instance, _year)
        nothing
    end
    function subtract_days(instance::GDateLike, _n_days::Integer)
        ret = ccall(("g_date_subtract_days", libglib), Nothing, (Ptr{_GDate}, UInt32), instance, _n_days)
        nothing
    end
    function subtract_months(instance::GDateLike, _n_months::Integer)
        ret = ccall(("g_date_subtract_months", libglib), Nothing, (Ptr{_GDate}, UInt32), instance, _n_months)
        nothing
    end
    function subtract_years(instance::GDateLike, _n_years::Integer)
        ret = ccall(("g_date_subtract_years", libglib), Nothing, (Ptr{_GDate}, UInt32), instance, _n_years)
        nothing
    end
    function to_struct_tm(instance::GDateLike, _tm::Nothing)
        ret = ccall(("g_date_to_struct_tm", libglib), Nothing, (Ptr{_GDate}, Ptr{Nothing}), instance, _tm)
        nothing
    end
    function valid(instance::GDateLike)
        ret = ccall(("g_date_valid", libglib), Cint, (Ptr{_GDate},), instance)
        ret2 = convert(Bool, ret)
        ret2
    end
    function DateTime_new(_tz::GTimeZone, _year::Integer, _month::Integer, _day::Integer, _hour::Integer, _minute::Integer, _seconds::Real)
        ret = ccall(("g_date_time_new", libglib), Ptr{GDateTime}, (Ptr{GTimeZone}, Int32, Int32, Int32, Int32, Int32, Float64), _tz, _year, _month, _day, _hour, _minute, _seconds)
        ret2 = convert_if_not_null(GDateTime, ret, true)
        ret2
    end
    function DateTime_new_from_iso8601(_text::Union{AbstractString, Symbol}, _default_tz::Maybe(GTimeZone))
        _default_tz_maybe = nothing_to_null(_default_tz)
        ret = ccall(("g_date_time_new_from_iso8601", libglib), Ptr{GDateTime}, (Cstring, Ptr{GTimeZone}), _text, _default_tz_maybe)
        ret2 = convert_if_not_null(GDateTime, ret, true)
        ret2
    end
    function DateTime_new_from_unix_local(_t::Integer)
        ret = ccall(("g_date_time_new_from_unix_local", libglib), Ptr{GDateTime}, (Int64,), _t)
        ret2 = convert_if_not_null(GDateTime, ret, true)
        ret2
    end
    function DateTime_new_from_unix_local_usec(_usecs::Integer)
        ret = ccall(("g_date_time_new_from_unix_local_usec", libglib), Ptr{GDateTime}, (Int64,), _usecs)
        ret2 = convert_if_not_null(GDateTime, ret, true)
        ret2
    end
    function DateTime_new_from_unix_utc(_t::Integer)
        ret = ccall(("g_date_time_new_from_unix_utc", libglib), Ptr{GDateTime}, (Int64,), _t)
        ret2 = convert_if_not_null(GDateTime, ret, true)
        ret2
    end
    function DateTime_new_from_unix_utc_usec(_usecs::Integer)
        ret = ccall(("g_date_time_new_from_unix_utc_usec", libglib), Ptr{GDateTime}, (Int64,), _usecs)
        ret2 = convert_if_not_null(GDateTime, ret, true)
        ret2
    end
    function DateTime_new_local(_year::Integer, _month::Integer, _day::Integer, _hour::Integer, _minute::Integer, _seconds::Real)
        ret = ccall(("g_date_time_new_local", libglib), Ptr{GDateTime}, (Int32, Int32, Int32, Int32, Int32, Float64), _year, _month, _day, _hour, _minute, _seconds)
        ret2 = convert_if_not_null(GDateTime, ret, true)
        ret2
    end
    function DateTime_new_now(_tz::GTimeZone)
        ret = ccall(("g_date_time_new_now", libglib), Ptr{GDateTime}, (Ptr{GTimeZone},), _tz)
        ret2 = convert_if_not_null(GDateTime, ret, true)
        ret2
    end
    function DateTime_new_now_local()
        ret = ccall(("g_date_time_new_now_local", libglib), Ptr{GDateTime}, ())
        ret2 = convert_if_not_null(GDateTime, ret, true)
        ret2
    end
    function DateTime_new_now_utc()
        ret = ccall(("g_date_time_new_now_utc", libglib), Ptr{GDateTime}, ())
        ret2 = convert_if_not_null(GDateTime, ret, true)
        ret2
    end
    function DateTime_new_utc(_year::Integer, _month::Integer, _day::Integer, _hour::Integer, _minute::Integer, _seconds::Real)
        ret = ccall(("g_date_time_new_utc", libglib), Ptr{GDateTime}, (Int32, Int32, Int32, Int32, Int32, Float64), _year, _month, _day, _hour, _minute, _seconds)
        ret2 = convert_if_not_null(GDateTime, ret, true)
        ret2
    end
    function add(instance::GDateTime, _timespan::Integer)
        ret = ccall(("g_date_time_add", libglib), Ptr{GDateTime}, (Ptr{GDateTime}, Int64), instance, _timespan)
        ret2 = convert_if_not_null(GDateTime, ret, true)
        ret2
    end
    function add_days(instance::GDateTime, _days::Integer)
        ret = ccall(("g_date_time_add_days", libglib), Ptr{GDateTime}, (Ptr{GDateTime}, Int32), instance, _days)
        ret2 = convert_if_not_null(GDateTime, ret, true)
        ret2
    end
    function add_full(instance::GDateTime, _years::Integer, _months::Integer, _days::Integer, _hours::Integer, _minutes::Integer, _seconds::Real)
        ret = ccall(("g_date_time_add_full", libglib), Ptr{GDateTime}, (Ptr{GDateTime}, Int32, Int32, Int32, Int32, Int32, Float64), instance, _years, _months, _days, _hours, _minutes, _seconds)
        ret2 = convert_if_not_null(GDateTime, ret, true)
        ret2
    end
    function add_hours(instance::GDateTime, _hours::Integer)
        ret = ccall(("g_date_time_add_hours", libglib), Ptr{GDateTime}, (Ptr{GDateTime}, Int32), instance, _hours)
        ret2 = convert_if_not_null(GDateTime, ret, true)
        ret2
    end
    function add_minutes(instance::GDateTime, _minutes::Integer)
        ret = ccall(("g_date_time_add_minutes", libglib), Ptr{GDateTime}, (Ptr{GDateTime}, Int32), instance, _minutes)
        ret2 = convert_if_not_null(GDateTime, ret, true)
        ret2
    end
    function add_months(instance::GDateTime, _months::Integer)
        ret = ccall(("g_date_time_add_months", libglib), Ptr{GDateTime}, (Ptr{GDateTime}, Int32), instance, _months)
        ret2 = convert_if_not_null(GDateTime, ret, true)
        ret2
    end
    function add_seconds(instance::GDateTime, _seconds::Real)
        ret = ccall(("g_date_time_add_seconds", libglib), Ptr{GDateTime}, (Ptr{GDateTime}, Float64), instance, _seconds)
        ret2 = convert_if_not_null(GDateTime, ret, true)
        ret2
    end
    function add_weeks(instance::GDateTime, _weeks::Integer)
        ret = ccall(("g_date_time_add_weeks", libglib), Ptr{GDateTime}, (Ptr{GDateTime}, Int32), instance, _weeks)
        ret2 = convert_if_not_null(GDateTime, ret, true)
        ret2
    end
    function add_years(instance::GDateTime, _years::Integer)
        ret = ccall(("g_date_time_add_years", libglib), Ptr{GDateTime}, (Ptr{GDateTime}, Int32), instance, _years)
        ret2 = convert_if_not_null(GDateTime, ret, true)
        ret2
    end
    function compare(instance::GDateTime, _dt2::GDateTime)
        ret = ccall(("g_date_time_compare", libglib), Int32, (Ptr{GDateTime}, Ptr{GDateTime}), instance, _dt2)
        ret
    end
    function difference(instance::GDateTime, _begin::GDateTime)
        ret = ccall(("g_date_time_difference", libglib), Int64, (Ptr{GDateTime}, Ptr{GDateTime}), instance, _begin)
        ret
    end
    function equal(instance::GDateTime, _dt2::GDateTime)
        ret = ccall(("g_date_time_equal", libglib), Cint, (Ptr{GDateTime}, Ptr{GDateTime}), instance, _dt2)
        ret2 = convert(Bool, ret)
        ret2
    end
    function format(instance::GDateTime, _format::Union{AbstractString, Symbol})
        ret = ccall(("g_date_time_format", libglib), Cstring, (Ptr{GDateTime}, Cstring), instance, _format)
        ret2 = string_or_nothing(ret, true)
        ret2
    end
    function format_iso8601(instance::GDateTime)
        ret = ccall(("g_date_time_format_iso8601", libglib), Cstring, (Ptr{GDateTime},), instance)
        ret2 = string_or_nothing(ret, true)
        ret2
    end
    function get_day_of_month(instance::GDateTime)
        ret = ccall(("g_date_time_get_day_of_month", libglib), Int32, (Ptr{GDateTime},), instance)
        ret
    end
    function get_day_of_week(instance::GDateTime)
        ret = ccall(("g_date_time_get_day_of_week", libglib), Int32, (Ptr{GDateTime},), instance)
        ret
    end
    function get_day_of_year(instance::GDateTime)
        ret = ccall(("g_date_time_get_day_of_year", libglib), Int32, (Ptr{GDateTime},), instance)
        ret
    end
    function get_hour(instance::GDateTime)
        ret = ccall(("g_date_time_get_hour", libglib), Int32, (Ptr{GDateTime},), instance)
        ret
    end
    function get_microsecond(instance::GDateTime)
        ret = ccall(("g_date_time_get_microsecond", libglib), Int32, (Ptr{GDateTime},), instance)
        ret
    end
    function get_minute(instance::GDateTime)
        ret = ccall(("g_date_time_get_minute", libglib), Int32, (Ptr{GDateTime},), instance)
        ret
    end
    function get_month(instance::GDateTime)
        ret = ccall(("g_date_time_get_month", libglib), Int32, (Ptr{GDateTime},), instance)
        ret
    end
    function get_second(instance::GDateTime)
        ret = ccall(("g_date_time_get_second", libglib), Int32, (Ptr{GDateTime},), instance)
        ret
    end
    function get_seconds(instance::GDateTime)
        ret = ccall(("g_date_time_get_seconds", libglib), Float64, (Ptr{GDateTime},), instance)
        ret
    end
    function get_timezone(instance::GDateTime)
        ret = ccall(("g_date_time_get_timezone", libglib), Ptr{GTimeZone}, (Ptr{GDateTime},), instance)
        ret2 = convert(GTimeZone, ret, false)
        ret2
    end
    function get_timezone_abbreviation(instance::GDateTime)
        ret = ccall(("g_date_time_get_timezone_abbreviation", libglib), Cstring, (Ptr{GDateTime},), instance)
        ret2 = string_or_nothing(ret, false)
        ret2
    end
    function get_utc_offset(instance::GDateTime)
        ret = ccall(("g_date_time_get_utc_offset", libglib), Int64, (Ptr{GDateTime},), instance)
        ret
    end
    function get_week_numbering_year(instance::GDateTime)
        ret = ccall(("g_date_time_get_week_numbering_year", libglib), Int32, (Ptr{GDateTime},), instance)
        ret
    end
    function get_week_of_year(instance::GDateTime)
        ret = ccall(("g_date_time_get_week_of_year", libglib), Int32, (Ptr{GDateTime},), instance)
        ret
    end
    function get_year(instance::GDateTime)
        ret = ccall(("g_date_time_get_year", libglib), Int32, (Ptr{GDateTime},), instance)
        ret
    end
    function get_ymd(instance::GDateTime)
        m_year = Ref{Int32}()
        m_month = Ref{Int32}()
        m_day = Ref{Int32}()
        ret = ccall(("g_date_time_get_ymd", libglib), Nothing, (Ptr{GDateTime}, Ptr{Int32}, Ptr{Int32}, Ptr{Int32}), instance, m_year, m_month, m_day)
        _year = m_year[]
        _month = m_month[]
        _day = m_day[]
        (_year, _month, _day)
    end
    function hash(instance::GDateTime)
        ret = ccall(("g_date_time_hash", libglib), UInt32, (Ptr{GDateTime},), instance)
        ret
    end
    function is_daylight_savings(instance::GDateTime)
        ret = ccall(("g_date_time_is_daylight_savings", libglib), Cint, (Ptr{GDateTime},), instance)
        ret2 = convert(Bool, ret)
        ret2
    end
    function ref(instance::GDateTime)
        ret = ccall(("g_date_time_ref", libglib), Ptr{GDateTime}, (Ptr{GDateTime},), instance)
        ret2 = convert(GDateTime, ret, true)
        ret2
    end
    function to_local(instance::GDateTime)
        ret = ccall(("g_date_time_to_local", libglib), Ptr{GDateTime}, (Ptr{GDateTime},), instance)
        ret2 = convert_if_not_null(GDateTime, ret, true)
        ret2
    end
    function to_timezone(instance::GDateTime, _tz::GTimeZone)
        ret = ccall(("g_date_time_to_timezone", libglib), Ptr{GDateTime}, (Ptr{GDateTime}, Ptr{GTimeZone}), instance, _tz)
        ret2 = convert_if_not_null(GDateTime, ret, true)
        ret2
    end
    function to_unix(instance::GDateTime)
        ret = ccall(("g_date_time_to_unix", libglib), Int64, (Ptr{GDateTime},), instance)
        ret
    end
    function to_unix_usec(instance::GDateTime)
        ret = ccall(("g_date_time_to_unix_usec", libglib), Int64, (Ptr{GDateTime},), instance)
        ret
    end
    function to_utc(instance::GDateTime)
        ret = ccall(("g_date_time_to_utc", libglib), Ptr{GDateTime}, (Ptr{GDateTime},), instance)
        ret2 = convert_if_not_null(GDateTime, ret, true)
        ret2
    end
    function unref(instance::GDateTime)
        ret = ccall(("g_date_time_unref", libglib), Nothing, (Ptr{GDateTime},), instance)
        nothing
    end
    function Dir_open(_path::Union{AbstractString, Symbol}, _flags::Integer)
        err = err_buf()
        ret = ccall(("g_dir_open", libglib), Ptr{GDir}, (Cstring, UInt32, Ptr{Ptr{GError}}), _path, _flags, err)
        check_err(err)
        ret2 = convert(GDir, ret, true)
        ret2
    end
    function close(instance::GDir)
        reffed_instance = GLib.glib_ref(instance)
        ret = ccall(("g_dir_close", libglib), Nothing, (Ptr{GDir},), reffed_instance)
        nothing
    end
    function read_name(instance::GDir)
        ret = ccall(("g_dir_read_name", libglib), Cstring, (Ptr{GDir},), instance)
        ret2 = string_or_nothing(ret, false)
        ret2
    end
    function ref(instance::GDir)
        ret = ccall(("g_dir_ref", libglib), Ptr{GDir}, (Ptr{GDir},), instance)
        ret2 = convert(GDir, ret, true)
        ret2
    end
    function rewind(instance::GDir)
        ret = ccall(("g_dir_rewind", libglib), Nothing, (Ptr{GDir},), instance)
        nothing
    end
    function unref(instance::GDir)
        reffed_instance = GLib.glib_ref(instance)
        ret = ccall(("g_dir_unref", libglib), Nothing, (Ptr{GDir},), reffed_instance)
        nothing
    end
    function Hmac_new(_digest_type, _key::UInt8, _key_len::Integer)
        ret = ccall(("g_hmac_new", libglib), Ptr{GHmac}, (UInt32, Ptr{UInt8}, UInt64), _digest_type, _key, _key_len)
        ret2 = convert(GHmac, ret, true)
        ret2
    end
    function copy(instance::GHmac)
        ret = ccall(("g_hmac_copy", libglib), Ptr{GHmac}, (Ptr{GHmac},), instance)
        ret2 = convert(GHmac, ret, true)
        ret2
    end
    function get_digest(instance::GHmac, _buffer::UInt8, _digest_len::UInt64)
        ret = ccall(("g_hmac_get_digest", libglib), Nothing, (Ptr{GHmac}, Ptr{UInt8}, Ptr{UInt64}), instance, _buffer, _digest_len)
        nothing
    end
    function get_string(instance::GHmac)
        ret = ccall(("g_hmac_get_string", libglib), Cstring, (Ptr{GHmac},), instance)
        ret2 = string_or_nothing(ret, false)
        ret2
    end
    function ref(instance::GHmac)
        ret = ccall(("g_hmac_ref", libglib), Ptr{GHmac}, (Ptr{GHmac},), instance)
        ret2 = convert(GHmac, ret, true)
        ret2
    end
    function unref(instance::GHmac)
        ret = ccall(("g_hmac_unref", libglib), Nothing, (Ptr{GHmac},), instance)
        nothing
    end
    function update(instance::GHmac, _data::UInt8, _length::Integer)
        ret = ccall(("g_hmac_update", libglib), Nothing, (Ptr{GHmac}, Ptr{UInt8}, Int64), instance, _data, _length)
        nothing
    end
    function KeyFile_new()
        ret = ccall(("g_key_file_new", libglib), Ptr{GKeyFile}, ())
        ret2 = convert(GKeyFile, ret, true)
        ret2
    end
    function get_boolean(instance::GKeyFile, _group_name::Union{AbstractString, Symbol}, _key::Union{AbstractString, Symbol})
        err = err_buf()
        ret = ccall(("g_key_file_get_boolean", libglib), Cint, (Ptr{GKeyFile}, Cstring, Cstring, Ptr{Ptr{GError}}), instance, _group_name, _key, err)
        check_err(err)
        ret2 = convert(Bool, ret)
        ret2
    end
    function get_boolean_list(instance::GKeyFile, _group_name::Union{AbstractString, Symbol}, _key::Union{AbstractString, Symbol})
        m_length = Ref{UInt64}()
        err = err_buf()
        ret = ccall(("g_key_file_get_boolean_list", libglib), Ptr{Cint}, (Ptr{GKeyFile}, Cstring, Cstring, Ptr{UInt64}, Ptr{Ptr{GError}}), instance, _group_name, _key, m_length, err)
        check_err(err)
        ret2 = begin
                arrtemp = collect(unsafe_wrap(Vector{Cint}, ret, m_length[]))
                GLib.g_free(ret)
                arrtemp
            end
        _length = m_length[]
        ret2
    end
    function get_comment(instance::GKeyFile, _group_name::Maybe(Union{AbstractString, Symbol}), _key::Maybe(Union{AbstractString, Symbol}))
        _group_name_maybe = nothing_to_null(_group_name)
        _key_maybe = nothing_to_null(_key)
        err = err_buf()
        ret = ccall(("g_key_file_get_comment", libglib), Cstring, (Ptr{GKeyFile}, Cstring, Cstring, Ptr{Ptr{GError}}), instance, _group_name_maybe, _key_maybe, err)
        check_err(err)
        ret2 = string_or_nothing(ret, true)
        ret2
    end
    function get_double(instance::GKeyFile, _group_name::Union{AbstractString, Symbol}, _key::Union{AbstractString, Symbol})
        err = err_buf()
        ret = ccall(("g_key_file_get_double", libglib), Float64, (Ptr{GKeyFile}, Cstring, Cstring, Ptr{Ptr{GError}}), instance, _group_name, _key, err)
        check_err(err)
        ret
    end
    function get_double_list(instance::GKeyFile, _group_name::Union{AbstractString, Symbol}, _key::Union{AbstractString, Symbol})
        m_length = Ref{UInt64}()
        err = err_buf()
        ret = ccall(("g_key_file_get_double_list", libglib), Ptr{Float64}, (Ptr{GKeyFile}, Cstring, Cstring, Ptr{UInt64}, Ptr{Ptr{GError}}), instance, _group_name, _key, m_length, err)
        check_err(err)
        ret2 = begin
                arrtemp = collect(unsafe_wrap(Vector{Float64}, ret, m_length[]))
                GLib.g_free(ret)
                arrtemp
            end
        _length = m_length[]
        ret2
    end
    function get_groups(instance::GKeyFile)
        m_length = Ref{UInt64}()
        ret = ccall(("g_key_file_get_groups", libglib), Ptr{Cstring}, (Ptr{GKeyFile}, Ptr{UInt64}), instance, m_length)
        ret2 = begin
                _len = length_zt(ret)
                arrtemp = bytestring.(unsafe_wrap(Vector{Cstring}, ret, _len))
                GLib.g_strfreev(ret)
                arrtemp
            end
        _length = m_length[]
        (ret2, _length)
    end
    function get_int64(instance::GKeyFile, _group_name::Union{AbstractString, Symbol}, _key::Union{AbstractString, Symbol})
        err = err_buf()
        ret = ccall(("g_key_file_get_int64", libglib), Int64, (Ptr{GKeyFile}, Cstring, Cstring, Ptr{Ptr{GError}}), instance, _group_name, _key, err)
        check_err(err)
        ret
    end
    function get_integer(instance::GKeyFile, _group_name::Union{AbstractString, Symbol}, _key::Union{AbstractString, Symbol})
        err = err_buf()
        ret = ccall(("g_key_file_get_integer", libglib), Int32, (Ptr{GKeyFile}, Cstring, Cstring, Ptr{Ptr{GError}}), instance, _group_name, _key, err)
        check_err(err)
        ret
    end
    function get_integer_list(instance::GKeyFile, _group_name::Union{AbstractString, Symbol}, _key::Union{AbstractString, Symbol})
        m_length = Ref{UInt64}()
        err = err_buf()
        ret = ccall(("g_key_file_get_integer_list", libglib), Ptr{Int32}, (Ptr{GKeyFile}, Cstring, Cstring, Ptr{UInt64}, Ptr{Ptr{GError}}), instance, _group_name, _key, m_length, err)
        check_err(err)
        ret2 = begin
                arrtemp = collect(unsafe_wrap(Vector{Int32}, ret, m_length[]))
                GLib.g_free(ret)
                arrtemp
            end
        _length = m_length[]
        ret2
    end
    function get_keys(instance::GKeyFile, _group_name::Union{AbstractString, Symbol})
        m_length = Ref{UInt64}()
        err = err_buf()
        ret = ccall(("g_key_file_get_keys", libglib), Ptr{Cstring}, (Ptr{GKeyFile}, Cstring, Ptr{UInt64}, Ptr{Ptr{GError}}), instance, _group_name, m_length, err)
        check_err(err)
        ret2 = begin
                _len = length_zt(ret)
                arrtemp = bytestring.(unsafe_wrap(Vector{Cstring}, ret, _len))
                GLib.g_strfreev(ret)
                arrtemp
            end
        _length = m_length[]
        (ret2, _length)
    end
    function get_locale_for_key(instance::GKeyFile, _group_name::Union{AbstractString, Symbol}, _key::Union{AbstractString, Symbol}, _locale::Maybe(Union{AbstractString, Symbol}))
        _locale_maybe = nothing_to_null(_locale)
        ret = ccall(("g_key_file_get_locale_for_key", libglib), Cstring, (Ptr{GKeyFile}, Cstring, Cstring, Cstring), instance, _group_name, _key, _locale_maybe)
        ret2 = string_or_nothing(ret, true)
        ret2
    end
    function get_locale_string(instance::GKeyFile, _group_name::Union{AbstractString, Symbol}, _key::Union{AbstractString, Symbol}, _locale::Maybe(Union{AbstractString, Symbol}))
        _locale_maybe = nothing_to_null(_locale)
        err = err_buf()
        ret = ccall(("g_key_file_get_locale_string", libglib), Cstring, (Ptr{GKeyFile}, Cstring, Cstring, Cstring, Ptr{Ptr{GError}}), instance, _group_name, _key, _locale_maybe, err)
        check_err(err)
        ret2 = string_or_nothing(ret, true)
        ret2
    end
    function get_locale_string_list(instance::GKeyFile, _group_name::Union{AbstractString, Symbol}, _key::Union{AbstractString, Symbol}, _locale::Maybe(Union{AbstractString, Symbol}))
        _locale_maybe = nothing_to_null(_locale)
        m_length = Ref{UInt64}()
        err = err_buf()
        ret = ccall(("g_key_file_get_locale_string_list", libglib), Ptr{Cstring}, (Ptr{GKeyFile}, Cstring, Cstring, Cstring, Ptr{UInt64}, Ptr{Ptr{GError}}), instance, _group_name, _key, _locale_maybe, m_length, err)
        check_err(err)
        ret2 = begin
                _len = length_zt(ret)
                arrtemp = bytestring.(unsafe_wrap(Vector{Cstring}, ret, _len))
                GLib.g_strfreev(ret)
                arrtemp
            end
        _length = m_length[]
        ret2
    end
    function get_start_group(instance::GKeyFile)
        ret = ccall(("g_key_file_get_start_group", libglib), Cstring, (Ptr{GKeyFile},), instance)
        ret2 = string_or_nothing(ret, true)
        ret2
    end
    function get_string(instance::GKeyFile, _group_name::Union{AbstractString, Symbol}, _key::Union{AbstractString, Symbol})
        err = err_buf()
        ret = ccall(("g_key_file_get_string", libglib), Cstring, (Ptr{GKeyFile}, Cstring, Cstring, Ptr{Ptr{GError}}), instance, _group_name, _key, err)
        check_err(err)
        ret2 = string_or_nothing(ret, true)
        ret2
    end
    function get_string_list(instance::GKeyFile, _group_name::Union{AbstractString, Symbol}, _key::Union{AbstractString, Symbol})
        m_length = Ref{UInt64}()
        err = err_buf()
        ret = ccall(("g_key_file_get_string_list", libglib), Ptr{Cstring}, (Ptr{GKeyFile}, Cstring, Cstring, Ptr{UInt64}, Ptr{Ptr{GError}}), instance, _group_name, _key, m_length, err)
        check_err(err)
        ret2 = begin
                _len = length_zt(ret)
                arrtemp = bytestring.(unsafe_wrap(Vector{Cstring}, ret, _len))
                GLib.g_strfreev(ret)
                arrtemp
            end
        _length = m_length[]
        ret2
    end
    function get_uint64(instance::GKeyFile, _group_name::Union{AbstractString, Symbol}, _key::Union{AbstractString, Symbol})
        err = err_buf()
        ret = ccall(("g_key_file_get_uint64", libglib), UInt64, (Ptr{GKeyFile}, Cstring, Cstring, Ptr{Ptr{GError}}), instance, _group_name, _key, err)
        check_err(err)
        ret
    end
    function get_value(instance::GKeyFile, _group_name::Union{AbstractString, Symbol}, _key::Union{AbstractString, Symbol})
        err = err_buf()
        ret = ccall(("g_key_file_get_value", libglib), Cstring, (Ptr{GKeyFile}, Cstring, Cstring, Ptr{Ptr{GError}}), instance, _group_name, _key, err)
        check_err(err)
        ret2 = string_or_nothing(ret, true)
        ret2
    end
    function has_group(instance::GKeyFile, _group_name::Union{AbstractString, Symbol})
        ret = ccall(("g_key_file_has_group", libglib), Cint, (Ptr{GKeyFile}, Cstring), instance, _group_name)
        ret2 = convert(Bool, ret)
        ret2
    end
    function load_from_bytes(instance::GKeyFile, _bytes::GBytes, _flags)
        err = err_buf()
        ret = ccall(("g_key_file_load_from_bytes", libglib), Cint, (Ptr{GKeyFile}, Ptr{GBytes}, UInt32, Ptr{Ptr{GError}}), instance, _bytes, _flags, err)
        check_err(err)
        ret2 = convert(Bool, ret)
        ret2
    end
    function load_from_data(instance::GKeyFile, _data::Union{AbstractString, Symbol}, _length::Integer, _flags)
        err = err_buf()
        ret = ccall(("g_key_file_load_from_data", libglib), Cint, (Ptr{GKeyFile}, Cstring, UInt64, UInt32, Ptr{Ptr{GError}}), instance, _data, _length, _flags, err)
        check_err(err)
        ret2 = convert(Bool, ret)
        ret2
    end
    function load_from_data_dirs(instance::GKeyFile, _file::Union{AbstractString, Symbol}, _flags)
        m_full_path = Ref{Cstring}()
        err = err_buf()
        ret = ccall(("g_key_file_load_from_data_dirs", libglib), Cint, (Ptr{GKeyFile}, Cstring, Ptr{Cstring}, UInt32, Ptr{Ptr{GError}}), instance, _file, m_full_path, _flags, err)
        check_err(err)
        ret2 = convert(Bool, ret)
        _full_path = m_full_path[]
        _full_path = string_or_nothing(_full_path, true)
        (ret2, _full_path)
    end
    function load_from_dirs(instance::GKeyFile, _file::Union{AbstractString, Symbol}, _search_dirs, _flags)
        m_full_path = Ref{Cstring}()
        err = err_buf()
        ret = ccall(("g_key_file_load_from_dirs", libglib), Cint, (Ptr{GKeyFile}, Cstring, Ptr{Cstring}, Ptr{Cstring}, UInt32, Ptr{Ptr{GError}}), instance, _file, _search_dirs, m_full_path, _flags, err)
        check_err(err)
        ret2 = convert(Bool, ret)
        _full_path = m_full_path[]
        _full_path = string_or_nothing(_full_path, true)
        (ret2, _full_path)
    end
    function load_from_file(instance::GKeyFile, _file::Union{AbstractString, Symbol}, _flags)
        err = err_buf()
        ret = ccall(("g_key_file_load_from_file", libglib), Cint, (Ptr{GKeyFile}, Cstring, UInt32, Ptr{Ptr{GError}}), instance, _file, _flags, err)
        check_err(err)
        ret2 = convert(Bool, ret)
        ret2
    end
    function remove_comment(instance::GKeyFile, _group_name::Maybe(Union{AbstractString, Symbol}), _key::Maybe(Union{AbstractString, Symbol}))
        _group_name_maybe = nothing_to_null(_group_name)
        _key_maybe = nothing_to_null(_key)
        err = err_buf()
        ret = ccall(("g_key_file_remove_comment", libglib), Cint, (Ptr{GKeyFile}, Cstring, Cstring, Ptr{Ptr{GError}}), instance, _group_name_maybe, _key_maybe, err)
        check_err(err)
        ret2 = convert(Bool, ret)
        ret2
    end
    function remove_group(instance::GKeyFile, _group_name::Union{AbstractString, Symbol})
        err = err_buf()
        ret = ccall(("g_key_file_remove_group", libglib), Cint, (Ptr{GKeyFile}, Cstring, Ptr{Ptr{GError}}), instance, _group_name, err)
        check_err(err)
        ret2 = convert(Bool, ret)
        ret2
    end
    function remove_key(instance::GKeyFile, _group_name::Union{AbstractString, Symbol}, _key::Union{AbstractString, Symbol})
        err = err_buf()
        ret = ccall(("g_key_file_remove_key", libglib), Cint, (Ptr{GKeyFile}, Cstring, Cstring, Ptr{Ptr{GError}}), instance, _group_name, _key, err)
        check_err(err)
        ret2 = convert(Bool, ret)
        ret2
    end
    function save_to_file(instance::GKeyFile, _filename::Union{AbstractString, Symbol})
        err = err_buf()
        ret = ccall(("g_key_file_save_to_file", libglib), Cint, (Ptr{GKeyFile}, Cstring, Ptr{Ptr{GError}}), instance, _filename, err)
        check_err(err)
        ret2 = convert(Bool, ret)
        ret2
    end
    function set_boolean(instance::GKeyFile, _group_name::Union{AbstractString, Symbol}, _key::Union{AbstractString, Symbol}, _value::Bool)
        ret = ccall(("g_key_file_set_boolean", libglib), Nothing, (Ptr{GKeyFile}, Cstring, Cstring, Cint), instance, _group_name, _key, _value)
        nothing
    end
    function set_boolean_list(instance::GKeyFile, _group_name::Union{AbstractString, Symbol}, _key::Union{AbstractString, Symbol}, _list)
        _list_arr = convert(Vector{Cint}, _list)
        _length = length(_list)
        ret = ccall(("g_key_file_set_boolean_list", libglib), Nothing, (Ptr{GKeyFile}, Cstring, Cstring, Ptr{Cint}, UInt64), instance, _group_name, _key, _list_arr, _length)
        nothing
    end
    function set_comment(instance::GKeyFile, _group_name::Maybe(Union{AbstractString, Symbol}), _key::Maybe(Union{AbstractString, Symbol}), _comment::Union{AbstractString, Symbol})
        _group_name_maybe = nothing_to_null(_group_name)
        _key_maybe = nothing_to_null(_key)
        err = err_buf()
        ret = ccall(("g_key_file_set_comment", libglib), Cint, (Ptr{GKeyFile}, Cstring, Cstring, Cstring, Ptr{Ptr{GError}}), instance, _group_name_maybe, _key_maybe, _comment, err)
        check_err(err)
        ret2 = convert(Bool, ret)
        ret2
    end
    function set_double(instance::GKeyFile, _group_name::Union{AbstractString, Symbol}, _key::Union{AbstractString, Symbol}, _value::Real)
        ret = ccall(("g_key_file_set_double", libglib), Nothing, (Ptr{GKeyFile}, Cstring, Cstring, Float64), instance, _group_name, _key, _value)
        nothing
    end
    function set_double_list(instance::GKeyFile, _group_name::Union{AbstractString, Symbol}, _key::Union{AbstractString, Symbol}, _list)
        _list_arr = convert(Vector{Float64}, _list)
        _length = length(_list)
        ret = ccall(("g_key_file_set_double_list", libglib), Nothing, (Ptr{GKeyFile}, Cstring, Cstring, Ptr{Float64}, UInt64), instance, _group_name, _key, _list_arr, _length)
        nothing
    end
    function set_int64(instance::GKeyFile, _group_name::Union{AbstractString, Symbol}, _key::Union{AbstractString, Symbol}, _value::Integer)
        ret = ccall(("g_key_file_set_int64", libglib), Nothing, (Ptr{GKeyFile}, Cstring, Cstring, Int64), instance, _group_name, _key, _value)
        nothing
    end
    function set_integer(instance::GKeyFile, _group_name::Union{AbstractString, Symbol}, _key::Union{AbstractString, Symbol}, _value::Integer)
        ret = ccall(("g_key_file_set_integer", libglib), Nothing, (Ptr{GKeyFile}, Cstring, Cstring, Int32), instance, _group_name, _key, _value)
        nothing
    end
    function set_integer_list(instance::GKeyFile, _group_name::Union{AbstractString, Symbol}, _key::Union{AbstractString, Symbol}, _list)
        _list_arr = convert(Vector{Int32}, _list)
        _length = length(_list)
        ret = ccall(("g_key_file_set_integer_list", libglib), Nothing, (Ptr{GKeyFile}, Cstring, Cstring, Ptr{Int32}, UInt64), instance, _group_name, _key, _list_arr, _length)
        nothing
    end
    function set_list_separator(instance::GKeyFile, _separator::Integer)
        ret = ccall(("g_key_file_set_list_separator", libglib), Nothing, (Ptr{GKeyFile}, Int8), instance, _separator)
        nothing
    end
    function set_locale_string(instance::GKeyFile, _group_name::Union{AbstractString, Symbol}, _key::Union{AbstractString, Symbol}, _locale::Union{AbstractString, Symbol}, _string::Union{AbstractString, Symbol})
        ret = ccall(("g_key_file_set_locale_string", libglib), Nothing, (Ptr{GKeyFile}, Cstring, Cstring, Cstring, Cstring), instance, _group_name, _key, _locale, _string)
        nothing
    end
    function set_locale_string_list(instance::GKeyFile, _group_name::Union{AbstractString, Symbol}, _key::Union{AbstractString, Symbol}, _locale::Union{AbstractString, Symbol}, _list)
        _length = length(_list)
        ret = ccall(("g_key_file_set_locale_string_list", libglib), Nothing, (Ptr{GKeyFile}, Cstring, Cstring, Cstring, Ptr{Cstring}, UInt64), instance, _group_name, _key, _locale, _list, _length)
        nothing
    end
    function set_string(instance::GKeyFile, _group_name::Union{AbstractString, Symbol}, _key::Union{AbstractString, Symbol}, _string::Union{AbstractString, Symbol})
        ret = ccall(("g_key_file_set_string", libglib), Nothing, (Ptr{GKeyFile}, Cstring, Cstring, Cstring), instance, _group_name, _key, _string)
        nothing
    end
    function set_string_list(instance::GKeyFile, _group_name::Union{AbstractString, Symbol}, _key::Union{AbstractString, Symbol}, _list)
        _length = length(_list)
        ret = ccall(("g_key_file_set_string_list", libglib), Nothing, (Ptr{GKeyFile}, Cstring, Cstring, Ptr{Cstring}, UInt64), instance, _group_name, _key, _list, _length)
        nothing
    end
    function set_uint64(instance::GKeyFile, _group_name::Union{AbstractString, Symbol}, _key::Union{AbstractString, Symbol}, _value::Integer)
        ret = ccall(("g_key_file_set_uint64", libglib), Nothing, (Ptr{GKeyFile}, Cstring, Cstring, UInt64), instance, _group_name, _key, _value)
        nothing
    end
    function set_value(instance::GKeyFile, _group_name::Union{AbstractString, Symbol}, _key::Union{AbstractString, Symbol}, _value::Union{AbstractString, Symbol})
        ret = ccall(("g_key_file_set_value", libglib), Nothing, (Ptr{GKeyFile}, Cstring, Cstring, Cstring), instance, _group_name, _key, _value)
        nothing
    end
    function to_data(instance::GKeyFile)
        m_length = Ref{UInt64}()
        err = err_buf()
        ret = ccall(("g_key_file_to_data", libglib), Cstring, (Ptr{GKeyFile}, Ptr{UInt64}, Ptr{Ptr{GError}}), instance, m_length, err)
        check_err(err)
        ret2 = string_or_nothing(ret, true)
        _length = m_length[]
        (ret2, _length)
    end
    function unref(instance::GKeyFile)
        ret = ccall(("g_key_file_unref", libglib), Nothing, (Ptr{GKeyFile},), instance)
        nothing
    end
    function MainContext_new()
        ret = ccall(("g_main_context_new", libglib), Ptr{GMainContext}, ())
        ret2 = convert(GMainContext, ret, true)
        ret2
    end
    function MainContext_new_with_flags(_flags)
        ret = ccall(("g_main_context_new_with_flags", libglib), Ptr{GMainContext}, (UInt32,), _flags)
        ret2 = convert(GMainContext, ret, true)
        ret2
    end
    function acquire(instance::GMainContext)
        ret = ccall(("g_main_context_acquire", libglib), Cint, (Ptr{GMainContext},), instance)
        ret2 = convert(Bool, ret)
        ret2
    end
    function dispatch(instance::GMainContext)
        ret = ccall(("g_main_context_dispatch", libglib), Nothing, (Ptr{GMainContext},), instance)
        nothing
    end
    function is_owner(instance::GMainContext)
        ret = ccall(("g_main_context_is_owner", libglib), Cint, (Ptr{GMainContext},), instance)
        ret2 = convert(Bool, ret)
        ret2
    end
    function iteration(instance::GMainContext, _may_block::Bool)
        ret = ccall(("g_main_context_iteration", libglib), Cint, (Ptr{GMainContext}, Cint), instance, _may_block)
        ret2 = convert(Bool, ret)
        ret2
    end
    function pending(instance::GMainContext)
        ret = ccall(("g_main_context_pending", libglib), Cint, (Ptr{GMainContext},), instance)
        ret2 = convert(Bool, ret)
        ret2
    end
    function pop_thread_default(instance::GMainContext)
        ret = ccall(("g_main_context_pop_thread_default", libglib), Nothing, (Ptr{GMainContext},), instance)
        nothing
    end
    function prepare(instance::GMainContext)
        m_priority = Ref{Int32}()
        ret = ccall(("g_main_context_prepare", libglib), Cint, (Ptr{GMainContext}, Ptr{Int32}), instance, m_priority)
        ret2 = convert(Bool, ret)
        _priority = m_priority[]
        (ret2, _priority)
    end
    function push_thread_default(instance::GMainContext)
        ret = ccall(("g_main_context_push_thread_default", libglib), Nothing, (Ptr{GMainContext},), instance)
        nothing
    end
    function ref(instance::GMainContext)
        ret = ccall(("g_main_context_ref", libglib), Ptr{GMainContext}, (Ptr{GMainContext},), instance)
        ret2 = convert(GMainContext, ret, true)
        ret2
    end
    function release(instance::GMainContext)
        ret = ccall(("g_main_context_release", libglib), Nothing, (Ptr{GMainContext},), instance)
        nothing
    end
    function unref(instance::GMainContext)
        ret = ccall(("g_main_context_unref", libglib), Nothing, (Ptr{GMainContext},), instance)
        nothing
    end
    function wakeup(instance::GMainContext)
        ret = ccall(("g_main_context_wakeup", libglib), Nothing, (Ptr{GMainContext},), instance)
        nothing
    end
    function MainLoop_new(_context::Maybe(GMainContext), _is_running::Bool)
        _context_maybe = nothing_to_null(_context)
        ret = ccall(("g_main_loop_new", libglib), Ptr{GMainLoop}, (Ptr{GMainContext}, Cint), _context_maybe, _is_running)
        ret2 = convert(GMainLoop, ret, true)
        ret2
    end
    function get_context(instance::GMainLoop)
        ret = ccall(("g_main_loop_get_context", libglib), Ptr{GMainContext}, (Ptr{GMainLoop},), instance)
        ret2 = convert(GMainContext, ret, false)
        ret2
    end
    function is_running(instance::GMainLoop)
        ret = ccall(("g_main_loop_is_running", libglib), Cint, (Ptr{GMainLoop},), instance)
        ret2 = convert(Bool, ret)
        ret2
    end
    function quit(instance::GMainLoop)
        ret = ccall(("g_main_loop_quit", libglib), Nothing, (Ptr{GMainLoop},), instance)
        nothing
    end
    function ref(instance::GMainLoop)
        ret = ccall(("g_main_loop_ref", libglib), Ptr{GMainLoop}, (Ptr{GMainLoop},), instance)
        ret2 = convert(GMainLoop, ret, true)
        ret2
    end
    function run(instance::GMainLoop)
        ret = ccall(("g_main_loop_run", libglib), Nothing, (Ptr{GMainLoop},), instance)
        nothing
    end
    function unref(instance::GMainLoop)
        ret = ccall(("g_main_loop_unref", libglib), Nothing, (Ptr{GMainLoop},), instance)
        nothing
    end
    function MappedFile_new(_filename::Union{AbstractString, Symbol}, _writable::Bool)
        err = err_buf()
        ret = ccall(("g_mapped_file_new", libglib), Ptr{GMappedFile}, (Cstring, Cint, Ptr{Ptr{GError}}), _filename, _writable, err)
        check_err(err)
        ret2 = convert(GMappedFile, ret, true)
        ret2
    end
    function MappedFile_new_from_fd(_fd::Integer, _writable::Bool)
        err = err_buf()
        ret = ccall(("g_mapped_file_new_from_fd", libglib), Ptr{GMappedFile}, (Int32, Cint, Ptr{Ptr{GError}}), _fd, _writable, err)
        check_err(err)
        ret2 = convert(GMappedFile, ret, true)
        ret2
    end
    function get_bytes(instance::GMappedFile)
        ret = ccall(("g_mapped_file_get_bytes", libglib), Ptr{GBytes}, (Ptr{GMappedFile},), instance)
        ret2 = convert(GBytes, ret, true)
        ret2
    end
    function get_contents(instance::GMappedFile)
        ret = ccall(("g_mapped_file_get_contents", libglib), Cstring, (Ptr{GMappedFile},), instance)
        ret2 = string_or_nothing(ret, false)
        ret2
    end
    function get_length(instance::GMappedFile)
        ret = ccall(("g_mapped_file_get_length", libglib), UInt64, (Ptr{GMappedFile},), instance)
        ret
    end
    function ref(instance::GMappedFile)
        ret = ccall(("g_mapped_file_ref", libglib), Ptr{GMappedFile}, (Ptr{GMappedFile},), instance)
        ret2 = convert(GMappedFile, ret, true)
        ret2
    end
    function unref(instance::GMappedFile)
        ret = ccall(("g_mapped_file_unref", libglib), Nothing, (Ptr{GMappedFile},), instance)
        nothing
    end
    function expand_references(instance::GMatchInfo, _string_to_expand::Union{AbstractString, Symbol})
        err = err_buf()
        ret = ccall(("g_match_info_expand_references", libglib), Cstring, (Ptr{GMatchInfo}, Cstring, Ptr{Ptr{GError}}), instance, _string_to_expand, err)
        check_err(err)
        ret2 = string_or_nothing(ret, true)
        ret2
    end
    function fetch(instance::GMatchInfo, _match_num::Integer)
        ret = ccall(("g_match_info_fetch", libglib), Cstring, (Ptr{GMatchInfo}, Int32), instance, _match_num)
        ret2 = string_or_nothing(ret, true)
        ret2
    end
    function fetch_all(instance::GMatchInfo)
        ret = ccall(("g_match_info_fetch_all", libglib), Ptr{Cstring}, (Ptr{GMatchInfo},), instance)
        ret2 = begin
                _len = length_zt(ret)
                arrtemp = bytestring.(unsafe_wrap(Vector{Cstring}, ret, _len))
                GLib.g_strfreev(ret)
                arrtemp
            end
        ret2
    end
    function fetch_named(instance::GMatchInfo, _name::Union{AbstractString, Symbol})
        ret = ccall(("g_match_info_fetch_named", libglib), Cstring, (Ptr{GMatchInfo}, Cstring), instance, _name)
        ret2 = string_or_nothing(ret, true)
        ret2
    end
    function fetch_named_pos(instance::GMatchInfo, _name::Union{AbstractString, Symbol})
        m_start_pos = Ref{Int32}()
        m_end_pos = Ref{Int32}()
        ret = ccall(("g_match_info_fetch_named_pos", libglib), Cint, (Ptr{GMatchInfo}, Cstring, Ptr{Int32}, Ptr{Int32}), instance, _name, m_start_pos, m_end_pos)
        ret2 = convert(Bool, ret)
        _start_pos = m_start_pos[]
        _end_pos = m_end_pos[]
        (ret2, _start_pos, _end_pos)
    end
    function fetch_pos(instance::GMatchInfo, _match_num::Integer)
        m_start_pos = Ref{Int32}()
        m_end_pos = Ref{Int32}()
        ret = ccall(("g_match_info_fetch_pos", libglib), Cint, (Ptr{GMatchInfo}, Int32, Ptr{Int32}, Ptr{Int32}), instance, _match_num, m_start_pos, m_end_pos)
        ret2 = convert(Bool, ret)
        _start_pos = m_start_pos[]
        _end_pos = m_end_pos[]
        (ret2, _start_pos, _end_pos)
    end
    function free(instance::GMatchInfo)
        ret = ccall(("g_match_info_free", libglib), Nothing, (Ptr{GMatchInfo},), instance)
        nothing
    end
    function get_match_count(instance::GMatchInfo)
        ret = ccall(("g_match_info_get_match_count", libglib), Int32, (Ptr{GMatchInfo},), instance)
        ret
    end
    function get_regex(instance::GMatchInfo)
        ret = ccall(("g_match_info_get_regex", libglib), Ptr{GRegex}, (Ptr{GMatchInfo},), instance)
        ret2 = convert(GRegex, ret, false)
        ret2
    end
    function get_string(instance::GMatchInfo)
        ret = ccall(("g_match_info_get_string", libglib), Cstring, (Ptr{GMatchInfo},), instance)
        ret2 = string_or_nothing(ret, false)
        ret2
    end
    function is_partial_match(instance::GMatchInfo)
        ret = ccall(("g_match_info_is_partial_match", libglib), Cint, (Ptr{GMatchInfo},), instance)
        ret2 = convert(Bool, ret)
        ret2
    end
    function matches(instance::GMatchInfo)
        ret = ccall(("g_match_info_matches", libglib), Cint, (Ptr{GMatchInfo},), instance)
        ret2 = convert(Bool, ret)
        ret2
    end
    function next(instance::GMatchInfo)
        err = err_buf()
        ret = ccall(("g_match_info_next", libglib), Cint, (Ptr{GMatchInfo}, Ptr{Ptr{GError}}), instance, err)
        check_err(err)
        ret2 = convert(Bool, ret)
        ret2
    end
    function ref(instance::GMatchInfo)
        ret = ccall(("g_match_info_ref", libglib), Ptr{GMatchInfo}, (Ptr{GMatchInfo},), instance)
        ret2 = convert(GMatchInfo, ret, true)
        ret2
    end
    function unref(instance::GMatchInfo)
        ret = ccall(("g_match_info_unref", libglib), Nothing, (Ptr{GMatchInfo},), instance)
        nothing
    end
    function PatternSpec_new(_pattern::Union{AbstractString, Symbol})
        ret = ccall(("g_pattern_spec_new", libglib), Ptr{GPatternSpec}, (Cstring,), _pattern)
        ret2 = convert(GPatternSpec, ret, true)
        ret2
    end
    function copy(instance::GPatternSpec)
        ret = ccall(("g_pattern_spec_copy", libglib), Ptr{GPatternSpec}, (Ptr{GPatternSpec},), instance)
        ret2 = convert(GPatternSpec, ret, true)
        ret2
    end
    function equal(instance::GPatternSpec, _pspec2::GPatternSpec)
        ret = ccall(("g_pattern_spec_equal", libglib), Cint, (Ptr{GPatternSpec}, Ptr{GPatternSpec}), instance, _pspec2)
        ret2 = convert(Bool, ret)
        ret2
    end
    function free(instance::GPatternSpec)
        ret = ccall(("g_pattern_spec_free", libglib), Nothing, (Ptr{GPatternSpec},), instance)
        nothing
    end
    function match(instance::GPatternSpec, _string_length::Integer, _string::Union{AbstractString, Symbol}, _string_reversed::Maybe(Union{AbstractString, Symbol}))
        _string_reversed_maybe = nothing_to_null(_string_reversed)
        ret = ccall(("g_pattern_spec_match", libglib), Cint, (Ptr{GPatternSpec}, UInt64, Cstring, Cstring), instance, _string_length, _string, _string_reversed_maybe)
        ret2 = convert(Bool, ret)
        ret2
    end
    function match_string(instance::GPatternSpec, _string::Union{AbstractString, Symbol})
        ret = ccall(("g_pattern_spec_match_string", libglib), Cint, (Ptr{GPatternSpec}, Cstring), instance, _string)
        ret2 = convert(Bool, ret)
        ret2
    end
    function Rand_new()
        ret = ccall(("g_rand_new", libglib), Ptr{GRand}, ())
        ret2 = convert(GRand, ret, true)
        ret2
    end
    function Rand_new_with_seed(_seed::Integer)
        ret = ccall(("g_rand_new_with_seed", libglib), Ptr{GRand}, (UInt32,), _seed)
        ret2 = convert(GRand, ret, true)
        ret2
    end
    function Rand_new_with_seed_array(_seed::UInt32, _seed_length::Integer)
        ret = ccall(("g_rand_new_with_seed_array", libglib), Ptr{GRand}, (Ptr{UInt32}, UInt32), _seed, _seed_length)
        ret2 = convert(GRand, ret, true)
        ret2
    end
    function copy(instance::GRand)
        ret = ccall(("g_rand_copy", libglib), Ptr{GRand}, (Ptr{GRand},), instance)
        ret2 = convert(GRand, ret, true)
        ret2
    end
    function double(instance::GRand)
        ret = ccall(("g_rand_double", libglib), Float64, (Ptr{GRand},), instance)
        ret
    end
    function double_range(instance::GRand, _begin::Real, _end::Real)
        ret = ccall(("g_rand_double_range", libglib), Float64, (Ptr{GRand}, Float64, Float64), instance, _begin, _end)
        ret
    end
    function free(instance::GRand)
        ret = ccall(("g_rand_free", libglib), Nothing, (Ptr{GRand},), instance)
        nothing
    end
    function int(instance::GRand)
        ret = ccall(("g_rand_int", libglib), UInt32, (Ptr{GRand},), instance)
        ret
    end
    function int_range(instance::GRand, _begin::Integer, _end::Integer)
        ret = ccall(("g_rand_int_range", libglib), Int32, (Ptr{GRand}, Int32, Int32), instance, _begin, _end)
        ret
    end
    function set_seed(instance::GRand, _seed::Integer)
        ret = ccall(("g_rand_set_seed", libglib), Nothing, (Ptr{GRand}, UInt32), instance, _seed)
        nothing
    end
    function set_seed_array(instance::GRand, _seed::UInt32, _seed_length::Integer)
        ret = ccall(("g_rand_set_seed_array", libglib), Nothing, (Ptr{GRand}, Ptr{UInt32}, UInt32), instance, _seed, _seed_length)
        nothing
    end
    function Regex_new(_pattern::Union{AbstractString, Symbol}, _compile_options, _match_options)
        err = err_buf()
        ret = ccall(("g_regex_new", libglib), Ptr{GRegex}, (Cstring, UInt32, UInt32, Ptr{Ptr{GError}}), _pattern, _compile_options, _match_options, err)
        check_err(err)
        ret2 = convert_if_not_null(GRegex, ret, true)
        ret2
    end
    function get_capture_count(instance::GRegex)
        ret = ccall(("g_regex_get_capture_count", libglib), Int32, (Ptr{GRegex},), instance)
        ret
    end
    function get_compile_flags(instance::GRegex)
        ret = ccall(("g_regex_get_compile_flags", libglib), UInt32, (Ptr{GRegex},), instance)
        ret2 = RegexCompileFlags(ret)
        ret2
    end
    function get_has_cr_or_lf(instance::GRegex)
        ret = ccall(("g_regex_get_has_cr_or_lf", libglib), Cint, (Ptr{GRegex},), instance)
        ret2 = convert(Bool, ret)
        ret2
    end
    function get_match_flags(instance::GRegex)
        ret = ccall(("g_regex_get_match_flags", libglib), UInt32, (Ptr{GRegex},), instance)
        ret2 = RegexMatchFlags(ret)
        ret2
    end
    function get_max_backref(instance::GRegex)
        ret = ccall(("g_regex_get_max_backref", libglib), Int32, (Ptr{GRegex},), instance)
        ret
    end
    function get_max_lookbehind(instance::GRegex)
        ret = ccall(("g_regex_get_max_lookbehind", libglib), Int32, (Ptr{GRegex},), instance)
        ret
    end
    function get_pattern(instance::GRegex)
        ret = ccall(("g_regex_get_pattern", libglib), Cstring, (Ptr{GRegex},), instance)
        ret2 = string_or_nothing(ret, false)
        ret2
    end
    function get_string_number(instance::GRegex, _name::Union{AbstractString, Symbol})
        ret = ccall(("g_regex_get_string_number", libglib), Int32, (Ptr{GRegex}, Cstring), instance, _name)
        ret
    end
    function match(instance::GRegex, _string::Union{AbstractString, Symbol}, _match_options)
        m_match_info = Ref{Ptr{GMatchInfo}}()
        ret = ccall(("g_regex_match", libglib), Cint, (Ptr{GRegex}, Cstring, UInt32, Ptr{Ptr{GMatchInfo}}), instance, _string, _match_options, m_match_info)
        ret2 = convert(Bool, ret)
        _match_info = m_match_info[]
        _match_info = convert(GMatchInfo, _match_info, true)
        (ret2, _match_info)
    end
    function match_all(instance::GRegex, _string::Union{AbstractString, Symbol}, _match_options)
        m_match_info = Ref{Ptr{GMatchInfo}}()
        ret = ccall(("g_regex_match_all", libglib), Cint, (Ptr{GRegex}, Cstring, UInt32, Ptr{Ptr{GMatchInfo}}), instance, _string, _match_options, m_match_info)
        ret2 = convert(Bool, ret)
        _match_info = m_match_info[]
        _match_info = convert(GMatchInfo, _match_info, true)
        (ret2, _match_info)
    end
    function match_all_full(instance::GRegex, _string, _start_position::Integer, _match_options)
        m_match_info = Ref{Ptr{GMatchInfo}}()
        _string_len = length(_string)
        err = err_buf()
        ret = ccall(("g_regex_match_all_full", libglib), Cint, (Ptr{GRegex}, Ptr{Cstring}, Int64, Int32, UInt32, Ptr{Ptr{GMatchInfo}}, Ptr{Ptr{GError}}), instance, _string, _string_len, _start_position, _match_options, m_match_info, err)
        check_err(err)
        ret2 = convert(Bool, ret)
        _match_info = m_match_info[]
        _match_info = convert(GMatchInfo, _match_info, true)
        (ret2, _match_info)
    end
    function match_full(instance::GRegex, _string, _start_position::Integer, _match_options)
        m_match_info = Ref{Ptr{GMatchInfo}}()
        _string_len = length(_string)
        err = err_buf()
        ret = ccall(("g_regex_match_full", libglib), Cint, (Ptr{GRegex}, Ptr{Cstring}, Int64, Int32, UInt32, Ptr{Ptr{GMatchInfo}}, Ptr{Ptr{GError}}), instance, _string, _string_len, _start_position, _match_options, m_match_info, err)
        check_err(err)
        ret2 = convert(Bool, ret)
        _match_info = m_match_info[]
        _match_info = convert(GMatchInfo, _match_info, true)
        (ret2, _match_info)
    end
    function ref(instance::GRegex)
        ret = ccall(("g_regex_ref", libglib), Ptr{GRegex}, (Ptr{GRegex},), instance)
        ret2 = convert(GRegex, ret, true)
        ret2
    end
    function replace(instance::GRegex, _string, _start_position::Integer, _replacement::Union{AbstractString, Symbol}, _match_options)
        _string_len = length(_string)
        err = err_buf()
        ret = ccall(("g_regex_replace", libglib), Cstring, (Ptr{GRegex}, Ptr{Cstring}, Int64, Int32, Cstring, UInt32, Ptr{Ptr{GError}}), instance, _string, _string_len, _start_position, _replacement, _match_options, err)
        check_err(err)
        ret2 = string_or_nothing(ret, true)
        ret2
    end
    function replace_eval(instance::GRegex, _string, _start_position::Integer, _match_options, _eval::Function)
        _eval_cfunc = @cfunction(GRegexEvalCallback, Cint, (Ptr{GMatchInfo}, Ptr{_GString}, Ref{Function}))
        ref = Ref{Any}(_eval)
        _eval_closure = unsafe_load(convert(Ptr{Ptr{Nothing}}, Base.unsafe_convert(Ptr{Any}, ref)))
        _string_len = length(_string)
        err = err_buf()
        ret = ccall(("g_regex_replace_eval", libglib), Cstring, (Ptr{GRegex}, Ptr{Cstring}, Int64, Int32, UInt32, Ptr{Cvoid}, Ptr{Nothing}, Ptr{Ptr{GError}}), instance, _string, _string_len, _start_position, _match_options, _eval_cfunc, _eval_closure, err)
        check_err(err)
        ret2 = string_or_nothing(ret, true)
        ret2
    end
    function replace_literal(instance::GRegex, _string, _start_position::Integer, _replacement::Union{AbstractString, Symbol}, _match_options)
        _string_len = length(_string)
        err = err_buf()
        ret = ccall(("g_regex_replace_literal", libglib), Cstring, (Ptr{GRegex}, Ptr{Cstring}, Int64, Int32, Cstring, UInt32, Ptr{Ptr{GError}}), instance, _string, _string_len, _start_position, _replacement, _match_options, err)
        check_err(err)
        ret2 = string_or_nothing(ret, true)
        ret2
    end
    function split(instance::GRegex, _string::Union{AbstractString, Symbol}, _match_options)
        ret = ccall(("g_regex_split", libglib), Ptr{Cstring}, (Ptr{GRegex}, Cstring, UInt32), instance, _string, _match_options)
        ret2 = begin
                _len = length_zt(ret)
                arrtemp = bytestring.(unsafe_wrap(Vector{Cstring}, ret, _len))
                GLib.g_strfreev(ret)
                arrtemp
            end
        ret2
    end
    function split_full(instance::GRegex, _string, _start_position::Integer, _match_options, _max_tokens::Integer)
        _string_len = length(_string)
        err = err_buf()
        ret = ccall(("g_regex_split_full", libglib), Ptr{Cstring}, (Ptr{GRegex}, Ptr{Cstring}, Int64, Int32, UInt32, Int32, Ptr{Ptr{GError}}), instance, _string, _string_len, _start_position, _match_options, _max_tokens, err)
        check_err(err)
        ret2 = begin
                _len = length_zt(ret)
                arrtemp = bytestring.(unsafe_wrap(Vector{Cstring}, ret, _len))
                GLib.g_strfreev(ret)
                arrtemp
            end
        ret2
    end
    function unref(instance::GRegex)
        ret = ccall(("g_regex_unref", libglib), Nothing, (Ptr{GRegex},), instance)
        nothing
    end
    function String_new(_init::Maybe(Union{AbstractString, Symbol}))
        _init_maybe = nothing_to_null(_init)
        ret = ccall(("g_string_new", libglib), Ptr{_GString}, (Cstring,), _init_maybe)
        ret2 = convert(GStringLike, ret, true)
        ret2
    end
    function String_new_len(_init::Union{AbstractString, Symbol}, _len::Integer)
        ret = ccall(("g_string_new_len", libglib), Ptr{_GString}, (Cstring, Int64), _init, _len)
        ret2 = convert(GStringLike, ret, true)
        ret2
    end
    function String_new_take(_init::Maybe(Union{AbstractString, Symbol}))
        _init_maybe = nothing_to_null(_init)
        ret = ccall(("g_string_new_take", libglib), Ptr{_GString}, (Cstring,), _init_maybe)
        ret2 = convert(GStringLike, ret, true)
        ret2
    end
    function String_sized_new(_dfl_size::Integer)
        ret = ccall(("g_string_sized_new", libglib), Ptr{_GString}, (UInt64,), _dfl_size)
        ret2 = convert(GStringLike, ret, true)
        ret2
    end
    function append(instance::GStringLike, _val::Union{AbstractString, Symbol})
        ret = ccall(("g_string_append", libglib), Ptr{_GString}, (Ptr{_GString}, Cstring), instance, _val)
        ret2 = convert(GStringLike, ret, false)
        ret2
    end
    function append_c(instance::GStringLike, _c::Integer)
        ret = ccall(("g_string_append_c", libglib), Ptr{_GString}, (Ptr{_GString}, Int8), instance, _c)
        ret2 = convert(GStringLike, ret, false)
        ret2
    end
    function append_len(instance::GStringLike, _val::Union{AbstractString, Symbol}, _len::Integer)
        ret = ccall(("g_string_append_len", libglib), Ptr{_GString}, (Ptr{_GString}, Cstring, Int64), instance, _val, _len)
        ret2 = convert(GStringLike, ret, false)
        ret2
    end
    function append_unichar(instance::GStringLike, _wc)
        ret = ccall(("g_string_append_unichar", libglib), Ptr{_GString}, (Ptr{_GString}, Nothing), instance, _wc)
        ret2 = convert(GStringLike, ret, false)
        ret2
    end
    function append_uri_escaped(instance::GStringLike, _unescaped::Union{AbstractString, Symbol}, _reserved_chars_allowed::Union{AbstractString, Symbol}, _allow_utf8::Bool)
        ret = ccall(("g_string_append_uri_escaped", libglib), Ptr{_GString}, (Ptr{_GString}, Cstring, Cstring, Cint), instance, _unescaped, _reserved_chars_allowed, _allow_utf8)
        ret2 = convert(GStringLike, ret, false)
        ret2
    end
    function ascii_down(instance::GStringLike)
        ret = ccall(("g_string_ascii_down", libglib), Ptr{_GString}, (Ptr{_GString},), instance)
        ret2 = convert(GStringLike, ret, false)
        ret2
    end
    function ascii_up(instance::GStringLike)
        ret = ccall(("g_string_ascii_up", libglib), Ptr{_GString}, (Ptr{_GString},), instance)
        ret2 = convert(GStringLike, ret, false)
        ret2
    end
    function assign(instance::GStringLike, _rval::Union{AbstractString, Symbol})
        ret = ccall(("g_string_assign", libglib), Ptr{_GString}, (Ptr{_GString}, Cstring), instance, _rval)
        ret2 = convert(GStringLike, ret, false)
        ret2
    end
    function equal(instance::GStringLike, _v2::GStringLike)
        ret = ccall(("g_string_equal", libglib), Cint, (Ptr{_GString}, Ptr{_GString}), instance, _v2)
        ret2 = convert(Bool, ret)
        ret2
    end
    function erase(instance::GStringLike, _pos::Integer, _len::Integer)
        ret = ccall(("g_string_erase", libglib), Ptr{_GString}, (Ptr{_GString}, Int64, Int64), instance, _pos, _len)
        ret2 = convert(GStringLike, ret, false)
        ret2
    end
    function free(instance::GStringLike, _free_segment::Bool)
        reffed_instance = GLib.glib_ref(instance)
        ret = ccall(("g_string_free", libglib), Cstring, (Ptr{_GString}, Cint), reffed_instance, _free_segment)
        ret2 = string_or_nothing(ret, true)
        ret2
    end
    function free_and_steal(instance::GStringLike)
        reffed_instance = GLib.glib_ref(instance)
        ret = ccall(("g_string_free_and_steal", libglib), Cstring, (Ptr{_GString},), reffed_instance)
        ret2 = string_or_nothing(ret, true)
        ret2
    end
    function free_to_bytes(instance::GStringLike)
        reffed_instance = GLib.glib_ref(instance)
        ret = ccall(("g_string_free_to_bytes", libglib), Ptr{GBytes}, (Ptr{_GString},), reffed_instance)
        ret2 = convert(GBytes, ret, true)
        ret2
    end
    function hash(instance::GStringLike)
        ret = ccall(("g_string_hash", libglib), UInt32, (Ptr{_GString},), instance)
        ret
    end
    function insert(instance::GStringLike, _pos::Integer, _val::Union{AbstractString, Symbol})
        ret = ccall(("g_string_insert", libglib), Ptr{_GString}, (Ptr{_GString}, Int64, Cstring), instance, _pos, _val)
        ret2 = convert(GStringLike, ret, false)
        ret2
    end
    function insert_c(instance::GStringLike, _pos::Integer, _c::Integer)
        ret = ccall(("g_string_insert_c", libglib), Ptr{_GString}, (Ptr{_GString}, Int64, Int8), instance, _pos, _c)
        ret2 = convert(GStringLike, ret, false)
        ret2
    end
    function insert_len(instance::GStringLike, _pos::Integer, _val::Union{AbstractString, Symbol}, _len::Integer)
        ret = ccall(("g_string_insert_len", libglib), Ptr{_GString}, (Ptr{_GString}, Int64, Cstring, Int64), instance, _pos, _val, _len)
        ret2 = convert(GStringLike, ret, false)
        ret2
    end
    function insert_unichar(instance::GStringLike, _pos::Integer, _wc)
        ret = ccall(("g_string_insert_unichar", libglib), Ptr{_GString}, (Ptr{_GString}, Int64, Nothing), instance, _pos, _wc)
        ret2 = convert(GStringLike, ret, false)
        ret2
    end
    function overwrite(instance::GStringLike, _pos::Integer, _val::Union{AbstractString, Symbol})
        ret = ccall(("g_string_overwrite", libglib), Ptr{_GString}, (Ptr{_GString}, UInt64, Cstring), instance, _pos, _val)
        ret2 = convert(GStringLike, ret, false)
        ret2
    end
    function overwrite_len(instance::GStringLike, _pos::Integer, _val::Union{AbstractString, Symbol}, _len::Integer)
        ret = ccall(("g_string_overwrite_len", libglib), Ptr{_GString}, (Ptr{_GString}, UInt64, Cstring, Int64), instance, _pos, _val, _len)
        ret2 = convert(GStringLike, ret, false)
        ret2
    end
    function prepend(instance::GStringLike, _val::Union{AbstractString, Symbol})
        ret = ccall(("g_string_prepend", libglib), Ptr{_GString}, (Ptr{_GString}, Cstring), instance, _val)
        ret2 = convert(GStringLike, ret, false)
        ret2
    end
    function prepend_c(instance::GStringLike, _c::Integer)
        ret = ccall(("g_string_prepend_c", libglib), Ptr{_GString}, (Ptr{_GString}, Int8), instance, _c)
        ret2 = convert(GStringLike, ret, false)
        ret2
    end
    function prepend_len(instance::GStringLike, _val::Union{AbstractString, Symbol}, _len::Integer)
        ret = ccall(("g_string_prepend_len", libglib), Ptr{_GString}, (Ptr{_GString}, Cstring, Int64), instance, _val, _len)
        ret2 = convert(GStringLike, ret, false)
        ret2
    end
    function prepend_unichar(instance::GStringLike, _wc)
        ret = ccall(("g_string_prepend_unichar", libglib), Ptr{_GString}, (Ptr{_GString}, Nothing), instance, _wc)
        ret2 = convert(GStringLike, ret, false)
        ret2
    end
    function replace(instance::GStringLike, _find::Union{AbstractString, Symbol}, _replace::Union{AbstractString, Symbol}, _limit::Integer)
        ret = ccall(("g_string_replace", libglib), UInt32, (Ptr{_GString}, Cstring, Cstring, UInt32), instance, _find, _replace, _limit)
        ret
    end
    function set_size(instance::GStringLike, _len::Integer)
        ret = ccall(("g_string_set_size", libglib), Ptr{_GString}, (Ptr{_GString}, UInt64), instance, _len)
        ret2 = convert(GStringLike, ret, false)
        ret2
    end
    function truncate(instance::GStringLike, _len::Integer)
        ret = ccall(("g_string_truncate", libglib), Ptr{_GString}, (Ptr{_GString}, UInt64), instance, _len)
        ret2 = convert(GStringLike, ret, false)
        ret2
    end
    function StrvBuilder_new()
        ret = ccall(("g_strv_builder_new", libglib), Ptr{GStrvBuilder}, ())
        ret2 = convert(GStrvBuilder, ret, true)
        ret2
    end
    function add(instance::GStrvBuilder, _value::Union{AbstractString, Symbol})
        ret = ccall(("g_strv_builder_add", libglib), Nothing, (Ptr{GStrvBuilder}, Cstring), instance, _value)
        nothing
    end
    function addv(instance::GStrvBuilder, _value)
        ret = ccall(("g_strv_builder_addv", libglib), Nothing, (Ptr{GStrvBuilder}, Ptr{Cstring}), instance, _value)
        nothing
    end
    function ref(instance::GStrvBuilder)
        ret = ccall(("g_strv_builder_ref", libglib), Ptr{GStrvBuilder}, (Ptr{GStrvBuilder},), instance)
        ret2 = convert(GStrvBuilder, ret, true)
        ret2
    end
    function take(instance::GStrvBuilder, _value::Union{AbstractString, Symbol})
        ret = ccall(("g_strv_builder_take", libglib), Nothing, (Ptr{GStrvBuilder}, Cstring), instance, _value)
        nothing
    end
    function unref(instance::GStrvBuilder)
        reffed_instance = GLib.glib_ref(instance)
        ret = ccall(("g_strv_builder_unref", libglib), Nothing, (Ptr{GStrvBuilder},), reffed_instance)
        nothing
    end
    function unref_to_strv(instance::GStrvBuilder)
        reffed_instance = GLib.glib_ref(instance)
        ret = ccall(("g_strv_builder_unref_to_strv", libglib), Ptr{Cstring}, (Ptr{GStrvBuilder},), reffed_instance)
        ret2 = begin
                _len = length_zt(ret)
                arrtemp = bytestring.(unsafe_wrap(Vector{Cstring}, ret, _len))
                GLib.g_strfreev(ret)
                arrtemp
            end
        ret2
    end
    function TimeZone_new_identifier(_identifier::Maybe(Union{AbstractString, Symbol}))
        _identifier_maybe = nothing_to_null(_identifier)
        ret = ccall(("g_time_zone_new_identifier", libglib), Ptr{GTimeZone}, (Cstring,), _identifier_maybe)
        ret2 = convert_if_not_null(GTimeZone, ret, true)
        ret2
    end
    function TimeZone_new_local()
        ret = ccall(("g_time_zone_new_local", libglib), Ptr{GTimeZone}, ())
        ret2 = convert(GTimeZone, ret, true)
        ret2
    end
    function TimeZone_new_offset(_seconds::Integer)
        ret = ccall(("g_time_zone_new_offset", libglib), Ptr{GTimeZone}, (Int32,), _seconds)
        ret2 = convert(GTimeZone, ret, true)
        ret2
    end
    function TimeZone_new_utc()
        ret = ccall(("g_time_zone_new_utc", libglib), Ptr{GTimeZone}, ())
        ret2 = convert(GTimeZone, ret, true)
        ret2
    end
    function adjust_time(instance::GTimeZone, _type, _time_::Integer)
        m_time_ = Ref{Int64}()
        m_time_[] = Base.cconvert(Int64, _time_)
        ret = ccall(("g_time_zone_adjust_time", libglib), Int32, (Ptr{GTimeZone}, UInt32, Ptr{Int64}), instance, _type, m_time_)
        _time_ = m_time_[]
        (ret, _time_)
    end
    function find_interval(instance::GTimeZone, _type, _time_::Integer)
        ret = ccall(("g_time_zone_find_interval", libglib), Int32, (Ptr{GTimeZone}, UInt32, Int64), instance, _type, _time_)
        ret
    end
    function get_abbreviation(instance::GTimeZone, _interval::Integer)
        ret = ccall(("g_time_zone_get_abbreviation", libglib), Cstring, (Ptr{GTimeZone}, Int32), instance, _interval)
        ret2 = string_or_nothing(ret, false)
        ret2
    end
    function get_identifier(instance::GTimeZone)
        ret = ccall(("g_time_zone_get_identifier", libglib), Cstring, (Ptr{GTimeZone},), instance)
        ret2 = string_or_nothing(ret, false)
        ret2
    end
    function get_offset(instance::GTimeZone, _interval::Integer)
        ret = ccall(("g_time_zone_get_offset", libglib), Int32, (Ptr{GTimeZone}, Int32), instance, _interval)
        ret
    end
    function is_dst(instance::GTimeZone, _interval::Integer)
        ret = ccall(("g_time_zone_is_dst", libglib), Cint, (Ptr{GTimeZone}, Int32), instance, _interval)
        ret2 = convert(Bool, ret)
        ret2
    end
    function ref(instance::GTimeZone)
        ret = ccall(("g_time_zone_ref", libglib), Ptr{GTimeZone}, (Ptr{GTimeZone},), instance)
        ret2 = convert(GTimeZone, ret, true)
        ret2
    end
    function unref(instance::GTimeZone)
        ret = ccall(("g_time_zone_unref", libglib), Nothing, (Ptr{GTimeZone},), instance)
        nothing
    end
    function get_auth_params(instance::GUri)
        ret = ccall(("g_uri_get_auth_params", libglib), Cstring, (Ptr{GUri},), instance)
        ret2 = string_or_nothing(ret, false)
        ret2
    end
    function get_flags(instance::GUri)
        ret = ccall(("g_uri_get_flags", libglib), UInt32, (Ptr{GUri},), instance)
        ret2 = UriFlags(ret)
        ret2
    end
    function get_fragment(instance::GUri)
        ret = ccall(("g_uri_get_fragment", libglib), Cstring, (Ptr{GUri},), instance)
        ret2 = string_or_nothing(ret, false)
        ret2
    end
    function get_host(instance::GUri)
        ret = ccall(("g_uri_get_host", libglib), Cstring, (Ptr{GUri},), instance)
        ret2 = string_or_nothing(ret, false)
        ret2
    end
    function get_password(instance::GUri)
        ret = ccall(("g_uri_get_password", libglib), Cstring, (Ptr{GUri},), instance)
        ret2 = string_or_nothing(ret, false)
        ret2
    end
    function get_path(instance::GUri)
        ret = ccall(("g_uri_get_path", libglib), Cstring, (Ptr{GUri},), instance)
        ret2 = string_or_nothing(ret, false)
        ret2
    end
    function get_port(instance::GUri)
        ret = ccall(("g_uri_get_port", libglib), Int32, (Ptr{GUri},), instance)
        ret
    end
    function get_query(instance::GUri)
        ret = ccall(("g_uri_get_query", libglib), Cstring, (Ptr{GUri},), instance)
        ret2 = string_or_nothing(ret, false)
        ret2
    end
    function get_scheme(instance::GUri)
        ret = ccall(("g_uri_get_scheme", libglib), Cstring, (Ptr{GUri},), instance)
        ret2 = string_or_nothing(ret, false)
        ret2
    end
    function get_user(instance::GUri)
        ret = ccall(("g_uri_get_user", libglib), Cstring, (Ptr{GUri},), instance)
        ret2 = string_or_nothing(ret, false)
        ret2
    end
    function get_userinfo(instance::GUri)
        ret = ccall(("g_uri_get_userinfo", libglib), Cstring, (Ptr{GUri},), instance)
        ret2 = string_or_nothing(ret, false)
        ret2
    end
    function parse_relative(instance::GUri, _uri_ref::Union{AbstractString, Symbol}, _flags)
        err = err_buf()
        ret = ccall(("g_uri_parse_relative", libglib), Ptr{GUri}, (Ptr{GUri}, Cstring, UInt32, Ptr{Ptr{GError}}), instance, _uri_ref, _flags, err)
        check_err(err)
        ret2 = convert(GUri, ret, true)
        ret2
    end
    function to_string(instance::GUri)
        ret = ccall(("g_uri_to_string", libglib), Cstring, (Ptr{GUri},), instance)
        ret2 = string_or_nothing(ret, true)
        ret2
    end
    function to_string_partial(instance::GUri, _flags)
        ret = ccall(("g_uri_to_string_partial", libglib), Cstring, (Ptr{GUri}, UInt32), instance, _flags)
        ret2 = string_or_nothing(ret, true)
        ret2
    end
    function Variant_new_array(_child_type::Maybe(GVariantType), _children)
        _child_type_maybe = nothing_to_null(_child_type)
        _children_arr = convert(Vector{Ptr{GVariant}}, _children)
        _n_children = length(_children)
        ret = ccall(("g_variant_new_array", libglib), Ptr{GVariant}, (Ptr{GVariantType}, Ptr{Ptr{GVariant}}, UInt64), _child_type_maybe, _children_arr, _n_children)
        ret2 = convert(GVariant, ret)
        ret2
    end
    function Variant_new_boolean(_value::Bool)
        ret = ccall(("g_variant_new_boolean", libglib), Ptr{GVariant}, (Cint,), _value)
        ret2 = convert(GVariant, ret)
        ret2
    end
    function Variant_new_byte(_value::Integer)
        ret = ccall(("g_variant_new_byte", libglib), Ptr{GVariant}, (UInt8,), _value)
        ret2 = convert(GVariant, ret)
        ret2
    end
    function Variant_new_bytestring(_string)
        _string_arr = convert(Vector{UInt8}, _string)
        ret = ccall(("g_variant_new_bytestring", libglib), Ptr{GVariant}, (Ptr{UInt8},), _string_arr)
        ret2 = convert(GVariant, ret)
        ret2
    end
    function Variant_new_bytestring_array(_strv)
        _length = length(_strv)
        ret = ccall(("g_variant_new_bytestring_array", libglib), Ptr{GVariant}, (Ptr{Cstring}, Int64), _strv, _length)
        ret2 = convert(GVariant, ret)
        ret2
    end
    function Variant_new_dict_entry(_key::GVariant, _value::GVariant)
        ret = ccall(("g_variant_new_dict_entry", libglib), Ptr{GVariant}, (Ptr{GVariant}, Ptr{GVariant}), _key, _value)
        ret2 = convert(GVariant, ret)
        ret2
    end
    function Variant_new_double(_value::Real)
        ret = ccall(("g_variant_new_double", libglib), Ptr{GVariant}, (Float64,), _value)
        ret2 = convert(GVariant, ret)
        ret2
    end
    function Variant_new_fixed_array(_element_type::GVariantType, _elements::Maybe(Nothing), _n_elements::Integer, _element_size::Integer)
        _elements_maybe = nothing_to_null(_elements)
        ret = ccall(("g_variant_new_fixed_array", libglib), Ptr{GVariant}, (Ptr{GVariantType}, Ptr{Nothing}, UInt64, UInt64), _element_type, _elements_maybe, _n_elements, _element_size)
        ret2 = convert(GVariant, ret)
        ret2
    end
    function Variant_new_from_bytes(_type::GVariantType, _bytes::GBytes, _trusted::Bool)
        ret = ccall(("g_variant_new_from_bytes", libglib), Ptr{GVariant}, (Ptr{GVariantType}, Ptr{GBytes}, Cint), _type, _bytes, _trusted)
        ret2 = convert(GVariant, ret)
        ret2
    end
    function Variant_new_handle(_value::Integer)
        ret = ccall(("g_variant_new_handle", libglib), Ptr{GVariant}, (Int32,), _value)
        ret2 = convert(GVariant, ret)
        ret2
    end
    function Variant_new_int16(_value::Integer)
        ret = ccall(("g_variant_new_int16", libglib), Ptr{GVariant}, (Int16,), _value)
        ret2 = convert(GVariant, ret)
        ret2
    end
    function Variant_new_int32(_value::Integer)
        ret = ccall(("g_variant_new_int32", libglib), Ptr{GVariant}, (Int32,), _value)
        ret2 = convert(GVariant, ret)
        ret2
    end
    function Variant_new_int64(_value::Integer)
        ret = ccall(("g_variant_new_int64", libglib), Ptr{GVariant}, (Int64,), _value)
        ret2 = convert(GVariant, ret)
        ret2
    end
    function Variant_new_maybe(_child_type::Maybe(GVariantType), _child::Maybe(GVariant))
        _child_type_maybe = nothing_to_null(_child_type)
        _child_maybe = nothing_to_null(_child)
        ret = ccall(("g_variant_new_maybe", libglib), Ptr{GVariant}, (Ptr{GVariantType}, Ptr{GVariant}), _child_type_maybe, _child_maybe)
        ret2 = convert(GVariant, ret)
        ret2
    end
    function Variant_new_object_path(_object_path::Union{AbstractString, Symbol})
        ret = ccall(("g_variant_new_object_path", libglib), Ptr{GVariant}, (Cstring,), _object_path)
        ret2 = convert(GVariant, ret)
        ret2
    end
    function Variant_new_objv(_strv)
        _length = length(_strv)
        ret = ccall(("g_variant_new_objv", libglib), Ptr{GVariant}, (Ptr{Cstring}, Int64), _strv, _length)
        ret2 = convert(GVariant, ret)
        ret2
    end
    function Variant_new_signature(_signature::Union{AbstractString, Symbol})
        ret = ccall(("g_variant_new_signature", libglib), Ptr{GVariant}, (Cstring,), _signature)
        ret2 = convert(GVariant, ret)
        ret2
    end
    function Variant_new_string(_string::Union{AbstractString, Symbol})
        ret = ccall(("g_variant_new_string", libglib), Ptr{GVariant}, (Cstring,), _string)
        ret2 = convert(GVariant, ret)
        ret2
    end
    function Variant_new_strv(_strv)
        _length = length(_strv)
        ret = ccall(("g_variant_new_strv", libglib), Ptr{GVariant}, (Ptr{Cstring}, Int64), _strv, _length)
        ret2 = convert(GVariant, ret)
        ret2
    end
    function Variant_new_tuple(_children)
        _children_arr = convert(Vector{Ptr{GVariant}}, _children)
        _n_children = length(_children)
        ret = ccall(("g_variant_new_tuple", libglib), Ptr{GVariant}, (Ptr{Ptr{GVariant}}, UInt64), _children_arr, _n_children)
        ret2 = convert(GVariant, ret)
        ret2
    end
    function Variant_new_uint16(_value::Integer)
        ret = ccall(("g_variant_new_uint16", libglib), Ptr{GVariant}, (UInt16,), _value)
        ret2 = convert(GVariant, ret)
        ret2
    end
    function Variant_new_uint32(_value::Integer)
        ret = ccall(("g_variant_new_uint32", libglib), Ptr{GVariant}, (UInt32,), _value)
        ret2 = convert(GVariant, ret)
        ret2
    end
    function Variant_new_uint64(_value::Integer)
        ret = ccall(("g_variant_new_uint64", libglib), Ptr{GVariant}, (UInt64,), _value)
        ret2 = convert(GVariant, ret)
        ret2
    end
    function Variant_new_variant(_value::GVariant)
        ret = ccall(("g_variant_new_variant", libglib), Ptr{GVariant}, (Ptr{GVariant},), _value)
        ret2 = convert(GVariant, ret)
        ret2
    end
    function byteswap(instance::GVariant)
        ret = ccall(("g_variant_byteswap", libglib), Ptr{GVariant}, (Ptr{GVariant},), instance)
        ret2 = convert(GVariant, ret)
        ret2
    end
    function check_format_string(instance::GVariant, _format_string::Union{AbstractString, Symbol}, _copy_only::Bool)
        ret = ccall(("g_variant_check_format_string", libglib), Cint, (Ptr{GVariant}, Cstring, Cint), instance, _format_string, _copy_only)
        ret2 = convert(Bool, ret)
        ret2
    end
    function classify(instance::GVariant)
        ret = ccall(("g_variant_classify", libglib), UInt32, (Ptr{GVariant},), instance)
        ret2 = VariantClass(ret)
        ret2
    end
    function compare(instance::GVariant, _two::GVariant)
        ret = ccall(("g_variant_compare", libglib), Int32, (Ptr{GVariant}, Ptr{GVariant}), instance, _two)
        ret
    end
    function dup_bytestring_array(instance::GVariant)
        m_length = Ref{UInt64}()
        ret = ccall(("g_variant_dup_bytestring_array", libglib), Ptr{Cstring}, (Ptr{GVariant}, Ptr{UInt64}), instance, m_length)
        ret2 = begin
                arrtemp = bytestring.(unsafe_wrap(Vector{Cstring}, ret, m_length[]))
                GLib.g_free(ret)
                arrtemp
            end
        _length = m_length[]
        ret2
    end
    function dup_objv(instance::GVariant)
        m_length = Ref{UInt64}()
        ret = ccall(("g_variant_dup_objv", libglib), Ptr{Cstring}, (Ptr{GVariant}, Ptr{UInt64}), instance, m_length)
        ret2 = begin
                _len = length_zt(ret)
                arrtemp = bytestring.(unsafe_wrap(Vector{Cstring}, ret, _len))
                GLib.g_strfreev(ret)
                arrtemp
            end
        _length = m_length[]
        ret2
    end
    function dup_string(instance::GVariant)
        m_length = Ref{UInt64}()
        ret = ccall(("g_variant_dup_string", libglib), Cstring, (Ptr{GVariant}, Ptr{UInt64}), instance, m_length)
        ret2 = string_or_nothing(ret, true)
        _length = m_length[]
        (ret2, _length)
    end
    function dup_strv(instance::GVariant)
        m_length = Ref{UInt64}()
        ret = ccall(("g_variant_dup_strv", libglib), Ptr{Cstring}, (Ptr{GVariant}, Ptr{UInt64}), instance, m_length)
        ret2 = begin
                _len = length_zt(ret)
                arrtemp = bytestring.(unsafe_wrap(Vector{Cstring}, ret, _len))
                GLib.g_strfreev(ret)
                arrtemp
            end
        _length = m_length[]
        ret2
    end
    function equal(instance::GVariant, _two::GVariant)
        ret = ccall(("g_variant_equal", libglib), Cint, (Ptr{GVariant}, Ptr{GVariant}), instance, _two)
        ret2 = convert(Bool, ret)
        ret2
    end
    function get_boolean(instance::GVariant)
        ret = ccall(("g_variant_get_boolean", libglib), Cint, (Ptr{GVariant},), instance)
        ret2 = convert(Bool, ret)
        ret2
    end
    function get_byte(instance::GVariant)
        ret = ccall(("g_variant_get_byte", libglib), UInt8, (Ptr{GVariant},), instance)
        ret
    end
    function get_bytestring_array(instance::GVariant)
        m_length = Ref{UInt64}()
        ret = ccall(("g_variant_get_bytestring_array", libglib), Ptr{Cstring}, (Ptr{GVariant}, Ptr{UInt64}), instance, m_length)
        ret2 = begin
                arrtemp = bytestring.(unsafe_wrap(Vector{Cstring}, ret, m_length[]), false)
                GLib.g_free(ret)
                arrtemp
            end
        _length = m_length[]
        ret2
    end
    function get_child_value(instance::GVariant, _index_::Integer)
        ret = ccall(("g_variant_get_child_value", libglib), Ptr{GVariant}, (Ptr{GVariant}, UInt64), instance, _index_)
        ret2 = convert(GVariant, ret)
        ret2
    end
    function get_data(instance::GVariant)
        ret = ccall(("g_variant_get_data", libglib), Ptr{Nothing}, (Ptr{GVariant},), instance)
        ret2 = convert(Nothing, ret)
        ret2
    end
    function get_data_as_bytes(instance::GVariant)
        ret = ccall(("g_variant_get_data_as_bytes", libglib), Ptr{GBytes}, (Ptr{GVariant},), instance)
        ret2 = convert(GBytes, ret, true)
        ret2
    end
    function get_double(instance::GVariant)
        ret = ccall(("g_variant_get_double", libglib), Float64, (Ptr{GVariant},), instance)
        ret
    end
    function get_handle(instance::GVariant)
        ret = ccall(("g_variant_get_handle", libglib), Int32, (Ptr{GVariant},), instance)
        ret
    end
    function get_int16(instance::GVariant)
        ret = ccall(("g_variant_get_int16", libglib), Int16, (Ptr{GVariant},), instance)
        ret
    end
    function get_int32(instance::GVariant)
        ret = ccall(("g_variant_get_int32", libglib), Int32, (Ptr{GVariant},), instance)
        ret
    end
    function get_int64(instance::GVariant)
        ret = ccall(("g_variant_get_int64", libglib), Int64, (Ptr{GVariant},), instance)
        ret
    end
    function get_maybe(instance::GVariant)
        ret = ccall(("g_variant_get_maybe", libglib), Ptr{GVariant}, (Ptr{GVariant},), instance)
        ret2 = convert(GVariant, ret)
        ret2
    end
    function get_normal_form(instance::GVariant)
        ret = ccall(("g_variant_get_normal_form", libglib), Ptr{GVariant}, (Ptr{GVariant},), instance)
        ret2 = convert(GVariant, ret)
        ret2
    end
    function get_objv(instance::GVariant)
        m_length = Ref{UInt64}()
        ret = ccall(("g_variant_get_objv", libglib), Ptr{Cstring}, (Ptr{GVariant}, Ptr{UInt64}), instance, m_length)
        ret2 = begin
                arrtemp = bytestring.(unsafe_wrap(Vector{Cstring}, ret, m_length[]), false)
                GLib.g_free(ret)
                arrtemp
            end
        _length = m_length[]
        ret2
    end
    function get_size(instance::GVariant)
        ret = ccall(("g_variant_get_size", libglib), UInt64, (Ptr{GVariant},), instance)
        ret
    end
    function get_string(instance::GVariant)
        m_length = Ref{UInt64}()
        ret = ccall(("g_variant_get_string", libglib), Cstring, (Ptr{GVariant}, Ptr{UInt64}), instance, m_length)
        ret2 = string_or_nothing(ret, false)
        _length = m_length[]
        (ret2, _length)
    end
    function get_strv(instance::GVariant)
        m_length = Ref{UInt64}()
        ret = ccall(("g_variant_get_strv", libglib), Ptr{Cstring}, (Ptr{GVariant}, Ptr{UInt64}), instance, m_length)
        ret2 = begin
                arrtemp = bytestring.(unsafe_wrap(Vector{Cstring}, ret, m_length[]), false)
                GLib.g_free(ret)
                arrtemp
            end
        _length = m_length[]
        ret2
    end
    function get_type(instance::GVariant)
        ret = ccall(("g_variant_get_type", libglib), Ptr{GVariantType}, (Ptr{GVariant},), instance)
        ret2 = convert(GVariantType, ret, false)
        ret2
    end
    function get_type_string(instance::GVariant)
        ret = ccall(("g_variant_get_type_string", libglib), Cstring, (Ptr{GVariant},), instance)
        ret2 = string_or_nothing(ret, false)
        ret2
    end
    function get_uint16(instance::GVariant)
        ret = ccall(("g_variant_get_uint16", libglib), UInt16, (Ptr{GVariant},), instance)
        ret
    end
    function get_uint32(instance::GVariant)
        ret = ccall(("g_variant_get_uint32", libglib), UInt32, (Ptr{GVariant},), instance)
        ret
    end
    function get_uint64(instance::GVariant)
        ret = ccall(("g_variant_get_uint64", libglib), UInt64, (Ptr{GVariant},), instance)
        ret
    end
    function get_variant(instance::GVariant)
        ret = ccall(("g_variant_get_variant", libglib), Ptr{GVariant}, (Ptr{GVariant},), instance)
        ret2 = convert(GVariant, ret)
        ret2
    end
    function hash(instance::GVariant)
        ret = ccall(("g_variant_hash", libglib), UInt32, (Ptr{GVariant},), instance)
        ret
    end
    function is_container(instance::GVariant)
        ret = ccall(("g_variant_is_container", libglib), Cint, (Ptr{GVariant},), instance)
        ret2 = convert(Bool, ret)
        ret2
    end
    function is_floating(instance::GVariant)
        ret = ccall(("g_variant_is_floating", libglib), Cint, (Ptr{GVariant},), instance)
        ret2 = convert(Bool, ret)
        ret2
    end
    function is_normal_form(instance::GVariant)
        ret = ccall(("g_variant_is_normal_form", libglib), Cint, (Ptr{GVariant},), instance)
        ret2 = convert(Bool, ret)
        ret2
    end
    function is_of_type(instance::GVariant, _type::GVariantType)
        ret = ccall(("g_variant_is_of_type", libglib), Cint, (Ptr{GVariant}, Ptr{GVariantType}), instance, _type)
        ret2 = convert(Bool, ret)
        ret2
    end
    function lookup_value(instance::GVariant, _key::Union{AbstractString, Symbol}, _expected_type::Maybe(GVariantType))
        _expected_type_maybe = nothing_to_null(_expected_type)
        ret = ccall(("g_variant_lookup_value", libglib), Ptr{GVariant}, (Ptr{GVariant}, Cstring, Ptr{GVariantType}), instance, _key, _expected_type_maybe)
        ret2 = convert(GVariant, ret)
        ret2
    end
    function n_children(instance::GVariant)
        ret = ccall(("g_variant_n_children", libglib), UInt64, (Ptr{GVariant},), instance)
        ret
    end
    function print(instance::GVariant, _type_annotate::Bool)
        ret = ccall(("g_variant_print", libglib), Cstring, (Ptr{GVariant}, Cint), instance, _type_annotate)
        ret2 = string_or_nothing(ret, true)
        ret2
    end
    function ref(instance::GVariant)
        ret = ccall(("g_variant_ref", libglib), Ptr{GVariant}, (Ptr{GVariant},), instance)
        ret2 = convert(GVariant, ret)
        ret2
    end
    function ref_sink(instance::GVariant)
        ret = ccall(("g_variant_ref_sink", libglib), Ptr{GVariant}, (Ptr{GVariant},), instance)
        ret2 = convert(GVariant, ret)
        ret2
    end
    function store(instance::GVariant, _data::Nothing)
        ret = ccall(("g_variant_store", libglib), Nothing, (Ptr{GVariant}, Ptr{Nothing}), instance, _data)
        nothing
    end
    function take_ref(instance::GVariant)
        ret = ccall(("g_variant_take_ref", libglib), Ptr{GVariant}, (Ptr{GVariant},), instance)
        ret2 = convert(GVariant, ret)
        ret2
    end
    function unref(instance::GVariant)
        ret = ccall(("g_variant_unref", libglib), Nothing, (Ptr{GVariant},), instance)
        nothing
    end
    function VariantBuilder_new(_type::GVariantType)
        ret = ccall(("g_variant_builder_new", libglib), Ptr{GVariantBuilder}, (Ptr{GVariantType},), _type)
        ret2 = convert(GVariantBuilder, ret, true)
        ret2
    end
    function add_value(instance::GVariantBuilder, _value::GVariant)
        ret = ccall(("g_variant_builder_add_value", libglib), Nothing, (Ptr{GVariantBuilder}, Ptr{GVariant}), instance, _value)
        nothing
    end
    function close(instance::GVariantBuilder)
        ret = ccall(("g_variant_builder_close", libglib), Nothing, (Ptr{GVariantBuilder},), instance)
        nothing
    end
    function open(instance::GVariantBuilder, _type::GVariantType)
        ret = ccall(("g_variant_builder_open", libglib), Nothing, (Ptr{GVariantBuilder}, Ptr{GVariantType}), instance, _type)
        nothing
    end
    function ref(instance::GVariantBuilder)
        ret = ccall(("g_variant_builder_ref", libglib), Ptr{GVariantBuilder}, (Ptr{GVariantBuilder},), instance)
        ret2 = convert(GVariantBuilder, ret, true)
        ret2
    end
    function unref(instance::GVariantBuilder)
        reffed_instance = GLib.glib_ref(instance)
        ret = ccall(("g_variant_builder_unref", libglib), Nothing, (Ptr{GVariantBuilder},), reffed_instance)
        nothing
    end
    function VariantDict_new(_from_asv::Maybe(GVariant))
        _from_asv_maybe = nothing_to_null(_from_asv)
        ret = ccall(("g_variant_dict_new", libglib), Ptr{GVariantDict}, (Ptr{GVariant},), _from_asv_maybe)
        ret2 = convert(GVariantDict, ret, true)
        ret2
    end
    function clear(instance::GVariantDict)
        ret = ccall(("g_variant_dict_clear", libglib), Nothing, (Ptr{GVariantDict},), instance)
        nothing
    end
    function contains(instance::GVariantDict, _key::Union{AbstractString, Symbol})
        ret = ccall(("g_variant_dict_contains", libglib), Cint, (Ptr{GVariantDict}, Cstring), instance, _key)
        ret2 = convert(Bool, ret)
        ret2
    end
    function insert_value(instance::GVariantDict, _key::Union{AbstractString, Symbol}, _value::GVariant)
        ret = ccall(("g_variant_dict_insert_value", libglib), Nothing, (Ptr{GVariantDict}, Cstring, Ptr{GVariant}), instance, _key, _value)
        nothing
    end
    function lookup_value(instance::GVariantDict, _key::Union{AbstractString, Symbol}, _expected_type::Maybe(GVariantType))
        _expected_type_maybe = nothing_to_null(_expected_type)
        ret = ccall(("g_variant_dict_lookup_value", libglib), Ptr{GVariant}, (Ptr{GVariantDict}, Cstring, Ptr{GVariantType}), instance, _key, _expected_type_maybe)
        ret2 = convert(GVariant, ret)
        ret2
    end
    function ref(instance::GVariantDict)
        ret = ccall(("g_variant_dict_ref", libglib), Ptr{GVariantDict}, (Ptr{GVariantDict},), instance)
        ret2 = convert(GVariantDict, ret, true)
        ret2
    end
    function remove(instance::GVariantDict, _key::Union{AbstractString, Symbol})
        ret = ccall(("g_variant_dict_remove", libglib), Cint, (Ptr{GVariantDict}, Cstring), instance, _key)
        ret2 = convert(Bool, ret)
        ret2
    end
    function unref(instance::GVariantDict)
        reffed_instance = GLib.glib_ref(instance)
        ret = ccall(("g_variant_dict_unref", libglib), Nothing, (Ptr{GVariantDict},), reffed_instance)
        nothing
    end
    function VariantType_new(_type_string::Union{AbstractString, Symbol})
        ret = ccall(("g_variant_type_new", libglib), Ptr{GVariantType}, (Cstring,), _type_string)
        ret2 = convert(GVariantType, ret, true)
        ret2
    end
    function VariantType_new_array(_element::GVariantType)
        ret = ccall(("g_variant_type_new_array", libglib), Ptr{GVariantType}, (Ptr{GVariantType},), _element)
        ret2 = convert(GVariantType, ret, true)
        ret2
    end
    function VariantType_new_dict_entry(_key::GVariantType, _value::GVariantType)
        ret = ccall(("g_variant_type_new_dict_entry", libglib), Ptr{GVariantType}, (Ptr{GVariantType}, Ptr{GVariantType}), _key, _value)
        ret2 = convert(GVariantType, ret, true)
        ret2
    end
    function VariantType_new_maybe(_element::GVariantType)
        ret = ccall(("g_variant_type_new_maybe", libglib), Ptr{GVariantType}, (Ptr{GVariantType},), _element)
        ret2 = convert(GVariantType, ret, true)
        ret2
    end
    function VariantType_new_tuple(_items)
        _items_arr = convert(Vector{Ptr{GVariantType}}, _items)
        _length = length(_items)
        ret = ccall(("g_variant_type_new_tuple", libglib), Ptr{GVariantType}, (Ptr{Ptr{GVariantType}}, Int32), _items_arr, _length)
        ret2 = convert(GVariantType, ret, true)
        ret2
    end
    function copy(instance::GVariantType)
        ret = ccall(("g_variant_type_copy", libglib), Ptr{GVariantType}, (Ptr{GVariantType},), instance)
        ret2 = convert(GVariantType, ret, true)
        ret2
    end
    function dup_string(instance::GVariantType)
        ret = ccall(("g_variant_type_dup_string", libglib), Cstring, (Ptr{GVariantType},), instance)
        ret2 = string_or_nothing(ret, true)
        ret2
    end
    function element(instance::GVariantType)
        ret = ccall(("g_variant_type_element", libglib), Ptr{GVariantType}, (Ptr{GVariantType},), instance)
        ret2 = convert(GVariantType, ret, false)
        ret2
    end
    function equal(instance::GVariantType, _type2::GVariantType)
        ret = ccall(("g_variant_type_equal", libglib), Cint, (Ptr{GVariantType}, Ptr{GVariantType}), instance, _type2)
        ret2 = convert(Bool, ret)
        ret2
    end
    function first(instance::GVariantType)
        ret = ccall(("g_variant_type_first", libglib), Ptr{GVariantType}, (Ptr{GVariantType},), instance)
        ret2 = convert(GVariantType, ret, false)
        ret2
    end
    function free(instance::GVariantType)
        ret = ccall(("g_variant_type_free", libglib), Nothing, (Ptr{GVariantType},), instance)
        nothing
    end
    function get_string_length(instance::GVariantType)
        ret = ccall(("g_variant_type_get_string_length", libglib), UInt64, (Ptr{GVariantType},), instance)
        ret
    end
    function hash(instance::GVariantType)
        ret = ccall(("g_variant_type_hash", libglib), UInt32, (Ptr{GVariantType},), instance)
        ret
    end
    function is_array(instance::GVariantType)
        ret = ccall(("g_variant_type_is_array", libglib), Cint, (Ptr{GVariantType},), instance)
        ret2 = convert(Bool, ret)
        ret2
    end
    function is_basic(instance::GVariantType)
        ret = ccall(("g_variant_type_is_basic", libglib), Cint, (Ptr{GVariantType},), instance)
        ret2 = convert(Bool, ret)
        ret2
    end
    function is_container(instance::GVariantType)
        ret = ccall(("g_variant_type_is_container", libglib), Cint, (Ptr{GVariantType},), instance)
        ret2 = convert(Bool, ret)
        ret2
    end
    function is_definite(instance::GVariantType)
        ret = ccall(("g_variant_type_is_definite", libglib), Cint, (Ptr{GVariantType},), instance)
        ret2 = convert(Bool, ret)
        ret2
    end
    function is_dict_entry(instance::GVariantType)
        ret = ccall(("g_variant_type_is_dict_entry", libglib), Cint, (Ptr{GVariantType},), instance)
        ret2 = convert(Bool, ret)
        ret2
    end
    function is_maybe(instance::GVariantType)
        ret = ccall(("g_variant_type_is_maybe", libglib), Cint, (Ptr{GVariantType},), instance)
        ret2 = convert(Bool, ret)
        ret2
    end
    function is_subtype_of(instance::GVariantType, _supertype::GVariantType)
        ret = ccall(("g_variant_type_is_subtype_of", libglib), Cint, (Ptr{GVariantType}, Ptr{GVariantType}), instance, _supertype)
        ret2 = convert(Bool, ret)
        ret2
    end
    function is_tuple(instance::GVariantType)
        ret = ccall(("g_variant_type_is_tuple", libglib), Cint, (Ptr{GVariantType},), instance)
        ret2 = convert(Bool, ret)
        ret2
    end
    function is_variant(instance::GVariantType)
        ret = ccall(("g_variant_type_is_variant", libglib), Cint, (Ptr{GVariantType},), instance)
        ret2 = convert(Bool, ret)
        ret2
    end
    function key(instance::GVariantType)
        ret = ccall(("g_variant_type_key", libglib), Ptr{GVariantType}, (Ptr{GVariantType},), instance)
        ret2 = convert(GVariantType, ret, false)
        ret2
    end
    function n_items(instance::GVariantType)
        ret = ccall(("g_variant_type_n_items", libglib), UInt64, (Ptr{GVariantType},), instance)
        ret
    end
    function next(instance::GVariantType)
        ret = ccall(("g_variant_type_next", libglib), Ptr{GVariantType}, (Ptr{GVariantType},), instance)
        ret2 = convert(GVariantType, ret, false)
        ret2
    end
    function value(instance::GVariantType)
        ret = ccall(("g_variant_type_value", libglib), Ptr{GVariantType}, (Ptr{GVariantType},), instance)
        ret2 = convert(GVariantType, ret, false)
        ret2
    end
end
