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)
    begin
        _eval_cfunc = @cfunction(GRegexEvalCallback, Cint, (Ptr{GMatchInfo}, Ptr{_GString}, Ref{Function}))
        begin
            ref = Ref{Any}(_eval)
            _eval_closure = unsafe_load(convert(Ptr{Ptr{Nothing}}, Base.unsafe_convert(Ptr{Any}, ref)))
        end
    end
    _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
