function FileAttributeInfoList_new()
    ret = ccall(("g_file_attribute_info_list_new", libgio), Ptr{_GFileAttributeInfoList}, ())
    ret2 = convert(GFileAttributeInfoListLike, ret, true)
    ret2
end
function add(instance::GFileAttributeInfoListLike, _name::Union{AbstractString, Symbol}, _type, _flags)
    ret = ccall(("g_file_attribute_info_list_add", libgio), Nothing, (Ptr{_GFileAttributeInfoList}, Cstring, UInt32, UInt32), instance, _name, _type, _flags)
    nothing
end
function dup(instance::GFileAttributeInfoListLike)
    ret = ccall(("g_file_attribute_info_list_dup", libgio), Ptr{_GFileAttributeInfoList}, (Ptr{_GFileAttributeInfoList},), instance)
    ret2 = convert(GFileAttributeInfoListLike, ret, true)
    ret2
end
function lookup(instance::GFileAttributeInfoListLike, _name::Union{AbstractString, Symbol})
    ret = ccall(("g_file_attribute_info_list_lookup", libgio), Ptr{_GFileAttributeInfo}, (Ptr{_GFileAttributeInfoList}, Cstring), instance, _name)
    ret2 = convert(GFileAttributeInfoLike, ret)
    ret2
end
function ref(instance::GFileAttributeInfoListLike)
    ret = ccall(("g_file_attribute_info_list_ref", libgio), Ptr{_GFileAttributeInfoList}, (Ptr{_GFileAttributeInfoList},), instance)
    ret2 = convert(GFileAttributeInfoListLike, ret, true)
    ret2
end
function unref(instance::GFileAttributeInfoListLike)
    ret = ccall(("g_file_attribute_info_list_unref", libgio), Nothing, (Ptr{_GFileAttributeInfoList},), instance)
    nothing
end
function FileAttributeMatcher_new(_attributes::Union{AbstractString, Symbol})
    ret = ccall(("g_file_attribute_matcher_new", libgio), Ptr{GFileAttributeMatcher}, (Cstring,), _attributes)
    ret2 = convert(GFileAttributeMatcher, ret, true)
    ret2
end
function enumerate_namespace(instance::GFileAttributeMatcher, _ns::Union{AbstractString, Symbol})
    ret = ccall(("g_file_attribute_matcher_enumerate_namespace", libgio), Cint, (Ptr{GFileAttributeMatcher}, Cstring), instance, _ns)
    ret2 = convert(Bool, ret)
    ret2
end
function enumerate_next(instance::GFileAttributeMatcher)
    ret = ccall(("g_file_attribute_matcher_enumerate_next", libgio), Cstring, (Ptr{GFileAttributeMatcher},), instance)
    ret2 = string_or_nothing(ret, false)
    ret2
end
function matches(instance::GFileAttributeMatcher, _attribute::Union{AbstractString, Symbol})
    ret = ccall(("g_file_attribute_matcher_matches", libgio), Cint, (Ptr{GFileAttributeMatcher}, Cstring), instance, _attribute)
    ret2 = convert(Bool, ret)
    ret2
end
function matches_only(instance::GFileAttributeMatcher, _attribute::Union{AbstractString, Symbol})
    ret = ccall(("g_file_attribute_matcher_matches_only", libgio), Cint, (Ptr{GFileAttributeMatcher}, Cstring), instance, _attribute)
    ret2 = convert(Bool, ret)
    ret2
end
function ref(instance::GFileAttributeMatcher)
    ret = ccall(("g_file_attribute_matcher_ref", libgio), Ptr{GFileAttributeMatcher}, (Ptr{GFileAttributeMatcher},), instance)
    ret2 = convert(GFileAttributeMatcher, ret, true)
    ret2
end
function subtract(instance::GFileAttributeMatcher, _subtract::Maybe(GFileAttributeMatcher))
    _subtract_maybe = nothing_to_null(_subtract)
    ret = ccall(("g_file_attribute_matcher_subtract", libgio), Ptr{GFileAttributeMatcher}, (Ptr{GFileAttributeMatcher}, Ptr{GFileAttributeMatcher}), instance, _subtract_maybe)
    ret2 = convert_if_not_null(GFileAttributeMatcher, ret, true)
    ret2
end
function to_string(instance::GFileAttributeMatcher)
    ret = ccall(("g_file_attribute_matcher_to_string", libgio), Cstring, (Ptr{GFileAttributeMatcher},), instance)
    ret2 = string_or_nothing(ret, true)
    ret2
end
function unref(instance::GFileAttributeMatcher)
    ret = ccall(("g_file_attribute_matcher_unref", libgio), Nothing, (Ptr{GFileAttributeMatcher},), instance)
    nothing
end
function Resource_new_from_data(_data::GBytes)
    err = err_buf()
    ret = ccall(("g_resource_new_from_data", libgio), Ptr{GResource}, (Ptr{GBytes}, Ptr{Ptr{GError}}), _data, err)
    check_err(err)
    ret2 = convert(GResource, ret, true)
    ret2
end
function _register(instance::GResource)
    ret = ccall(("g_resources_register", libgio), Nothing, (Ptr{GResource},), instance)
    nothing
end
function _unregister(instance::GResource)
    ret = ccall(("g_resources_unregister", libgio), Nothing, (Ptr{GResource},), instance)
    nothing
end
function enumerate_children(instance::GResource, _path::Union{AbstractString, Symbol}, _lookup_flags)
    err = err_buf()
    ret = ccall(("g_resource_enumerate_children", libgio), Ptr{Cstring}, (Ptr{GResource}, Cstring, UInt32, Ptr{Ptr{GError}}), instance, _path, _lookup_flags, 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 get_info(instance::GResource, _path::Union{AbstractString, Symbol}, _lookup_flags)
    m_size = Ref{UInt64}()
    m_flags = Ref{UInt32}()
    err = err_buf()
    ret = ccall(("g_resource_get_info", libgio), Cint, (Ptr{GResource}, Cstring, UInt32, Ptr{UInt64}, Ptr{UInt32}, Ptr{Ptr{GError}}), instance, _path, _lookup_flags, m_size, m_flags, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    _size = m_size[]
    _flags = m_flags[]
    (ret2, _size, _flags)
end
function lookup_data(instance::GResource, _path::Union{AbstractString, Symbol}, _lookup_flags)
    err = err_buf()
    ret = ccall(("g_resource_lookup_data", libgio), Ptr{GBytes}, (Ptr{GResource}, Cstring, UInt32, Ptr{Ptr{GError}}), instance, _path, _lookup_flags, err)
    check_err(err)
    ret2 = convert(GBytes, ret, true)
    ret2
end
function open_stream(instance::GResource, _path::Union{AbstractString, Symbol}, _lookup_flags)
    err = err_buf()
    ret = ccall(("g_resource_open_stream", libgio), Ptr{GObject}, (Ptr{GResource}, Cstring, UInt32, Ptr{Ptr{GError}}), instance, _path, _lookup_flags, err)
    check_err(err)
    ret2 = convert(GInputStream, ret, true)
    ret2
end
function ref(instance::GResource)
    ret = ccall(("g_resource_ref", libgio), Ptr{GResource}, (Ptr{GResource},), instance)
    ret2 = convert(GResource, ret, true)
    ret2
end
function unref(instance::GResource)
    ret = ccall(("g_resource_unref", libgio), Nothing, (Ptr{GResource},), instance)
    nothing
end
function get_id(instance::GSettingsSchema)
    ret = ccall(("g_settings_schema_get_id", libgio), Cstring, (Ptr{GSettingsSchema},), instance)
    ret2 = string_or_nothing(ret, false)
    ret2
end
function get_key(instance::GSettingsSchema, _name::Union{AbstractString, Symbol})
    ret = ccall(("g_settings_schema_get_key", libgio), Ptr{GSettingsSchemaKey}, (Ptr{GSettingsSchema}, Cstring), instance, _name)
    ret2 = convert(GSettingsSchemaKey, ret, true)
    ret2
end
function get_path(instance::GSettingsSchema)
    ret = ccall(("g_settings_schema_get_path", libgio), Cstring, (Ptr{GSettingsSchema},), instance)
    ret2 = string_or_nothing(ret, false)
    ret2
end
function has_key(instance::GSettingsSchema, _name::Union{AbstractString, Symbol})
    ret = ccall(("g_settings_schema_has_key", libgio), Cint, (Ptr{GSettingsSchema}, Cstring), instance, _name)
    ret2 = convert(Bool, ret)
    ret2
end
function list_children(instance::GSettingsSchema)
    ret = ccall(("g_settings_schema_list_children", libgio), Ptr{Cstring}, (Ptr{GSettingsSchema},), instance)
    ret2 = begin
            _len = length_zt(ret)
            arrtemp = bytestring.(unsafe_wrap(Vector{Cstring}, ret, _len))
            GLib.g_strfreev(ret)
            arrtemp
        end
    ret2
end
function list_keys(instance::GSettingsSchema)
    ret = ccall(("g_settings_schema_list_keys", libgio), Ptr{Cstring}, (Ptr{GSettingsSchema},), instance)
    ret2 = begin
            _len = length_zt(ret)
            arrtemp = bytestring.(unsafe_wrap(Vector{Cstring}, ret, _len))
            GLib.g_strfreev(ret)
            arrtemp
        end
    ret2
end
function ref(instance::GSettingsSchema)
    ret = ccall(("g_settings_schema_ref", libgio), Ptr{GSettingsSchema}, (Ptr{GSettingsSchema},), instance)
    ret2 = convert(GSettingsSchema, ret, true)
    ret2
end
function unref(instance::GSettingsSchema)
    ret = ccall(("g_settings_schema_unref", libgio), Nothing, (Ptr{GSettingsSchema},), instance)
    nothing
end
function get_default_value(instance::GSettingsSchemaKey)
    ret = ccall(("g_settings_schema_key_get_default_value", libgio), Ptr{GVariant}, (Ptr{GSettingsSchemaKey},), instance)
    ret2 = convert(GVariant, ret)
    ret2
end
function get_description(instance::GSettingsSchemaKey)
    ret = ccall(("g_settings_schema_key_get_description", libgio), Cstring, (Ptr{GSettingsSchemaKey},), instance)
    ret2 = string_or_nothing(ret, false)
    ret2
end
function get_name(instance::GSettingsSchemaKey)
    ret = ccall(("g_settings_schema_key_get_name", libgio), Cstring, (Ptr{GSettingsSchemaKey},), instance)
    ret2 = string_or_nothing(ret, false)
    ret2
end
function get_range(instance::GSettingsSchemaKey)
    ret = ccall(("g_settings_schema_key_get_range", libgio), Ptr{GVariant}, (Ptr{GSettingsSchemaKey},), instance)
    ret2 = convert(GVariant, ret)
    ret2
end
function get_summary(instance::GSettingsSchemaKey)
    ret = ccall(("g_settings_schema_key_get_summary", libgio), Cstring, (Ptr{GSettingsSchemaKey},), instance)
    ret2 = string_or_nothing(ret, false)
    ret2
end
function get_value_type(instance::GSettingsSchemaKey)
    ret = ccall(("g_settings_schema_key_get_value_type", libgio), Ptr{GVariantType}, (Ptr{GSettingsSchemaKey},), instance)
    ret2 = convert(GVariantType, ret, false)
    ret2
end
function range_check(instance::GSettingsSchemaKey, _value::GVariant)
    ret = ccall(("g_settings_schema_key_range_check", libgio), Cint, (Ptr{GSettingsSchemaKey}, Ptr{GVariant}), instance, _value)
    ret2 = convert(Bool, ret)
    ret2
end
function ref(instance::GSettingsSchemaKey)
    ret = ccall(("g_settings_schema_key_ref", libgio), Ptr{GSettingsSchemaKey}, (Ptr{GSettingsSchemaKey},), instance)
    ret2 = convert(GSettingsSchemaKey, ret, true)
    ret2
end
function unref(instance::GSettingsSchemaKey)
    ret = ccall(("g_settings_schema_key_unref", libgio), Nothing, (Ptr{GSettingsSchemaKey},), instance)
    nothing
end
function SettingsSchemaSource_new_from_directory(_directory::Union{AbstractString, Symbol}, _parent::Maybe(GSettingsSchemaSource), _trusted::Bool)
    _parent_maybe = nothing_to_null(_parent)
    err = err_buf()
    ret = ccall(("g_settings_schema_source_new_from_directory", libgio), Ptr{GSettingsSchemaSource}, (Cstring, Ptr{GSettingsSchemaSource}, Cint, Ptr{Ptr{GError}}), _directory, _parent_maybe, _trusted, err)
    check_err(err)
    ret2 = convert(GSettingsSchemaSource, ret, true)
    ret2
end
function list_schemas(instance::GSettingsSchemaSource, _recursive::Bool)
    m_non_relocatable = Ref{Ptr{Cstring}}()
    m_relocatable = Ref{Ptr{Cstring}}()
    ret = ccall(("g_settings_schema_source_list_schemas", libgio), Nothing, (Ptr{GSettingsSchemaSource}, Cint, Ptr{Ptr{Cstring}}, Ptr{Ptr{Cstring}}), instance, _recursive, m_non_relocatable, m_relocatable)
    _non_relocatable = m_non_relocatable[]
    _non_relocatable = begin
            _len = length_zt(_non_relocatable)
            arrtemp = bytestring.(unsafe_wrap(Vector{Cstring}, _non_relocatable, _len))
            GLib.g_strfreev(_non_relocatable)
            arrtemp
        end
    _relocatable = m_relocatable[]
    _relocatable = begin
            _len = length_zt(_relocatable)
            arrtemp = bytestring.(unsafe_wrap(Vector{Cstring}, _relocatable, _len))
            GLib.g_strfreev(_relocatable)
            arrtemp
        end
    (_non_relocatable, _relocatable)
end
function lookup(instance::GSettingsSchemaSource, _schema_id::Union{AbstractString, Symbol}, _recursive::Bool)
    ret = ccall(("g_settings_schema_source_lookup", libgio), Ptr{GSettingsSchema}, (Ptr{GSettingsSchemaSource}, Cstring, Cint), instance, _schema_id, _recursive)
    ret2 = convert_if_not_null(GSettingsSchema, ret, true)
    ret2
end
function ref(instance::GSettingsSchemaSource)
    ret = ccall(("g_settings_schema_source_ref", libgio), Ptr{GSettingsSchemaSource}, (Ptr{GSettingsSchemaSource},), instance)
    ret2 = convert(GSettingsSchemaSource, ret, true)
    ret2
end
function unref(instance::GSettingsSchemaSource)
    ret = ccall(("g_settings_schema_source_unref", libgio), Nothing, (Ptr{GSettingsSchemaSource},), instance)
    nothing
end
function SrvTarget_new(_hostname::Union{AbstractString, Symbol}, _port::Integer, _priority::Integer, _weight::Integer)
    ret = ccall(("g_srv_target_new", libgio), Ptr{GSrvTarget}, (Cstring, UInt16, UInt16, UInt16), _hostname, _port, _priority, _weight)
    ret2 = convert(GSrvTarget, ret, true)
    ret2
end
function copy(instance::GSrvTarget)
    ret = ccall(("g_srv_target_copy", libgio), Ptr{GSrvTarget}, (Ptr{GSrvTarget},), instance)
    ret2 = convert(GSrvTarget, ret, true)
    ret2
end
function free(instance::GSrvTarget)
    ret = ccall(("g_srv_target_free", libgio), Nothing, (Ptr{GSrvTarget},), instance)
    nothing
end
function get_hostname(instance::GSrvTarget)
    ret = ccall(("g_srv_target_get_hostname", libgio), Cstring, (Ptr{GSrvTarget},), instance)
    ret2 = string_or_nothing(ret, false)
    ret2
end
function get_port(instance::GSrvTarget)
    ret = ccall(("g_srv_target_get_port", libgio), UInt16, (Ptr{GSrvTarget},), instance)
    ret
end
function get_priority(instance::GSrvTarget)
    ret = ccall(("g_srv_target_get_priority", libgio), UInt16, (Ptr{GSrvTarget},), instance)
    ret
end
function get_weight(instance::GSrvTarget)
    ret = ccall(("g_srv_target_get_weight", libgio), UInt16, (Ptr{GSrvTarget},), instance)
    ret
end
function AppLaunchContext_new()
    ret = ccall(("g_app_launch_context_new", libgio), Ptr{GObject}, ())
    ret2 = GAppLaunchContextLeaf(ret, true)
    ret2
end
function get_display(instance::GAppLaunchContext, _info::GAppInfo, _files::GLib.LList{GLib._GList{Ptr{GObject}}})
    ret = ccall(("g_app_launch_context_get_display", libgio), Cstring, (Ptr{GObject}, Ptr{GObject}, Ptr{GLib._GList{Ptr{GObject}}}), instance, _info, _files)
    ret2 = string_or_nothing(ret, true)
    ret2
end
function get_environment(instance::GAppLaunchContext)
    ret = ccall(("g_app_launch_context_get_environment", libgio), Ptr{Cstring}, (Ptr{GObject},), instance)
    ret2 = begin
            _len = length_zt(ret)
            arrtemp = bytestring.(unsafe_wrap(Vector{Cstring}, ret, _len))
            GLib.g_strfreev(ret)
            arrtemp
        end
    ret2
end
function get_startup_notify_id(instance::GAppLaunchContext, _info::Maybe(GAppInfo), _files::Maybe(GLib.LList{GLib._GList{Ptr{GObject}}}))
    _info_maybe = nothing_to_null(_info)
    _files_maybe = nothing_to_null(_files)
    ret = ccall(("g_app_launch_context_get_startup_notify_id", libgio), Cstring, (Ptr{GObject}, Ptr{GObject}, Ptr{GLib._GList{Ptr{GObject}}}), instance, _info_maybe, _files_maybe)
    ret2 = string_or_nothing(ret, true)
    ret2
end
function launch_failed(instance::GAppLaunchContext, _startup_notify_id::Union{AbstractString, Symbol})
    ret = ccall(("g_app_launch_context_launch_failed", libgio), Nothing, (Ptr{GObject}, Cstring), instance, _startup_notify_id)
    nothing
end
function setenv(instance::GAppLaunchContext, _variable::Union{AbstractString, Symbol}, _value::Union{AbstractString, Symbol})
    ret = ccall(("g_app_launch_context_setenv", libgio), Nothing, (Ptr{GObject}, Cstring, Cstring), instance, _variable, _value)
    nothing
end
function unsetenv(instance::GAppLaunchContext, _variable::Union{AbstractString, Symbol})
    ret = ccall(("g_app_launch_context_unsetenv", libgio), Nothing, (Ptr{GObject}, Cstring), instance, _variable)
    nothing
end
function Application_new(_application_id::Maybe(Union{AbstractString, Symbol}), _flags)
    _application_id_maybe = nothing_to_null(_application_id)
    ret = ccall(("g_application_new", libgio), Ptr{GObject}, (Cstring, UInt32), _application_id_maybe, _flags)
    ret2 = GApplicationLeaf(ret, true)
    ret2
end
function id_is_valid(_application_id::Union{AbstractString, Symbol})
    ret = ccall(("g_application_id_is_valid", libgio), Cint, (Cstring,), _application_id)
    ret2 = convert(Bool, ret)
    ret2
end
function activate(instance::GApplication)
    ret = ccall(("g_application_activate", libgio), Nothing, (Ptr{GObject},), instance)
    nothing
end
function add_main_option(instance::GApplication, _long_name::Union{AbstractString, Symbol}, _short_name::Integer, _flags, _arg, _description::Union{AbstractString, Symbol}, _arg_description::Maybe(Union{AbstractString, Symbol}))
    _arg_description_maybe = nothing_to_null(_arg_description)
    ret = ccall(("g_application_add_main_option", libgio), Nothing, (Ptr{GObject}, Cstring, Int8, UInt32, UInt32, Cstring, Cstring), instance, _long_name, _short_name, _flags, _arg, _description, _arg_description_maybe)
    nothing
end
function add_main_option_entries(instance::GApplication, _entries)
    _entries_arr = convert(Vector{_GOptionEntry}, _entries)
    ret = ccall(("g_application_add_main_option_entries", libgio), Nothing, (Ptr{GObject}, Ptr{_GOptionEntry}), instance, _entries_arr)
    nothing
end
function bind_busy_property(instance::GApplication, _object::GObject, _property::Union{AbstractString, Symbol})
    ret = ccall(("g_application_bind_busy_property", libgio), Nothing, (Ptr{GObject}, Ptr{GObject}, Cstring), instance, _object, _property)
    nothing
end
function get_application_id(instance::GApplication)
    ret = ccall(("g_application_get_application_id", libgio), Cstring, (Ptr{GObject},), instance)
    ret2 = string_or_nothing(ret, false)
    ret2
end
function get_dbus_connection(instance::GApplication)
    ret = ccall(("g_application_get_dbus_connection", libgio), Ptr{GObject}, (Ptr{GObject},), instance)
    ret2 = convert_if_not_null(GDBusConnection, ret, false)
    ret2
end
function get_dbus_object_path(instance::GApplication)
    ret = ccall(("g_application_get_dbus_object_path", libgio), Cstring, (Ptr{GObject},), instance)
    ret2 = string_or_nothing(ret, false)
    ret2
end
function get_flags(instance::GApplication)
    ret = ccall(("g_application_get_flags", libgio), UInt32, (Ptr{GObject},), instance)
    ret2 = ApplicationFlags(ret)
    ret2
end
function get_inactivity_timeout(instance::GApplication)
    ret = ccall(("g_application_get_inactivity_timeout", libgio), UInt32, (Ptr{GObject},), instance)
    ret
end
function get_is_busy(instance::GApplication)
    ret = ccall(("g_application_get_is_busy", libgio), Cint, (Ptr{GObject},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function get_is_registered(instance::GApplication)
    ret = ccall(("g_application_get_is_registered", libgio), Cint, (Ptr{GObject},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function get_is_remote(instance::GApplication)
    ret = ccall(("g_application_get_is_remote", libgio), Cint, (Ptr{GObject},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function get_resource_base_path(instance::GApplication)
    ret = ccall(("g_application_get_resource_base_path", libgio), Cstring, (Ptr{GObject},), instance)
    ret2 = string_or_nothing(ret, false)
    ret2
end
function get_version(instance::GApplication)
    ret = ccall(("g_application_get_version", libgio), Cstring, (Ptr{GObject},), instance)
    ret2 = string_or_nothing(ret, false)
    ret2
end
function hold(instance::GApplication)
    ret = ccall(("g_application_hold", libgio), Nothing, (Ptr{GObject},), instance)
    nothing
end
function mark_busy(instance::GApplication)
    ret = ccall(("g_application_mark_busy", libgio), Nothing, (Ptr{GObject},), instance)
    nothing
end
function open(instance::GApplication, _files, _hint::Union{AbstractString, Symbol})
    _files_arr = convert(Vector{Ptr{GObject}}, _files)
    _n_files = length(_files)
    ret = ccall(("g_application_open", libgio), Nothing, (Ptr{GObject}, Ptr{Ptr{GObject}}, Int32, Cstring), instance, _files_arr, _n_files, _hint)
    nothing
end
function quit(instance::GApplication)
    ret = ccall(("g_application_quit", libgio), Nothing, (Ptr{GObject},), instance)
    nothing
end
function register(instance::GApplication, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_application_register", libgio), Cint, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _cancellable_maybe, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function release(instance::GApplication)
    ret = ccall(("g_application_release", libgio), Nothing, (Ptr{GObject},), instance)
    nothing
end
function run(instance::GApplication, _argv)
    _argv_maybe = nothing_to_null(_argv)
    _argc = length(_argv)
    ret = ccall(("g_application_run", libgio), Int32, (Ptr{GObject}, Int32, Ptr{Cstring}), instance, _argc, _argv_maybe)
    ret
end
function send_notification(instance::GApplication, _id::Maybe(Union{AbstractString, Symbol}), _notification::GNotification)
    _id_maybe = nothing_to_null(_id)
    ret = ccall(("g_application_send_notification", libgio), Nothing, (Ptr{GObject}, Cstring, Ptr{GObject}), instance, _id_maybe, _notification)
    nothing
end
function set_application_id(instance::GApplication, _application_id::Maybe(Union{AbstractString, Symbol}))
    _application_id_maybe = nothing_to_null(_application_id)
    ret = ccall(("g_application_set_application_id", libgio), Nothing, (Ptr{GObject}, Cstring), instance, _application_id_maybe)
    nothing
end
function set_default(instance::GApplication)
    ret = ccall(("g_application_set_default", libgio), Nothing, (Ptr{GObject},), instance)
    nothing
end
function set_flags(instance::GApplication, _flags)
    ret = ccall(("g_application_set_flags", libgio), Nothing, (Ptr{GObject}, UInt32), instance, _flags)
    nothing
end
function set_inactivity_timeout(instance::GApplication, _inactivity_timeout::Integer)
    ret = ccall(("g_application_set_inactivity_timeout", libgio), Nothing, (Ptr{GObject}, UInt32), instance, _inactivity_timeout)
    nothing
end
function set_option_context_description(instance::GApplication, _description::Maybe(Union{AbstractString, Symbol}))
    _description_maybe = nothing_to_null(_description)
    ret = ccall(("g_application_set_option_context_description", libgio), Nothing, (Ptr{GObject}, Cstring), instance, _description_maybe)
    nothing
end
function set_option_context_parameter_string(instance::GApplication, _parameter_string::Maybe(Union{AbstractString, Symbol}))
    _parameter_string_maybe = nothing_to_null(_parameter_string)
    ret = ccall(("g_application_set_option_context_parameter_string", libgio), Nothing, (Ptr{GObject}, Cstring), instance, _parameter_string_maybe)
    nothing
end
function set_option_context_summary(instance::GApplication, _summary::Maybe(Union{AbstractString, Symbol}))
    _summary_maybe = nothing_to_null(_summary)
    ret = ccall(("g_application_set_option_context_summary", libgio), Nothing, (Ptr{GObject}, Cstring), instance, _summary_maybe)
    nothing
end
function set_resource_base_path(instance::GApplication, _resource_path::Maybe(Union{AbstractString, Symbol}))
    _resource_path_maybe = nothing_to_null(_resource_path)
    ret = ccall(("g_application_set_resource_base_path", libgio), Nothing, (Ptr{GObject}, Cstring), instance, _resource_path_maybe)
    nothing
end
function set_version(instance::GApplication, _version::Union{AbstractString, Symbol})
    ret = ccall(("g_application_set_version", libgio), Nothing, (Ptr{GObject}, Cstring), instance, _version)
    nothing
end
function unbind_busy_property(instance::GApplication, _object::GObject, _property::Union{AbstractString, Symbol})
    ret = ccall(("g_application_unbind_busy_property", libgio), Nothing, (Ptr{GObject}, Ptr{GObject}, Cstring), instance, _object, _property)
    nothing
end
function unmark_busy(instance::GApplication)
    ret = ccall(("g_application_unmark_busy", libgio), Nothing, (Ptr{GObject},), instance)
    nothing
end
function withdraw_notification(instance::GApplication, _id::Union{AbstractString, Symbol})
    ret = ccall(("g_application_withdraw_notification", libgio), Nothing, (Ptr{GObject}, Cstring), instance, _id)
    nothing
end
function action_added(instance::GApplication, _action_name::Union{AbstractString, Symbol})
    action_added(GActionGroup(instance), _action_name)
end
function action_enabled_changed(instance::GApplication, _action_name::Union{AbstractString, Symbol}, _enabled::Bool)
    action_enabled_changed(GActionGroup(instance), _action_name, _enabled)
end
function action_removed(instance::GApplication, _action_name::Union{AbstractString, Symbol})
    action_removed(GActionGroup(instance), _action_name)
end
function action_state_changed(instance::GApplication, _action_name::Union{AbstractString, Symbol}, _state::GVariant)
    action_state_changed(GActionGroup(instance), _action_name, _state)
end
function activate_action(instance::GApplication, _action_name::Union{AbstractString, Symbol}, _parameter::Maybe(GVariant))
    activate_action(GActionGroup(instance), _action_name, _parameter)
end
function change_action_state(instance::GApplication, _action_name::Union{AbstractString, Symbol}, _value::GVariant)
    change_action_state(GActionGroup(instance), _action_name, _value)
end
function get_action_enabled(instance::GApplication, _action_name::Union{AbstractString, Symbol})
    get_action_enabled(GActionGroup(instance), _action_name)
end
function get_action_parameter_type(instance::GApplication, _action_name::Union{AbstractString, Symbol})
    get_action_parameter_type(GActionGroup(instance), _action_name)
end
function get_action_state(instance::GApplication, _action_name::Union{AbstractString, Symbol})
    get_action_state(GActionGroup(instance), _action_name)
end
function get_action_state_hint(instance::GApplication, _action_name::Union{AbstractString, Symbol})
    get_action_state_hint(GActionGroup(instance), _action_name)
end
function get_action_state_type(instance::GApplication, _action_name::Union{AbstractString, Symbol})
    get_action_state_type(GActionGroup(instance), _action_name)
end
function has_action(instance::GApplication, _action_name::Union{AbstractString, Symbol})
    has_action(GActionGroup(instance), _action_name)
end
function list_actions(instance::GApplication)
    list_actions(GActionGroup(instance))
end
function query_action(instance::GApplication, _action_name::Union{AbstractString, Symbol})
    query_action(GActionGroup(instance), _action_name)
end
function add_action(instance::GApplication, _action::GAction)
    add_action(GActionMap(instance), _action)
end
function add_action_entries(instance::GApplication, _entries, _user_data::Maybe(Nothing))
    add_action_entries(GActionMap(instance), _entries, _user_data)
end
function lookup_action(instance::GApplication, _action_name::Union{AbstractString, Symbol})
    lookup_action(GActionMap(instance), _action_name)
end
function remove_action(instance::GApplication, _action_name::Union{AbstractString, Symbol})
    remove_action(GActionMap(instance), _action_name)
end
function remove_action_entries(instance::GApplication, _entries)
    remove_action_entries(GActionMap(instance), _entries)
end
function create_file_for_arg(instance::GApplicationCommandLine, _arg::Union{AbstractString, Symbol})
    ret = ccall(("g_application_command_line_create_file_for_arg", libgio), Ptr{GObject}, (Ptr{GObject}, Cstring), instance, _arg)
    ret2 = begin
            leaftype = GLib.find_leaf_type(ret)
            convert(leaftype, ret, true)
        end
    ret2
end
function done(instance::GApplicationCommandLine)
    ret = ccall(("g_application_command_line_done", libgio), Nothing, (Ptr{GObject},), instance)
    nothing
end
function get_arguments(instance::GApplicationCommandLine)
    m_argc = Ref{Int32}()
    ret = ccall(("g_application_command_line_get_arguments", libgio), Ptr{Cstring}, (Ptr{GObject}, Ptr{Int32}), instance, m_argc)
    ret2 = begin
            arrtemp = bytestring.(unsafe_wrap(Vector{Cstring}, ret, m_argc[]))
            GLib.g_free(ret)
            arrtemp
        end
    _argc = m_argc[]
    ret2
end
function get_cwd(instance::GApplicationCommandLine)
    ret = ccall(("g_application_command_line_get_cwd", libgio), Cstring, (Ptr{GObject},), instance)
    ret2 = string_or_nothing(ret, false)
    ret2
end
function get_environ(instance::GApplicationCommandLine)
    ret = ccall(("g_application_command_line_get_environ", libgio), Ptr{Cstring}, (Ptr{GObject},), instance)
    ret2 = begin
            _len = length_zt(ret)
            arrtemp = bytestring.(unsafe_wrap(Vector{Cstring}, ret, _len))
            arrtemp
        end
    ret2
end
function get_exit_status(instance::GApplicationCommandLine)
    ret = ccall(("g_application_command_line_get_exit_status", libgio), Int32, (Ptr{GObject},), instance)
    ret
end
function get_is_remote(instance::GApplicationCommandLine)
    ret = ccall(("g_application_command_line_get_is_remote", libgio), Cint, (Ptr{GObject},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function get_options_dict(instance::GApplicationCommandLine)
    ret = ccall(("g_application_command_line_get_options_dict", libgio), Ptr{GVariantDict}, (Ptr{GObject},), instance)
    ret2 = convert(GVariantDict, ret, false)
    ret2
end
function get_platform_data(instance::GApplicationCommandLine)
    ret = ccall(("g_application_command_line_get_platform_data", libgio), Ptr{GVariant}, (Ptr{GObject},), instance)
    ret2 = convert(GVariant, ret)
    ret2
end
function get_stdin(instance::GApplicationCommandLine)
    ret = ccall(("g_application_command_line_get_stdin", libgio), Ptr{GObject}, (Ptr{GObject},), instance)
    ret2 = convert_if_not_null(GInputStream, ret, true)
    ret2
end
function getenv(instance::GApplicationCommandLine, _name::Union{AbstractString, Symbol})
    ret = ccall(("g_application_command_line_getenv", libgio), Cstring, (Ptr{GObject}, Cstring), instance, _name)
    ret2 = string_or_nothing(ret, false)
    ret2
end
function print_literal(instance::GApplicationCommandLine, _message::Union{AbstractString, Symbol})
    ret = ccall(("g_application_command_line_print_literal", libgio), Nothing, (Ptr{GObject}, Cstring), instance, _message)
    nothing
end
function printerr_literal(instance::GApplicationCommandLine, _message::Union{AbstractString, Symbol})
    ret = ccall(("g_application_command_line_printerr_literal", libgio), Nothing, (Ptr{GObject}, Cstring), instance, _message)
    nothing
end
function set_exit_status(instance::GApplicationCommandLine, _exit_status::Integer)
    ret = ccall(("g_application_command_line_set_exit_status", libgio), Nothing, (Ptr{GObject}, Int32), instance, _exit_status)
    nothing
end
function BufferedInputStream_new(_base_stream::GInputStream)
    ret = ccall(("g_buffered_input_stream_new", libgio), Ptr{GObject}, (Ptr{GObject},), _base_stream)
    ret2 = GBufferedInputStreamLeaf(ret, true)
    ret2
end
function BufferedInputStream_new_sized(_base_stream::GInputStream, _size::Integer)
    ret = ccall(("g_buffered_input_stream_new_sized", libgio), Ptr{GObject}, (Ptr{GObject}, UInt64), _base_stream, _size)
    ret2 = GBufferedInputStreamLeaf(ret, true)
    ret2
end
function fill(instance::GBufferedInputStream, _count::Integer, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_buffered_input_stream_fill", libgio), Int64, (Ptr{GObject}, Int64, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _count, _cancellable_maybe, err)
    check_err(err)
    ret
end
function fill_async(instance::GBufferedInputStream, _count::Integer, _io_priority::Integer, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    ret = ccall(("g_buffered_input_stream_fill_async", libgio), Nothing, (Ptr{GObject}, Int64, Int32, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _count, _io_priority, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function fill_finish(instance::GBufferedInputStream, _result::GAsyncResult)
    err = err_buf()
    ret = ccall(("g_buffered_input_stream_fill_finish", libgio), Int64, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _result, err)
    check_err(err)
    ret
end
function get_available(instance::GBufferedInputStream)
    ret = ccall(("g_buffered_input_stream_get_available", libgio), UInt64, (Ptr{GObject},), instance)
    ret
end
function get_buffer_size(instance::GBufferedInputStream)
    ret = ccall(("g_buffered_input_stream_get_buffer_size", libgio), UInt64, (Ptr{GObject},), instance)
    ret
end
function peek(instance::GBufferedInputStream, _buffer, _offset::Integer)
    _buffer_arr = convert(Vector{UInt8}, _buffer)
    _count = length(_buffer)
    ret = ccall(("g_buffered_input_stream_peek", libgio), UInt64, (Ptr{GObject}, Ptr{UInt8}, UInt64, UInt64), instance, _buffer_arr, _offset, _count)
    ret
end
function peek_buffer(instance::GBufferedInputStream)
    m_count = Ref{UInt64}()
    ret = ccall(("g_buffered_input_stream_peek_buffer", libgio), Ptr{UInt8}, (Ptr{GObject}, Ptr{UInt64}), instance, m_count)
    ret2 = collect(unsafe_wrap(Vector{UInt8}, ret, m_count[]))
    _count = m_count[]
    ret2
end
function read_byte(instance::GBufferedInputStream, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_buffered_input_stream_read_byte", libgio), Int32, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _cancellable_maybe, err)
    check_err(err)
    ret
end
function set_buffer_size(instance::GBufferedInputStream, _size::Integer)
    ret = ccall(("g_buffered_input_stream_set_buffer_size", libgio), Nothing, (Ptr{GObject}, UInt64), instance, _size)
    nothing
end
function can_seek(instance::GBufferedInputStream)
    can_seek(GSeekable(instance))
end
function can_truncate(instance::GBufferedInputStream)
    can_truncate(GSeekable(instance))
end
function seek(instance::GBufferedInputStream, _offset::Integer, _type, _cancellable::Maybe(GCancellable))
    seek(GSeekable(instance), _offset, _type, _cancellable)
end
function tell(instance::GBufferedInputStream)
    tell(GSeekable(instance))
end
function truncate(instance::GBufferedInputStream, _offset::Integer, _cancellable::Maybe(GCancellable))
    truncate(GSeekable(instance), _offset, _cancellable)
end
function BufferedOutputStream_new(_base_stream::GOutputStream)
    ret = ccall(("g_buffered_output_stream_new", libgio), Ptr{GObject}, (Ptr{GObject},), _base_stream)
    ret2 = GBufferedOutputStreamLeaf(ret, true)
    ret2
end
function BufferedOutputStream_new_sized(_base_stream::GOutputStream, _size::Integer)
    ret = ccall(("g_buffered_output_stream_new_sized", libgio), Ptr{GObject}, (Ptr{GObject}, UInt64), _base_stream, _size)
    ret2 = GBufferedOutputStreamLeaf(ret, true)
    ret2
end
function get_auto_grow(instance::GBufferedOutputStream)
    ret = ccall(("g_buffered_output_stream_get_auto_grow", libgio), Cint, (Ptr{GObject},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function get_buffer_size(instance::GBufferedOutputStream)
    ret = ccall(("g_buffered_output_stream_get_buffer_size", libgio), UInt64, (Ptr{GObject},), instance)
    ret
end
function set_auto_grow(instance::GBufferedOutputStream, _auto_grow::Bool)
    ret = ccall(("g_buffered_output_stream_set_auto_grow", libgio), Nothing, (Ptr{GObject}, Cint), instance, _auto_grow)
    nothing
end
function set_buffer_size(instance::GBufferedOutputStream, _size::Integer)
    ret = ccall(("g_buffered_output_stream_set_buffer_size", libgio), Nothing, (Ptr{GObject}, UInt64), instance, _size)
    nothing
end
function can_seek(instance::GBufferedOutputStream)
    can_seek(GSeekable(instance))
end
function can_truncate(instance::GBufferedOutputStream)
    can_truncate(GSeekable(instance))
end
function seek(instance::GBufferedOutputStream, _offset::Integer, _type, _cancellable::Maybe(GCancellable))
    seek(GSeekable(instance), _offset, _type, _cancellable)
end
function tell(instance::GBufferedOutputStream)
    tell(GSeekable(instance))
end
function truncate(instance::GBufferedOutputStream, _offset::Integer, _cancellable::Maybe(GCancellable))
    truncate(GSeekable(instance), _offset, _cancellable)
end
function BytesIcon_new(_bytes::GBytes)
    ret = ccall(("g_bytes_icon_new", libgio), Ptr{GObject}, (Ptr{GBytes},), _bytes)
    ret2 = GBytesIconLeaf(ret, true)
    ret2
end
function get_bytes(instance::GBytesIcon)
    ret = ccall(("g_bytes_icon_get_bytes", libgio), Ptr{GBytes}, (Ptr{GObject},), instance)
    ret2 = convert(GBytes, ret, false)
    ret2
end
function equal(instance::GBytesIcon, _icon2::Maybe(GIcon))
    equal(GIcon(instance), _icon2)
end
function hash(instance::GBytesIcon)
    hash(GIcon(instance))
end
function serialize(instance::GBytesIcon)
    serialize(GIcon(instance))
end
function to_string(instance::GBytesIcon)
    to_string(GIcon(instance))
end
function load(instance::GBytesIcon, _size::Integer, _cancellable::Maybe(GCancellable))
    load(GLoadableIcon(instance), _size, _cancellable)
end
function load_async(instance::GBytesIcon, _size::Integer, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    load_async(GLoadableIcon(instance), _size, _cancellable, _callback)
end
function load_finish(instance::GBytesIcon, _res::GAsyncResult)
    load_finish(GLoadableIcon(instance), _res)
end
function Cancellable_new()
    ret = ccall(("g_cancellable_new", libgio), Ptr{GObject}, ())
    ret2 = GCancellableLeaf(ret, true)
    ret2
end
function get_current()
    ret = ccall(("g_cancellable_get_current", libgio), Ptr{GObject}, ())
    ret2 = convert_if_not_null(GCancellable, ret, false)
    ret2
end
function cancel(instance::GCancellable)
    ret = ccall(("g_cancellable_cancel", libgio), Nothing, (Ptr{GObject},), instance)
    nothing
end
function disconnect(instance::GCancellable, _handler_id::Integer)
    ret = ccall(("g_cancellable_disconnect", libgio), Nothing, (Ptr{GObject}, UInt64), instance, _handler_id)
    nothing
end
function get_fd(instance::GCancellable)
    ret = ccall(("g_cancellable_get_fd", libgio), Int32, (Ptr{GObject},), instance)
    ret
end
function is_cancelled(instance::GCancellable)
    ret = ccall(("g_cancellable_is_cancelled", libgio), Cint, (Ptr{GObject},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function pop_current(instance::GCancellable)
    ret = ccall(("g_cancellable_pop_current", libgio), Nothing, (Ptr{GObject},), instance)
    nothing
end
function push_current(instance::GCancellable)
    ret = ccall(("g_cancellable_push_current", libgio), Nothing, (Ptr{GObject},), instance)
    nothing
end
function release_fd(instance::GCancellable)
    ret = ccall(("g_cancellable_release_fd", libgio), Nothing, (Ptr{GObject},), instance)
    nothing
end
function reset(instance::GCancellable)
    ret = ccall(("g_cancellable_reset", libgio), Nothing, (Ptr{GObject},), instance)
    nothing
end
function set_error_if_cancelled(instance::GCancellable)
    err = err_buf()
    ret = ccall(("g_cancellable_set_error_if_cancelled", libgio), Cint, (Ptr{GObject}, Ptr{Ptr{GError}}), instance, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function source_new(instance::GCancellable)
    ret = ccall(("g_cancellable_source_new", libgio), Ptr{_GSource}, (Ptr{GObject},), instance)
    ret2 = convert(GSourceLike, ret, true)
    ret2
end
function CharsetConverter_new(_to_charset::Union{AbstractString, Symbol}, _from_charset::Union{AbstractString, Symbol})
    err = err_buf()
    ret = ccall(("g_charset_converter_new", libgio), Ptr{GObject}, (Cstring, Cstring, Ptr{Ptr{GError}}), _to_charset, _from_charset, err)
    check_err(err)
    ret2 = GCharsetConverterLeaf(ret, true)
    ret2
end
function get_num_fallbacks(instance::GCharsetConverter)
    ret = ccall(("g_charset_converter_get_num_fallbacks", libgio), UInt32, (Ptr{GObject},), instance)
    ret
end
function get_use_fallback(instance::GCharsetConverter)
    ret = ccall(("g_charset_converter_get_use_fallback", libgio), Cint, (Ptr{GObject},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function set_use_fallback(instance::GCharsetConverter, _use_fallback::Bool)
    ret = ccall(("g_charset_converter_set_use_fallback", libgio), Nothing, (Ptr{GObject}, Cint), instance, _use_fallback)
    nothing
end
function convert(instance::GCharsetConverter, _inbuf, _outbuf, _flags)
    convert(GConverter(instance), _inbuf, _outbuf, _flags)
end
function convert_bytes(instance::GCharsetConverter, _bytes::GBytes)
    convert_bytes(GConverter(instance), _bytes)
end
function reset(instance::GCharsetConverter)
    reset(GConverter(instance))
end
function init(instance::GCharsetConverter, _cancellable::Maybe(GCancellable))
    init(GInitable(instance), _cancellable)
end
function ConverterInputStream_new(_base_stream::GInputStream, _converter::GConverter)
    ret = ccall(("g_converter_input_stream_new", libgio), Ptr{GObject}, (Ptr{GObject}, Ptr{GObject}), _base_stream, _converter)
    ret2 = GConverterInputStreamLeaf(ret, true)
    ret2
end
function get_converter(instance::GConverterInputStream)
    ret = ccall(("g_converter_input_stream_get_converter", libgio), Ptr{GObject}, (Ptr{GObject},), instance)
    ret2 = begin
            leaftype = GLib.find_leaf_type(ret)
            convert(leaftype, ret, false)
        end
    ret2
end
function can_poll(instance::GConverterInputStream)
    can_poll(GPollableInputStream(instance))
end
function create_source(instance::GConverterInputStream, _cancellable::Maybe(GCancellable))
    create_source(GPollableInputStream(instance), _cancellable)
end
function is_readable(instance::GConverterInputStream)
    is_readable(GPollableInputStream(instance))
end
function read_nonblocking(instance::GConverterInputStream, _cancellable::Maybe(GCancellable))
    read_nonblocking(GPollableInputStream(instance), _cancellable)
end
function ConverterOutputStream_new(_base_stream::GOutputStream, _converter::GConverter)
    ret = ccall(("g_converter_output_stream_new", libgio), Ptr{GObject}, (Ptr{GObject}, Ptr{GObject}), _base_stream, _converter)
    ret2 = GConverterOutputStreamLeaf(ret, true)
    ret2
end
function get_converter(instance::GConverterOutputStream)
    ret = ccall(("g_converter_output_stream_get_converter", libgio), Ptr{GObject}, (Ptr{GObject},), instance)
    ret2 = begin
            leaftype = GLib.find_leaf_type(ret)
            convert(leaftype, ret, false)
        end
    ret2
end
function can_poll(instance::GConverterOutputStream)
    can_poll(GPollableOutputStream(instance))
end
function create_source(instance::GConverterOutputStream, _cancellable::Maybe(GCancellable))
    create_source(GPollableOutputStream(instance), _cancellable)
end
function is_writable(instance::GConverterOutputStream)
    is_writable(GPollableOutputStream(instance))
end
function write_nonblocking(instance::GConverterOutputStream, _buffer, _cancellable::Maybe(GCancellable))
    write_nonblocking(GPollableOutputStream(instance), _buffer, _cancellable)
end
function writev_nonblocking(instance::GConverterOutputStream, _vectors, _cancellable::Maybe(GCancellable))
    writev_nonblocking(GPollableOutputStream(instance), _vectors, _cancellable)
end
function Credentials_new()
    ret = ccall(("g_credentials_new", libgio), Ptr{GObject}, ())
    ret2 = GCredentialsLeaf(ret, true)
    ret2
end
function get_unix_pid(instance::GCredentials)
    err = err_buf()
    ret = ccall(("g_credentials_get_unix_pid", libgio), Int32, (Ptr{GObject}, Ptr{Ptr{GError}}), instance, err)
    check_err(err)
    ret
end
function get_unix_user(instance::GCredentials)
    err = err_buf()
    ret = ccall(("g_credentials_get_unix_user", libgio), UInt32, (Ptr{GObject}, Ptr{Ptr{GError}}), instance, err)
    check_err(err)
    ret
end
function is_same_user(instance::GCredentials, _other_credentials::GCredentials)
    err = err_buf()
    ret = ccall(("g_credentials_is_same_user", libgio), Cint, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _other_credentials, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function set_native(instance::GCredentials, _native_type, _native::Nothing)
    ret = ccall(("g_credentials_set_native", libgio), Nothing, (Ptr{GObject}, UInt32, Ptr{Nothing}), instance, _native_type, _native)
    nothing
end
function set_unix_user(instance::GCredentials, _uid::Integer)
    err = err_buf()
    ret = ccall(("g_credentials_set_unix_user", libgio), Cint, (Ptr{GObject}, UInt32, Ptr{Ptr{GError}}), instance, _uid, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function to_string(instance::GCredentials)
    ret = ccall(("g_credentials_to_string", libgio), Cstring, (Ptr{GObject},), instance)
    ret2 = string_or_nothing(ret, true)
    ret2
end
function get(_connection::GDBusConnection, _bus_name::Maybe(Union{AbstractString, Symbol}), _object_path::Union{AbstractString, Symbol})
    _bus_name_maybe = nothing_to_null(_bus_name)
    ret = ccall(("g_dbus_action_group_get", libgio), Ptr{GObject}, (Ptr{GObject}, Cstring, Cstring), _connection, _bus_name_maybe, _object_path)
    ret2 = convert(GDBusActionGroup, ret, true)
    ret2
end
function action_added(instance::GDBusActionGroup, _action_name::Union{AbstractString, Symbol})
    action_added(GActionGroup(instance), _action_name)
end
function action_enabled_changed(instance::GDBusActionGroup, _action_name::Union{AbstractString, Symbol}, _enabled::Bool)
    action_enabled_changed(GActionGroup(instance), _action_name, _enabled)
end
function action_removed(instance::GDBusActionGroup, _action_name::Union{AbstractString, Symbol})
    action_removed(GActionGroup(instance), _action_name)
end
function action_state_changed(instance::GDBusActionGroup, _action_name::Union{AbstractString, Symbol}, _state::GVariant)
    action_state_changed(GActionGroup(instance), _action_name, _state)
end
function activate_action(instance::GDBusActionGroup, _action_name::Union{AbstractString, Symbol}, _parameter::Maybe(GVariant))
    activate_action(GActionGroup(instance), _action_name, _parameter)
end
function change_action_state(instance::GDBusActionGroup, _action_name::Union{AbstractString, Symbol}, _value::GVariant)
    change_action_state(GActionGroup(instance), _action_name, _value)
end
function get_action_enabled(instance::GDBusActionGroup, _action_name::Union{AbstractString, Symbol})
    get_action_enabled(GActionGroup(instance), _action_name)
end
function get_action_parameter_type(instance::GDBusActionGroup, _action_name::Union{AbstractString, Symbol})
    get_action_parameter_type(GActionGroup(instance), _action_name)
end
function get_action_state(instance::GDBusActionGroup, _action_name::Union{AbstractString, Symbol})
    get_action_state(GActionGroup(instance), _action_name)
end
function get_action_state_hint(instance::GDBusActionGroup, _action_name::Union{AbstractString, Symbol})
    get_action_state_hint(GActionGroup(instance), _action_name)
end
function get_action_state_type(instance::GDBusActionGroup, _action_name::Union{AbstractString, Symbol})
    get_action_state_type(GActionGroup(instance), _action_name)
end
function has_action(instance::GDBusActionGroup, _action_name::Union{AbstractString, Symbol})
    has_action(GActionGroup(instance), _action_name)
end
function list_actions(instance::GDBusActionGroup)
    list_actions(GActionGroup(instance))
end
function query_action(instance::GDBusActionGroup, _action_name::Union{AbstractString, Symbol})
    query_action(GActionGroup(instance), _action_name)
end
function activate_action_full(instance::GDBusActionGroup, _action_name::Union{AbstractString, Symbol}, _parameter::Maybe(GVariant), _platform_data::GVariant)
    activate_action_full(GRemoteActionGroup(instance), _action_name, _parameter, _platform_data)
end
function change_action_state_full(instance::GDBusActionGroup, _action_name::Union{AbstractString, Symbol}, _value::GVariant, _platform_data::GVariant)
    change_action_state_full(GRemoteActionGroup(instance), _action_name, _value, _platform_data)
end
function DBusAuthObserver_new()
    ret = ccall(("g_dbus_auth_observer_new", libgio), Ptr{GObject}, ())
    ret2 = GDBusAuthObserverLeaf(ret, true)
    ret2
end
function allow_mechanism(instance::GDBusAuthObserver, _mechanism::Union{AbstractString, Symbol})
    ret = ccall(("g_dbus_auth_observer_allow_mechanism", libgio), Cint, (Ptr{GObject}, Cstring), instance, _mechanism)
    ret2 = convert(Bool, ret)
    ret2
end
function authorize_authenticated_peer(instance::GDBusAuthObserver, _stream::GIOStream, _credentials::Maybe(GCredentials))
    _credentials_maybe = nothing_to_null(_credentials)
    ret = ccall(("g_dbus_auth_observer_authorize_authenticated_peer", libgio), Cint, (Ptr{GObject}, Ptr{GObject}, Ptr{GObject}), instance, _stream, _credentials_maybe)
    ret2 = convert(Bool, ret)
    ret2
end
function DBusMessage_new()
    ret = ccall(("g_dbus_message_new", libgio), Ptr{GObject}, ())
    ret2 = GDBusMessageLeaf(ret, true)
    ret2
end
function DBusMessage_new_from_blob(_blob, _capabilities)
    _blob_arr = convert(Vector{UInt8}, _blob)
    _blob_len = length(_blob)
    err = err_buf()
    ret = ccall(("g_dbus_message_new_from_blob", libgio), Ptr{GObject}, (Ptr{UInt8}, UInt64, UInt32, Ptr{Ptr{GError}}), _blob_arr, _blob_len, _capabilities, err)
    check_err(err)
    ret2 = GDBusMessageLeaf(ret, true)
    ret2
end
function DBusMessage_new_method_call(_name::Maybe(Union{AbstractString, Symbol}), _path::Union{AbstractString, Symbol}, _interface_::Maybe(Union{AbstractString, Symbol}), _method::Union{AbstractString, Symbol})
    _name_maybe = nothing_to_null(_name)
    _interface__maybe = nothing_to_null(_interface_)
    ret = ccall(("g_dbus_message_new_method_call", libgio), Ptr{GObject}, (Cstring, Cstring, Cstring, Cstring), _name_maybe, _path, _interface__maybe, _method)
    ret2 = GDBusMessageLeaf(ret, true)
    ret2
end
function DBusMessage_new_signal(_path::Union{AbstractString, Symbol}, _interface_::Union{AbstractString, Symbol}, _signal::Union{AbstractString, Symbol})
    ret = ccall(("g_dbus_message_new_signal", libgio), Ptr{GObject}, (Cstring, Cstring, Cstring), _path, _interface_, _signal)
    ret2 = GDBusMessageLeaf(ret, true)
    ret2
end
function bytes_needed(_blob)
    _blob_arr = convert(Vector{UInt8}, _blob)
    _blob_len = length(_blob)
    err = err_buf()
    ret = ccall(("g_dbus_message_bytes_needed", libgio), Int64, (Ptr{UInt8}, UInt64, Ptr{Ptr{GError}}), _blob_arr, _blob_len, err)
    check_err(err)
    ret
end
function copy(instance::GDBusMessage)
    err = err_buf()
    ret = ccall(("g_dbus_message_copy", libgio), Ptr{GObject}, (Ptr{GObject}, Ptr{Ptr{GError}}), instance, err)
    check_err(err)
    ret2 = convert(GDBusMessage, ret, true)
    ret2
end
function get_arg0(instance::GDBusMessage)
    ret = ccall(("g_dbus_message_get_arg0", libgio), Cstring, (Ptr{GObject},), instance)
    ret2 = string_or_nothing(ret, false)
    ret2
end
function get_arg0_path(instance::GDBusMessage)
    ret = ccall(("g_dbus_message_get_arg0_path", libgio), Cstring, (Ptr{GObject},), instance)
    ret2 = string_or_nothing(ret, false)
    ret2
end
function get_body(instance::GDBusMessage)
    ret = ccall(("g_dbus_message_get_body", libgio), Ptr{GVariant}, (Ptr{GObject},), instance)
    ret2 = convert(GVariant, ret)
    ret2
end
function get_byte_order(instance::GDBusMessage)
    ret = ccall(("g_dbus_message_get_byte_order", libgio), UInt32, (Ptr{GObject},), instance)
    ret2 = DBusMessageByteOrder(ret)
    ret2
end
function get_destination(instance::GDBusMessage)
    ret = ccall(("g_dbus_message_get_destination", libgio), Cstring, (Ptr{GObject},), instance)
    ret2 = string_or_nothing(ret, false)
    ret2
end
function get_error_name(instance::GDBusMessage)
    ret = ccall(("g_dbus_message_get_error_name", libgio), Cstring, (Ptr{GObject},), instance)
    ret2 = string_or_nothing(ret, false)
    ret2
end
function get_flags(instance::GDBusMessage)
    ret = ccall(("g_dbus_message_get_flags", libgio), UInt32, (Ptr{GObject},), instance)
    ret2 = DBusMessageFlags(ret)
    ret2
end
function get_header(instance::GDBusMessage, _header_field)
    ret = ccall(("g_dbus_message_get_header", libgio), Ptr{GVariant}, (Ptr{GObject}, UInt32), instance, _header_field)
    ret2 = convert(GVariant, ret)
    ret2
end
function get_interface(instance::GDBusMessage)
    ret = ccall(("g_dbus_message_get_interface", libgio), Cstring, (Ptr{GObject},), instance)
    ret2 = string_or_nothing(ret, false)
    ret2
end
function get_locked(instance::GDBusMessage)
    ret = ccall(("g_dbus_message_get_locked", libgio), Cint, (Ptr{GObject},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function get_member(instance::GDBusMessage)
    ret = ccall(("g_dbus_message_get_member", libgio), Cstring, (Ptr{GObject},), instance)
    ret2 = string_or_nothing(ret, false)
    ret2
end
function get_message_type(instance::GDBusMessage)
    ret = ccall(("g_dbus_message_get_message_type", libgio), UInt32, (Ptr{GObject},), instance)
    ret2 = DBusMessageType(ret)
    ret2
end
function get_num_unix_fds(instance::GDBusMessage)
    ret = ccall(("g_dbus_message_get_num_unix_fds", libgio), UInt32, (Ptr{GObject},), instance)
    ret
end
function get_path(instance::GDBusMessage)
    ret = ccall(("g_dbus_message_get_path", libgio), Cstring, (Ptr{GObject},), instance)
    ret2 = string_or_nothing(ret, false)
    ret2
end
function get_reply_serial(instance::GDBusMessage)
    ret = ccall(("g_dbus_message_get_reply_serial", libgio), UInt32, (Ptr{GObject},), instance)
    ret
end
function get_sender(instance::GDBusMessage)
    ret = ccall(("g_dbus_message_get_sender", libgio), Cstring, (Ptr{GObject},), instance)
    ret2 = string_or_nothing(ret, false)
    ret2
end
function get_serial(instance::GDBusMessage)
    ret = ccall(("g_dbus_message_get_serial", libgio), UInt32, (Ptr{GObject},), instance)
    ret
end
function get_signature(instance::GDBusMessage)
    ret = ccall(("g_dbus_message_get_signature", libgio), Cstring, (Ptr{GObject},), instance)
    ret2 = string_or_nothing(ret, false)
    ret2
end
function lock(instance::GDBusMessage)
    ret = ccall(("g_dbus_message_lock", libgio), Nothing, (Ptr{GObject},), instance)
    nothing
end
function new_method_error_literal(instance::GDBusMessage, _error_name::Union{AbstractString, Symbol}, _error_message::Union{AbstractString, Symbol})
    ret = ccall(("g_dbus_message_new_method_error_literal", libgio), Ptr{GObject}, (Ptr{GObject}, Cstring, Cstring), instance, _error_name, _error_message)
    ret2 = convert(GDBusMessage, ret, true)
    ret2
end
function new_method_reply(instance::GDBusMessage)
    ret = ccall(("g_dbus_message_new_method_reply", libgio), Ptr{GObject}, (Ptr{GObject},), instance)
    ret2 = convert(GDBusMessage, ret, true)
    ret2
end
function print(instance::GDBusMessage, _indent::Integer)
    ret = ccall(("g_dbus_message_print", libgio), Cstring, (Ptr{GObject}, UInt32), instance, _indent)
    ret2 = string_or_nothing(ret, true)
    ret2
end
function set_body(instance::GDBusMessage, _body::GVariant)
    ret = ccall(("g_dbus_message_set_body", libgio), Nothing, (Ptr{GObject}, Ptr{GVariant}), instance, _body)
    nothing
end
function set_byte_order(instance::GDBusMessage, _byte_order)
    ret = ccall(("g_dbus_message_set_byte_order", libgio), Nothing, (Ptr{GObject}, UInt32), instance, _byte_order)
    nothing
end
function set_destination(instance::GDBusMessage, _value::Maybe(Union{AbstractString, Symbol}))
    _value_maybe = nothing_to_null(_value)
    ret = ccall(("g_dbus_message_set_destination", libgio), Nothing, (Ptr{GObject}, Cstring), instance, _value_maybe)
    nothing
end
function set_error_name(instance::GDBusMessage, _value::Union{AbstractString, Symbol})
    ret = ccall(("g_dbus_message_set_error_name", libgio), Nothing, (Ptr{GObject}, Cstring), instance, _value)
    nothing
end
function set_flags(instance::GDBusMessage, _flags)
    ret = ccall(("g_dbus_message_set_flags", libgio), Nothing, (Ptr{GObject}, UInt32), instance, _flags)
    nothing
end
function set_header(instance::GDBusMessage, _header_field, _value::Maybe(GVariant))
    _value_maybe = nothing_to_null(_value)
    ret = ccall(("g_dbus_message_set_header", libgio), Nothing, (Ptr{GObject}, UInt32, Ptr{GVariant}), instance, _header_field, _value_maybe)
    nothing
end
function set_interface(instance::GDBusMessage, _value::Maybe(Union{AbstractString, Symbol}))
    _value_maybe = nothing_to_null(_value)
    ret = ccall(("g_dbus_message_set_interface", libgio), Nothing, (Ptr{GObject}, Cstring), instance, _value_maybe)
    nothing
end
function set_member(instance::GDBusMessage, _value::Maybe(Union{AbstractString, Symbol}))
    _value_maybe = nothing_to_null(_value)
    ret = ccall(("g_dbus_message_set_member", libgio), Nothing, (Ptr{GObject}, Cstring), instance, _value_maybe)
    nothing
end
function set_message_type(instance::GDBusMessage, _type)
    ret = ccall(("g_dbus_message_set_message_type", libgio), Nothing, (Ptr{GObject}, UInt32), instance, _type)
    nothing
end
function set_num_unix_fds(instance::GDBusMessage, _value::Integer)
    ret = ccall(("g_dbus_message_set_num_unix_fds", libgio), Nothing, (Ptr{GObject}, UInt32), instance, _value)
    nothing
end
function set_path(instance::GDBusMessage, _value::Maybe(Union{AbstractString, Symbol}))
    _value_maybe = nothing_to_null(_value)
    ret = ccall(("g_dbus_message_set_path", libgio), Nothing, (Ptr{GObject}, Cstring), instance, _value_maybe)
    nothing
end
function set_reply_serial(instance::GDBusMessage, _value::Integer)
    ret = ccall(("g_dbus_message_set_reply_serial", libgio), Nothing, (Ptr{GObject}, UInt32), instance, _value)
    nothing
end
function set_sender(instance::GDBusMessage, _value::Maybe(Union{AbstractString, Symbol}))
    _value_maybe = nothing_to_null(_value)
    ret = ccall(("g_dbus_message_set_sender", libgio), Nothing, (Ptr{GObject}, Cstring), instance, _value_maybe)
    nothing
end
function set_serial(instance::GDBusMessage, _serial::Integer)
    ret = ccall(("g_dbus_message_set_serial", libgio), Nothing, (Ptr{GObject}, UInt32), instance, _serial)
    nothing
end
function set_signature(instance::GDBusMessage, _value::Maybe(Union{AbstractString, Symbol}))
    _value_maybe = nothing_to_null(_value)
    ret = ccall(("g_dbus_message_set_signature", libgio), Nothing, (Ptr{GObject}, Cstring), instance, _value_maybe)
    nothing
end
function to_blob(instance::GDBusMessage, _capabilities)
    m_out_size = Ref{UInt64}()
    err = err_buf()
    ret = ccall(("g_dbus_message_to_blob", libgio), Ptr{UInt8}, (Ptr{GObject}, Ptr{UInt64}, UInt32, Ptr{Ptr{GError}}), instance, m_out_size, _capabilities, err)
    check_err(err)
    ret2 = begin
            arrtemp = copy(unsafe_wrap(Vector{UInt8}, ret, m_out_size[]))
            GLib.g_free(ret)
            arrtemp
        end
    _out_size = m_out_size[]
    ret2
end
function to_gerror(instance::GDBusMessage)
    err = err_buf()
    ret = ccall(("g_dbus_message_to_gerror", libgio), Cint, (Ptr{GObject}, Ptr{Ptr{GError}}), instance, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function DBusObjectManagerClient_new_finish(_res::GAsyncResult)
    err = err_buf()
    ret = ccall(("g_dbus_object_manager_client_new_finish", libgio), Ptr{GObject}, (Ptr{GObject}, Ptr{Ptr{GError}}), _res, err)
    check_err(err)
    ret2 = GDBusObjectManagerClientLeaf(ret, true)
    ret2
end
function DBusObjectManagerClient_new_for_bus_finish(_res::GAsyncResult)
    err = err_buf()
    ret = ccall(("g_dbus_object_manager_client_new_for_bus_finish", libgio), Ptr{GObject}, (Ptr{GObject}, Ptr{Ptr{GError}}), _res, err)
    check_err(err)
    ret2 = GDBusObjectManagerClientLeaf(ret, true)
    ret2
end
function get_connection(instance::GDBusObjectManagerClient)
    ret = ccall(("g_dbus_object_manager_client_get_connection", libgio), Ptr{GObject}, (Ptr{GObject},), instance)
    ret2 = convert(GDBusConnection, ret, false)
    ret2
end
function get_flags(instance::GDBusObjectManagerClient)
    ret = ccall(("g_dbus_object_manager_client_get_flags", libgio), UInt32, (Ptr{GObject},), instance)
    ret2 = DBusObjectManagerClientFlags(ret)
    ret2
end
function get_name(instance::GDBusObjectManagerClient)
    ret = ccall(("g_dbus_object_manager_client_get_name", libgio), Cstring, (Ptr{GObject},), instance)
    ret2 = string_or_nothing(ret, false)
    ret2
end
function get_name_owner(instance::GDBusObjectManagerClient)
    ret = ccall(("g_dbus_object_manager_client_get_name_owner", libgio), Cstring, (Ptr{GObject},), instance)
    ret2 = string_or_nothing(ret, true)
    ret2
end
function init_async(instance::GDBusObjectManagerClient, _io_priority::Integer, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    init_async(GAsyncInitable(instance), _io_priority, _cancellable, _callback)
end
function init_finish(instance::GDBusObjectManagerClient, _res::GAsyncResult)
    init_finish(GAsyncInitable(instance), _res)
end
function get_interface(instance::GDBusObjectManagerClient, _object_path::Union{AbstractString, Symbol}, _interface_name::Union{AbstractString, Symbol})
    get_interface(GDBusObjectManager(instance), _object_path, _interface_name)
end
function get_object(instance::GDBusObjectManagerClient, _object_path::Union{AbstractString, Symbol})
    get_object(GDBusObjectManager(instance), _object_path)
end
function get_object_path(instance::GDBusObjectManagerClient)
    get_object_path(GDBusObjectManager(instance))
end
function get_objects(instance::GDBusObjectManagerClient)
    get_objects(GDBusObjectManager(instance))
end
function init(instance::GDBusObjectManagerClient, _cancellable::Maybe(GCancellable))
    init(GInitable(instance), _cancellable)
end
function DBusObjectProxy_new(_connection::GDBusConnection, _object_path::Union{AbstractString, Symbol})
    ret = ccall(("g_dbus_object_proxy_new", libgio), Ptr{GObject}, (Ptr{GObject}, Cstring), _connection, _object_path)
    ret2 = GDBusObjectProxyLeaf(ret, true)
    ret2
end
function get_connection(instance::GDBusObjectProxy)
    ret = ccall(("g_dbus_object_proxy_get_connection", libgio), Ptr{GObject}, (Ptr{GObject},), instance)
    ret2 = convert(GDBusConnection, ret, false)
    ret2
end
function get_interface(instance::GDBusObjectProxy, _interface_name::Union{AbstractString, Symbol})
    get_interface(GDBusObject(instance), _interface_name)
end
function get_interfaces(instance::GDBusObjectProxy)
    get_interfaces(GDBusObject(instance))
end
function get_object_path(instance::GDBusObjectProxy)
    get_object_path(GDBusObject(instance))
end
function get_client_address(instance::GDBusServer)
    ret = ccall(("g_dbus_server_get_client_address", libgio), Cstring, (Ptr{GObject},), instance)
    ret2 = string_or_nothing(ret, false)
    ret2
end
function get_flags(instance::GDBusServer)
    ret = ccall(("g_dbus_server_get_flags", libgio), UInt32, (Ptr{GObject},), instance)
    ret2 = DBusServerFlags(ret)
    ret2
end
function get_guid(instance::GDBusServer)
    ret = ccall(("g_dbus_server_get_guid", libgio), Cstring, (Ptr{GObject},), instance)
    ret2 = string_or_nothing(ret, false)
    ret2
end
function is_active(instance::GDBusServer)
    ret = ccall(("g_dbus_server_is_active", libgio), Cint, (Ptr{GObject},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function start(instance::GDBusServer)
    ret = ccall(("g_dbus_server_start", libgio), Nothing, (Ptr{GObject},), instance)
    nothing
end
function stop(instance::GDBusServer)
    ret = ccall(("g_dbus_server_stop", libgio), Nothing, (Ptr{GObject},), instance)
    nothing
end
function init(instance::GDBusServer, _cancellable::Maybe(GCancellable))
    init(GInitable(instance), _cancellable)
end
function DataInputStream_new(_base_stream::GInputStream)
    ret = ccall(("g_data_input_stream_new", libgio), Ptr{GObject}, (Ptr{GObject},), _base_stream)
    ret2 = GDataInputStreamLeaf(ret, true)
    ret2
end
function get_byte_order(instance::GDataInputStream)
    ret = ccall(("g_data_input_stream_get_byte_order", libgio), UInt32, (Ptr{GObject},), instance)
    ret2 = DataStreamByteOrder(ret)
    ret2
end
function get_newline_type(instance::GDataInputStream)
    ret = ccall(("g_data_input_stream_get_newline_type", libgio), UInt32, (Ptr{GObject},), instance)
    ret2 = DataStreamNewlineType(ret)
    ret2
end
function read_byte(instance::GDataInputStream, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_data_input_stream_read_byte", libgio), UInt8, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _cancellable_maybe, err)
    check_err(err)
    ret
end
function read_int16(instance::GDataInputStream, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_data_input_stream_read_int16", libgio), Int16, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _cancellable_maybe, err)
    check_err(err)
    ret
end
function read_int32(instance::GDataInputStream, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_data_input_stream_read_int32", libgio), Int32, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _cancellable_maybe, err)
    check_err(err)
    ret
end
function read_int64(instance::GDataInputStream, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_data_input_stream_read_int64", libgio), Int64, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _cancellable_maybe, err)
    check_err(err)
    ret
end
function read_line_async(instance::GDataInputStream, _io_priority::Integer, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    ret = ccall(("g_data_input_stream_read_line_async", libgio), Nothing, (Ptr{GObject}, Int32, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _io_priority, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function read_line_finish_utf8(instance::GDataInputStream, _result::GAsyncResult)
    m_length = Ref{UInt64}()
    err = err_buf()
    ret = ccall(("g_data_input_stream_read_line_finish_utf8", libgio), Cstring, (Ptr{GObject}, Ptr{GObject}, Ptr{UInt64}, Ptr{Ptr{GError}}), instance, _result, m_length, err)
    check_err(err)
    ret2 = string_or_nothing(ret, true)
    _length = m_length[]
    (ret2, _length)
end
function read_line_utf8(instance::GDataInputStream, _cancellable::Maybe(GCancellable))
    m_length = Ref{UInt64}()
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_data_input_stream_read_line_utf8", libgio), Cstring, (Ptr{GObject}, Ptr{UInt64}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, m_length, _cancellable_maybe, err)
    check_err(err)
    ret2 = string_or_nothing(ret, true)
    _length = m_length[]
    (ret2, _length)
end
function read_uint16(instance::GDataInputStream, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_data_input_stream_read_uint16", libgio), UInt16, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _cancellable_maybe, err)
    check_err(err)
    ret
end
function read_uint32(instance::GDataInputStream, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_data_input_stream_read_uint32", libgio), UInt32, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _cancellable_maybe, err)
    check_err(err)
    ret
end
function read_uint64(instance::GDataInputStream, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_data_input_stream_read_uint64", libgio), UInt64, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _cancellable_maybe, err)
    check_err(err)
    ret
end
function read_upto(instance::GDataInputStream, _stop_chars::Union{AbstractString, Symbol}, _stop_chars_len::Integer, _cancellable::Maybe(GCancellable))
    m_length = Ref{UInt64}()
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_data_input_stream_read_upto", libgio), Cstring, (Ptr{GObject}, Cstring, Int64, Ptr{UInt64}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _stop_chars, _stop_chars_len, m_length, _cancellable_maybe, err)
    check_err(err)
    ret2 = string_or_nothing(ret, true)
    _length = m_length[]
    (ret2, _length)
end
function read_upto_async(instance::GDataInputStream, _stop_chars::Union{AbstractString, Symbol}, _stop_chars_len::Integer, _io_priority::Integer, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    ret = ccall(("g_data_input_stream_read_upto_async", libgio), Nothing, (Ptr{GObject}, Cstring, Int64, Int32, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _stop_chars, _stop_chars_len, _io_priority, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function read_upto_finish(instance::GDataInputStream, _result::GAsyncResult)
    m_length = Ref{UInt64}()
    err = err_buf()
    ret = ccall(("g_data_input_stream_read_upto_finish", libgio), Cstring, (Ptr{GObject}, Ptr{GObject}, Ptr{UInt64}, Ptr{Ptr{GError}}), instance, _result, m_length, err)
    check_err(err)
    ret2 = string_or_nothing(ret, true)
    _length = m_length[]
    (ret2, _length)
end
function set_byte_order(instance::GDataInputStream, _order)
    ret = ccall(("g_data_input_stream_set_byte_order", libgio), Nothing, (Ptr{GObject}, UInt32), instance, _order)
    nothing
end
function set_newline_type(instance::GDataInputStream, _type)
    ret = ccall(("g_data_input_stream_set_newline_type", libgio), Nothing, (Ptr{GObject}, UInt32), instance, _type)
    nothing
end
function can_seek(instance::GDataInputStream)
    can_seek(GSeekable(instance))
end
function can_truncate(instance::GDataInputStream)
    can_truncate(GSeekable(instance))
end
function seek(instance::GDataInputStream, _offset::Integer, _type, _cancellable::Maybe(GCancellable))
    seek(GSeekable(instance), _offset, _type, _cancellable)
end
function tell(instance::GDataInputStream)
    tell(GSeekable(instance))
end
function truncate(instance::GDataInputStream, _offset::Integer, _cancellable::Maybe(GCancellable))
    truncate(GSeekable(instance), _offset, _cancellable)
end
function DataOutputStream_new(_base_stream::GOutputStream)
    ret = ccall(("g_data_output_stream_new", libgio), Ptr{GObject}, (Ptr{GObject},), _base_stream)
    ret2 = GDataOutputStreamLeaf(ret, true)
    ret2
end
function get_byte_order(instance::GDataOutputStream)
    ret = ccall(("g_data_output_stream_get_byte_order", libgio), UInt32, (Ptr{GObject},), instance)
    ret2 = DataStreamByteOrder(ret)
    ret2
end
function put_byte(instance::GDataOutputStream, _data::Integer, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_data_output_stream_put_byte", libgio), Cint, (Ptr{GObject}, UInt8, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _data, _cancellable_maybe, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function put_int16(instance::GDataOutputStream, _data::Integer, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_data_output_stream_put_int16", libgio), Cint, (Ptr{GObject}, Int16, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _data, _cancellable_maybe, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function put_int32(instance::GDataOutputStream, _data::Integer, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_data_output_stream_put_int32", libgio), Cint, (Ptr{GObject}, Int32, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _data, _cancellable_maybe, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function put_int64(instance::GDataOutputStream, _data::Integer, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_data_output_stream_put_int64", libgio), Cint, (Ptr{GObject}, Int64, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _data, _cancellable_maybe, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function put_string(instance::GDataOutputStream, _str::Union{AbstractString, Symbol}, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_data_output_stream_put_string", libgio), Cint, (Ptr{GObject}, Cstring, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _str, _cancellable_maybe, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function put_uint16(instance::GDataOutputStream, _data::Integer, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_data_output_stream_put_uint16", libgio), Cint, (Ptr{GObject}, UInt16, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _data, _cancellable_maybe, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function put_uint32(instance::GDataOutputStream, _data::Integer, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_data_output_stream_put_uint32", libgio), Cint, (Ptr{GObject}, UInt32, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _data, _cancellable_maybe, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function put_uint64(instance::GDataOutputStream, _data::Integer, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_data_output_stream_put_uint64", libgio), Cint, (Ptr{GObject}, UInt64, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _data, _cancellable_maybe, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function set_byte_order(instance::GDataOutputStream, _order)
    ret = ccall(("g_data_output_stream_set_byte_order", libgio), Nothing, (Ptr{GObject}, UInt32), instance, _order)
    nothing
end
function can_seek(instance::GDataOutputStream)
    can_seek(GSeekable(instance))
end
function can_truncate(instance::GDataOutputStream)
    can_truncate(GSeekable(instance))
end
function seek(instance::GDataOutputStream, _offset::Integer, _type, _cancellable::Maybe(GCancellable))
    seek(GSeekable(instance), _offset, _type, _cancellable)
end
function tell(instance::GDataOutputStream)
    tell(GSeekable(instance))
end
function truncate(instance::GDataOutputStream, _offset::Integer, _cancellable::Maybe(GCancellable))
    truncate(GSeekable(instance), _offset, _cancellable)
end
function DesktopAppInfo_new(_desktop_id::Union{AbstractString, Symbol})
    ret = ccall(("g_desktop_app_info_new", libgio), Ptr{GObject}, (Cstring,), _desktop_id)
    ret2 = convert_if_not_null(GDesktopAppInfo, ret, true)
    ret2
end
function DesktopAppInfo_new_from_filename(_filename::Union{AbstractString, Symbol})
    ret = ccall(("g_desktop_app_info_new_from_filename", libgio), Ptr{GObject}, (Cstring,), _filename)
    ret2 = convert_if_not_null(GDesktopAppInfo, ret, true)
    ret2
end
function DesktopAppInfo_new_from_keyfile(_key_file::GKeyFile)
    ret = ccall(("g_desktop_app_info_new_from_keyfile", libgio), Ptr{GObject}, (Ptr{GKeyFile},), _key_file)
    ret2 = convert_if_not_null(GDesktopAppInfo, ret, true)
    ret2
end
function get_implementations(_interface::Union{AbstractString, Symbol})
    ret = ccall(("g_desktop_app_info_get_implementations", libgio), Ptr{GLib._GList{Ptr{GObject}}}, (Cstring,), _interface)
    ret2 = GLib.GList(ret, true)
    ret2
end
function get_action_name(instance::GDesktopAppInfo, _action_name::Union{AbstractString, Symbol})
    ret = ccall(("g_desktop_app_info_get_action_name", libgio), Cstring, (Ptr{GObject}, Cstring), instance, _action_name)
    ret2 = string_or_nothing(ret, true)
    ret2
end
function get_boolean(instance::GDesktopAppInfo, _key::Union{AbstractString, Symbol})
    ret = ccall(("g_desktop_app_info_get_boolean", libgio), Cint, (Ptr{GObject}, Cstring), instance, _key)
    ret2 = convert(Bool, ret)
    ret2
end
function get_categories(instance::GDesktopAppInfo)
    ret = ccall(("g_desktop_app_info_get_categories", libgio), Cstring, (Ptr{GObject},), instance)
    ret2 = string_or_nothing(ret, false)
    ret2
end
function get_filename(instance::GDesktopAppInfo)
    ret = ccall(("g_desktop_app_info_get_filename", libgio), Cstring, (Ptr{GObject},), instance)
    ret2 = string_or_nothing(ret, false)
    ret2
end
function get_generic_name(instance::GDesktopAppInfo)
    ret = ccall(("g_desktop_app_info_get_generic_name", libgio), Cstring, (Ptr{GObject},), instance)
    ret2 = string_or_nothing(ret, false)
    ret2
end
function get_is_hidden(instance::GDesktopAppInfo)
    ret = ccall(("g_desktop_app_info_get_is_hidden", libgio), Cint, (Ptr{GObject},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function get_keywords(instance::GDesktopAppInfo)
    ret = ccall(("g_desktop_app_info_get_keywords", libgio), Ptr{Cstring}, (Ptr{GObject},), instance)
    ret2 = begin
            _len = length_zt(ret)
            arrtemp = bytestring.(unsafe_wrap(Vector{Cstring}, ret, _len))
            arrtemp
        end
    ret2
end
function get_locale_string(instance::GDesktopAppInfo, _key::Union{AbstractString, Symbol})
    ret = ccall(("g_desktop_app_info_get_locale_string", libgio), Cstring, (Ptr{GObject}, Cstring), instance, _key)
    ret2 = string_or_nothing(ret, true)
    ret2
end
function get_nodisplay(instance::GDesktopAppInfo)
    ret = ccall(("g_desktop_app_info_get_nodisplay", libgio), Cint, (Ptr{GObject},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function get_show_in(instance::GDesktopAppInfo, _desktop_env::Maybe(Union{AbstractString, Symbol}))
    _desktop_env_maybe = nothing_to_null(_desktop_env)
    ret = ccall(("g_desktop_app_info_get_show_in", libgio), Cint, (Ptr{GObject}, Cstring), instance, _desktop_env_maybe)
    ret2 = convert(Bool, ret)
    ret2
end
function get_startup_wm_class(instance::GDesktopAppInfo)
    ret = ccall(("g_desktop_app_info_get_startup_wm_class", libgio), Cstring, (Ptr{GObject},), instance)
    ret2 = string_or_nothing(ret, false)
    ret2
end
function get_string(instance::GDesktopAppInfo, _key::Union{AbstractString, Symbol})
    ret = ccall(("g_desktop_app_info_get_string", libgio), Cstring, (Ptr{GObject}, Cstring), instance, _key)
    ret2 = string_or_nothing(ret, true)
    ret2
end
function get_string_list(instance::GDesktopAppInfo, _key::Union{AbstractString, Symbol})
    m_length = Ref{UInt64}()
    ret = ccall(("g_desktop_app_info_get_string_list", libgio), Ptr{Cstring}, (Ptr{GObject}, Cstring, Ptr{UInt64}), instance, _key, 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 has_key(instance::GDesktopAppInfo, _key::Union{AbstractString, Symbol})
    ret = ccall(("g_desktop_app_info_has_key", libgio), Cint, (Ptr{GObject}, Cstring), instance, _key)
    ret2 = convert(Bool, ret)
    ret2
end
function launch_action(instance::GDesktopAppInfo, _action_name::Union{AbstractString, Symbol}, _launch_context::Maybe(GAppLaunchContext))
    _launch_context_maybe = nothing_to_null(_launch_context)
    ret = ccall(("g_desktop_app_info_launch_action", libgio), Nothing, (Ptr{GObject}, Cstring, Ptr{GObject}), instance, _action_name, _launch_context_maybe)
    nothing
end
function launch_uris_as_manager(instance::GDesktopAppInfo, _uris::GLib.LList{GLib._GList{String}}, _launch_context::Maybe(GAppLaunchContext), _spawn_flags, _user_setup::Maybe(Function), _pid_callback::Maybe(Function))
    _launch_context_maybe = nothing_to_null(_launch_context)
    if _user_setup === nothing
        _user_setup_cfunc = C_NULL
        _user_setup_closure = C_NULL
    else
        _user_setup_cfunc = @cfunction(GSpawnChildSetupFunc, Nothing, (Ref{Function},))
        _user_setup_closure = GLib.gc_ref(_user_setup)
    end
    if _pid_callback === nothing
        _pid_callback_cfunc = C_NULL
        _pid_callback_closure = C_NULL
    else
        _pid_callback_cfunc = @cfunction(GDesktopAppLaunchCallback, Nothing, (Ptr{GObject}, Int32, Ref{Function}))
        begin
            ref = Ref{Any}(_pid_callback)
            _pid_callback_closure = unsafe_load(convert(Ptr{Ptr{Nothing}}, Base.unsafe_convert(Ptr{Any}, ref)))
        end
    end
    err = err_buf()
    ret = ccall(("g_desktop_app_info_launch_uris_as_manager", libgio), Cint, (Ptr{GObject}, Ptr{GLib._GList{String}}, Ptr{GObject}, UInt32, Ptr{Cvoid}, Ptr{Nothing}, Ptr{Cvoid}, Ptr{Nothing}, Ptr{Ptr{GError}}), instance, _uris, _launch_context_maybe, _spawn_flags, _user_setup_cfunc, _user_setup_closure, _pid_callback_cfunc, _pid_callback_closure, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function launch_uris_as_manager_with_fds(instance::GDesktopAppInfo, _uris::GLib.LList{GLib._GList{String}}, _launch_context::Maybe(GAppLaunchContext), _spawn_flags, _user_setup::Maybe(Function), _pid_callback::Maybe(Function), _stdin_fd::Integer, _stdout_fd::Integer, _stderr_fd::Integer)
    _launch_context_maybe = nothing_to_null(_launch_context)
    if _user_setup === nothing
        _user_setup_cfunc = C_NULL
        _user_setup_closure = C_NULL
    else
        _user_setup_cfunc = @cfunction(GSpawnChildSetupFunc, Nothing, (Ref{Function},))
        _user_setup_closure = GLib.gc_ref(_user_setup)
    end
    if _pid_callback === nothing
        _pid_callback_cfunc = C_NULL
        _pid_callback_closure = C_NULL
    else
        _pid_callback_cfunc = @cfunction(GDesktopAppLaunchCallback, Nothing, (Ptr{GObject}, Int32, Ref{Function}))
        begin
            ref = Ref{Any}(_pid_callback)
            _pid_callback_closure = unsafe_load(convert(Ptr{Ptr{Nothing}}, Base.unsafe_convert(Ptr{Any}, ref)))
        end
    end
    err = err_buf()
    ret = ccall(("g_desktop_app_info_launch_uris_as_manager_with_fds", libgio), Cint, (Ptr{GObject}, Ptr{GLib._GList{String}}, Ptr{GObject}, UInt32, Ptr{Cvoid}, Ptr{Nothing}, Ptr{Cvoid}, Ptr{Nothing}, Int32, Int32, Int32, Ptr{Ptr{GError}}), instance, _uris, _launch_context_maybe, _spawn_flags, _user_setup_cfunc, _user_setup_closure, _pid_callback_cfunc, _pid_callback_closure, _stdin_fd, _stdout_fd, _stderr_fd, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function list_actions(instance::GDesktopAppInfo)
    ret = ccall(("g_desktop_app_info_list_actions", libgio), Ptr{Cstring}, (Ptr{GObject},), instance)
    ret2 = begin
            _len = length_zt(ret)
            arrtemp = bytestring.(unsafe_wrap(Vector{Cstring}, ret, _len))
            arrtemp
        end
    ret2
end
function add_supports_type(instance::GDesktopAppInfo, _content_type::Union{AbstractString, Symbol})
    add_supports_type(GAppInfo(instance), _content_type)
end
function can_delete(instance::GDesktopAppInfo)
    can_delete(GAppInfo(instance))
end
function can_remove_supports_type(instance::GDesktopAppInfo)
    can_remove_supports_type(GAppInfo(instance))
end
function delete(instance::GDesktopAppInfo)
    delete(GAppInfo(instance))
end
function dup(instance::GDesktopAppInfo)
    dup(GAppInfo(instance))
end
function equal(instance::GDesktopAppInfo, _appinfo2::GAppInfo)
    equal(GAppInfo(instance), _appinfo2)
end
function get_commandline(instance::GDesktopAppInfo)
    get_commandline(GAppInfo(instance))
end
function get_description(instance::GDesktopAppInfo)
    get_description(GAppInfo(instance))
end
function get_display_name(instance::GDesktopAppInfo)
    get_display_name(GAppInfo(instance))
end
function get_executable(instance::GDesktopAppInfo)
    get_executable(GAppInfo(instance))
end
function get_icon(instance::GDesktopAppInfo)
    get_icon(GAppInfo(instance))
end
function get_id(instance::GDesktopAppInfo)
    get_id(GAppInfo(instance))
end
function get_name(instance::GDesktopAppInfo)
    get_name(GAppInfo(instance))
end
function get_supported_types(instance::GDesktopAppInfo)
    get_supported_types(GAppInfo(instance))
end
function launch(instance::GDesktopAppInfo, _files::Maybe(GLib.LList{GLib._GList{Ptr{GObject}}}), _context::Maybe(GAppLaunchContext))
    launch(GAppInfo(instance), _files, _context)
end
function launch_uris(instance::GDesktopAppInfo, _uris::Maybe(GLib.LList{GLib._GList{String}}), _context::Maybe(GAppLaunchContext))
    launch_uris(GAppInfo(instance), _uris, _context)
end
function launch_uris_async(instance::GDesktopAppInfo, _uris::Maybe(GLib.LList{GLib._GList{String}}), _context::Maybe(GAppLaunchContext), _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    launch_uris_async(GAppInfo(instance), _uris, _context, _cancellable, _callback)
end
function launch_uris_finish(instance::GDesktopAppInfo, _result::GAsyncResult)
    launch_uris_finish(GAppInfo(instance), _result)
end
function remove_supports_type(instance::GDesktopAppInfo, _content_type::Union{AbstractString, Symbol})
    remove_supports_type(GAppInfo(instance), _content_type)
end
function set_as_default_for_extension(instance::GDesktopAppInfo, _extension::Union{AbstractString, Symbol})
    set_as_default_for_extension(GAppInfo(instance), _extension)
end
function set_as_default_for_type(instance::GDesktopAppInfo, _content_type::Union{AbstractString, Symbol})
    set_as_default_for_type(GAppInfo(instance), _content_type)
end
function set_as_last_used_for_type(instance::GDesktopAppInfo, _content_type::Union{AbstractString, Symbol})
    set_as_last_used_for_type(GAppInfo(instance), _content_type)
end
function should_show(instance::GDesktopAppInfo)
    should_show(GAppInfo(instance))
end
function supports_files(instance::GDesktopAppInfo)
    supports_files(GAppInfo(instance))
end
function supports_uris(instance::GDesktopAppInfo)
    supports_uris(GAppInfo(instance))
end
function Emblem_new(_icon::GIcon)
    ret = ccall(("g_emblem_new", libgio), Ptr{GObject}, (Ptr{GObject},), _icon)
    ret2 = GEmblemLeaf(ret, true)
    ret2
end
function Emblem_new_with_origin(_icon::GIcon, _origin)
    ret = ccall(("g_emblem_new_with_origin", libgio), Ptr{GObject}, (Ptr{GObject}, UInt32), _icon, _origin)
    ret2 = GEmblemLeaf(ret, true)
    ret2
end
function get_icon(instance::GEmblem)
    ret = ccall(("g_emblem_get_icon", libgio), Ptr{GObject}, (Ptr{GObject},), instance)
    ret2 = begin
            leaftype = GLib.find_leaf_type(ret)
            convert(leaftype, ret, false)
        end
    ret2
end
function get_origin(instance::GEmblem)
    ret = ccall(("g_emblem_get_origin", libgio), UInt32, (Ptr{GObject},), instance)
    ret2 = EmblemOrigin(ret)
    ret2
end
function equal(instance::GEmblem, _icon2::Maybe(GIcon))
    equal(GIcon(instance), _icon2)
end
function hash(instance::GEmblem)
    hash(GIcon(instance))
end
function serialize(instance::GEmblem)
    serialize(GIcon(instance))
end
function to_string(instance::GEmblem)
    to_string(GIcon(instance))
end
function EmblemedIcon_new(_icon::GIcon, _emblem::Maybe(GEmblem))
    _emblem_maybe = nothing_to_null(_emblem)
    ret = ccall(("g_emblemed_icon_new", libgio), Ptr{GObject}, (Ptr{GObject}, Ptr{GObject}), _icon, _emblem_maybe)
    ret2 = GEmblemedIconLeaf(ret, true)
    ret2
end
function add_emblem(instance::GEmblemedIcon, _emblem::GEmblem)
    ret = ccall(("g_emblemed_icon_add_emblem", libgio), Nothing, (Ptr{GObject}, Ptr{GObject}), instance, _emblem)
    nothing
end
function clear_emblems(instance::GEmblemedIcon)
    ret = ccall(("g_emblemed_icon_clear_emblems", libgio), Nothing, (Ptr{GObject},), instance)
    nothing
end
function get_emblems(instance::GEmblemedIcon)
    ret = ccall(("g_emblemed_icon_get_emblems", libgio), Ptr{GLib._GList{Ptr{GObject}}}, (Ptr{GObject},), instance)
    ret2 = GLib.GList(ret, false, false)
    ret2
end
function get_icon(instance::GEmblemedIcon)
    ret = ccall(("g_emblemed_icon_get_icon", libgio), Ptr{GObject}, (Ptr{GObject},), instance)
    ret2 = begin
            leaftype = GLib.find_leaf_type(ret)
            convert(leaftype, ret, false)
        end
    ret2
end
function equal(instance::GEmblemedIcon, _icon2::Maybe(GIcon))
    equal(GIcon(instance), _icon2)
end
function hash(instance::GEmblemedIcon)
    hash(GIcon(instance))
end
function serialize(instance::GEmblemedIcon)
    serialize(GIcon(instance))
end
function to_string(instance::GEmblemedIcon)
    to_string(GIcon(instance))
end
function close(instance::GFileEnumerator, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_file_enumerator_close", libgio), Cint, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _cancellable_maybe, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function close_async(instance::GFileEnumerator, _io_priority::Integer, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    ret = ccall(("g_file_enumerator_close_async", libgio), Nothing, (Ptr{GObject}, Int32, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _io_priority, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function close_finish(instance::GFileEnumerator, _result::GAsyncResult)
    err = err_buf()
    ret = ccall(("g_file_enumerator_close_finish", libgio), Cint, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _result, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function get_child(instance::GFileEnumerator, _info::GFileInfo)
    ret = ccall(("g_file_enumerator_get_child", libgio), Ptr{GObject}, (Ptr{GObject}, Ptr{GObject}), instance, _info)
    ret2 = begin
            leaftype = GLib.find_leaf_type(ret)
            convert(leaftype, ret, true)
        end
    ret2
end
function get_container(instance::GFileEnumerator)
    ret = ccall(("g_file_enumerator_get_container", libgio), Ptr{GObject}, (Ptr{GObject},), instance)
    ret2 = begin
            leaftype = GLib.find_leaf_type(ret)
            convert(leaftype, ret, false)
        end
    ret2
end
function has_pending(instance::GFileEnumerator)
    ret = ccall(("g_file_enumerator_has_pending", libgio), Cint, (Ptr{GObject},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function is_closed(instance::GFileEnumerator)
    ret = ccall(("g_file_enumerator_is_closed", libgio), Cint, (Ptr{GObject},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function iterate(instance::GFileEnumerator, _cancellable::Maybe(GCancellable))
    m_out_info = Ref{Ptr{GObject}}()
    m_out_child = Ref{Ptr{GObject}}()
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_file_enumerator_iterate", libgio), Cint, (Ptr{GObject}, Ptr{Ptr{GObject}}, Ptr{Ptr{GObject}}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, m_out_info, m_out_child, _cancellable_maybe, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    _out_info = m_out_info[]
    _out_info = convert(GFileInfo, _out_info, false)
    _out_child = m_out_child[]
    _out_child = begin
            leaftype = GLib.find_leaf_type(_out_child)
            convert(leaftype, _out_child, false)
        end
    (ret2, _out_info, _out_child)
end
function next_file(instance::GFileEnumerator, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_file_enumerator_next_file", libgio), Ptr{GObject}, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _cancellable_maybe, err)
    check_err(err)
    ret2 = convert_if_not_null(GFileInfo, ret, true)
    ret2
end
function next_files_async(instance::GFileEnumerator, _num_files::Integer, _io_priority::Integer, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    ret = ccall(("g_file_enumerator_next_files_async", libgio), Nothing, (Ptr{GObject}, Int32, Int32, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _num_files, _io_priority, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function next_files_finish(instance::GFileEnumerator, _result::GAsyncResult)
    err = err_buf()
    ret = ccall(("g_file_enumerator_next_files_finish", libgio), Ptr{GLib._GList{Ptr{GObject}}}, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _result, err)
    check_err(err)
    ret2 = GLib.GList(ret, true)
    ret2
end
function set_pending(instance::GFileEnumerator, _pending::Bool)
    ret = ccall(("g_file_enumerator_set_pending", libgio), Nothing, (Ptr{GObject}, Cint), instance, _pending)
    nothing
end
function get_etag(instance::GFileIOStream)
    ret = ccall(("g_file_io_stream_get_etag", libgio), Cstring, (Ptr{GObject},), instance)
    ret2 = string_or_nothing(ret, true)
    ret2
end
function query_info(instance::GFileIOStream, _attributes::Union{AbstractString, Symbol}, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_file_io_stream_query_info", libgio), Ptr{GObject}, (Ptr{GObject}, Cstring, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _attributes, _cancellable_maybe, err)
    check_err(err)
    ret2 = convert(GFileInfo, ret, true)
    ret2
end
function query_info_async(instance::GFileIOStream, _attributes::Union{AbstractString, Symbol}, _io_priority::Integer, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    ret = ccall(("g_file_io_stream_query_info_async", libgio), Nothing, (Ptr{GObject}, Cstring, Int32, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _attributes, _io_priority, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function query_info_finish(instance::GFileIOStream, _result::GAsyncResult)
    err = err_buf()
    ret = ccall(("g_file_io_stream_query_info_finish", libgio), Ptr{GObject}, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _result, err)
    check_err(err)
    ret2 = convert(GFileInfo, ret, true)
    ret2
end
function can_seek(instance::GFileIOStream)
    can_seek(GSeekable(instance))
end
function can_truncate(instance::GFileIOStream)
    can_truncate(GSeekable(instance))
end
function seek(instance::GFileIOStream, _offset::Integer, _type, _cancellable::Maybe(GCancellable))
    seek(GSeekable(instance), _offset, _type, _cancellable)
end
function tell(instance::GFileIOStream)
    tell(GSeekable(instance))
end
function truncate(instance::GFileIOStream, _offset::Integer, _cancellable::Maybe(GCancellable))
    truncate(GSeekable(instance), _offset, _cancellable)
end
function FileIcon_new(_file::GFile)
    ret = ccall(("g_file_icon_new", libgio), Ptr{GObject}, (Ptr{GObject},), _file)
    ret2 = GFileIconLeaf(ret, true)
    ret2
end
function get_file(instance::GFileIcon)
    ret = ccall(("g_file_icon_get_file", libgio), Ptr{GObject}, (Ptr{GObject},), instance)
    ret2 = begin
            leaftype = GLib.find_leaf_type(ret)
            convert(leaftype, ret, false)
        end
    ret2
end
function equal(instance::GFileIcon, _icon2::Maybe(GIcon))
    equal(GIcon(instance), _icon2)
end
function hash(instance::GFileIcon)
    hash(GIcon(instance))
end
function serialize(instance::GFileIcon)
    serialize(GIcon(instance))
end
function to_string(instance::GFileIcon)
    to_string(GIcon(instance))
end
function load(instance::GFileIcon, _size::Integer, _cancellable::Maybe(GCancellable))
    load(GLoadableIcon(instance), _size, _cancellable)
end
function load_async(instance::GFileIcon, _size::Integer, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    load_async(GLoadableIcon(instance), _size, _cancellable, _callback)
end
function load_finish(instance::GFileIcon, _res::GAsyncResult)
    load_finish(GLoadableIcon(instance), _res)
end
function FileInfo_new()
    ret = ccall(("g_file_info_new", libgio), Ptr{GObject}, ())
    ret2 = GFileInfoLeaf(ret, true)
    ret2
end
function clear_status(instance::GFileInfo)
    ret = ccall(("g_file_info_clear_status", libgio), Nothing, (Ptr{GObject},), instance)
    nothing
end
function copy_into(instance::GFileInfo, _dest_info::GFileInfo)
    ret = ccall(("g_file_info_copy_into", libgio), Nothing, (Ptr{GObject}, Ptr{GObject}), instance, _dest_info)
    nothing
end
function dup(instance::GFileInfo)
    ret = ccall(("g_file_info_dup", libgio), Ptr{GObject}, (Ptr{GObject},), instance)
    ret2 = convert(GFileInfo, ret, true)
    ret2
end
function get_access_date_time(instance::GFileInfo)
    ret = ccall(("g_file_info_get_access_date_time", libgio), Ptr{GDateTime}, (Ptr{GObject},), instance)
    ret2 = convert_if_not_null(GDateTime, ret, true)
    ret2
end
function get_attribute_as_string(instance::GFileInfo, _attribute::Union{AbstractString, Symbol})
    ret = ccall(("g_file_info_get_attribute_as_string", libgio), Cstring, (Ptr{GObject}, Cstring), instance, _attribute)
    ret2 = string_or_nothing(ret, true)
    ret2
end
function get_attribute_boolean(instance::GFileInfo, _attribute::Union{AbstractString, Symbol})
    ret = ccall(("g_file_info_get_attribute_boolean", libgio), Cint, (Ptr{GObject}, Cstring), instance, _attribute)
    ret2 = convert(Bool, ret)
    ret2
end
function get_attribute_byte_string(instance::GFileInfo, _attribute::Union{AbstractString, Symbol})
    ret = ccall(("g_file_info_get_attribute_byte_string", libgio), Cstring, (Ptr{GObject}, Cstring), instance, _attribute)
    ret2 = string_or_nothing(ret, false)
    ret2
end
function get_attribute_data(instance::GFileInfo, _attribute::Union{AbstractString, Symbol})
    m_type = Ref{UInt32}()
    m_value_pp = Ref{Ptr{Nothing}}()
    m_status = Ref{UInt32}()
    ret = ccall(("g_file_info_get_attribute_data", libgio), Cint, (Ptr{GObject}, Cstring, Ptr{UInt32}, Ptr{Ptr{Nothing}}, Ptr{UInt32}), instance, _attribute, m_type, m_value_pp, m_status)
    ret2 = convert(Bool, ret)
    _type = m_type[]
    _type = FileAttributeType(_type)
    _value_pp = m_value_pp[]
    _value_pp = convert(Nothing, _value_pp)
    _status = m_status[]
    _status = FileAttributeStatus(_status)
    (ret2, _type, _value_pp, _status)
end
function get_attribute_int32(instance::GFileInfo, _attribute::Union{AbstractString, Symbol})
    ret = ccall(("g_file_info_get_attribute_int32", libgio), Int32, (Ptr{GObject}, Cstring), instance, _attribute)
    ret
end
function get_attribute_int64(instance::GFileInfo, _attribute::Union{AbstractString, Symbol})
    ret = ccall(("g_file_info_get_attribute_int64", libgio), Int64, (Ptr{GObject}, Cstring), instance, _attribute)
    ret
end
function get_attribute_object(instance::GFileInfo, _attribute::Union{AbstractString, Symbol})
    ret = ccall(("g_file_info_get_attribute_object", libgio), Ptr{GObject}, (Ptr{GObject}, Cstring), instance, _attribute)
    ret2 = convert_if_not_null(GObject, ret, false)
    ret2
end
function get_attribute_status(instance::GFileInfo, _attribute::Union{AbstractString, Symbol})
    ret = ccall(("g_file_info_get_attribute_status", libgio), UInt32, (Ptr{GObject}, Cstring), instance, _attribute)
    ret2 = FileAttributeStatus(ret)
    ret2
end
function get_attribute_string(instance::GFileInfo, _attribute::Union{AbstractString, Symbol})
    ret = ccall(("g_file_info_get_attribute_string", libgio), Cstring, (Ptr{GObject}, Cstring), instance, _attribute)
    ret2 = string_or_nothing(ret, false)
    ret2
end
function get_attribute_stringv(instance::GFileInfo, _attribute::Union{AbstractString, Symbol})
    ret = ccall(("g_file_info_get_attribute_stringv", libgio), Ptr{Cstring}, (Ptr{GObject}, Cstring), instance, _attribute)
    ret2 = begin
            _len = length_zt(ret)
            arrtemp = bytestring.(unsafe_wrap(Vector{Cstring}, ret, _len))
            arrtemp
        end
    ret2
end
function get_attribute_type(instance::GFileInfo, _attribute::Union{AbstractString, Symbol})
    ret = ccall(("g_file_info_get_attribute_type", libgio), UInt32, (Ptr{GObject}, Cstring), instance, _attribute)
    ret2 = FileAttributeType(ret)
    ret2
end
function get_attribute_uint32(instance::GFileInfo, _attribute::Union{AbstractString, Symbol})
    ret = ccall(("g_file_info_get_attribute_uint32", libgio), UInt32, (Ptr{GObject}, Cstring), instance, _attribute)
    ret
end
function get_attribute_uint64(instance::GFileInfo, _attribute::Union{AbstractString, Symbol})
    ret = ccall(("g_file_info_get_attribute_uint64", libgio), UInt64, (Ptr{GObject}, Cstring), instance, _attribute)
    ret
end
function get_content_type(instance::GFileInfo)
    ret = ccall(("g_file_info_get_content_type", libgio), Cstring, (Ptr{GObject},), instance)
    ret2 = string_or_nothing(ret, false)
    ret2
end
function get_creation_date_time(instance::GFileInfo)
    ret = ccall(("g_file_info_get_creation_date_time", libgio), Ptr{GDateTime}, (Ptr{GObject},), instance)
    ret2 = convert_if_not_null(GDateTime, ret, true)
    ret2
end
function get_deletion_date(instance::GFileInfo)
    ret = ccall(("g_file_info_get_deletion_date", libgio), Ptr{GDateTime}, (Ptr{GObject},), instance)
    ret2 = convert_if_not_null(GDateTime, ret, true)
    ret2
end
function get_display_name(instance::GFileInfo)
    ret = ccall(("g_file_info_get_display_name", libgio), Cstring, (Ptr{GObject},), instance)
    ret2 = string_or_nothing(ret, false)
    ret2
end
function get_edit_name(instance::GFileInfo)
    ret = ccall(("g_file_info_get_edit_name", libgio), Cstring, (Ptr{GObject},), instance)
    ret2 = string_or_nothing(ret, false)
    ret2
end
function get_etag(instance::GFileInfo)
    ret = ccall(("g_file_info_get_etag", libgio), Cstring, (Ptr{GObject},), instance)
    ret2 = string_or_nothing(ret, false)
    ret2
end
function get_file_type(instance::GFileInfo)
    ret = ccall(("g_file_info_get_file_type", libgio), UInt32, (Ptr{GObject},), instance)
    ret2 = FileType(ret)
    ret2
end
function get_icon(instance::GFileInfo)
    ret = ccall(("g_file_info_get_icon", libgio), Ptr{GObject}, (Ptr{GObject},), instance)
    ret2 = GLib.find_leaf_type_if_not_null(ret, false)
    ret2
end
function get_is_backup(instance::GFileInfo)
    ret = ccall(("g_file_info_get_is_backup", libgio), Cint, (Ptr{GObject},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function get_is_hidden(instance::GFileInfo)
    ret = ccall(("g_file_info_get_is_hidden", libgio), Cint, (Ptr{GObject},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function get_is_symlink(instance::GFileInfo)
    ret = ccall(("g_file_info_get_is_symlink", libgio), Cint, (Ptr{GObject},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function get_modification_date_time(instance::GFileInfo)
    ret = ccall(("g_file_info_get_modification_date_time", libgio), Ptr{GDateTime}, (Ptr{GObject},), instance)
    ret2 = convert_if_not_null(GDateTime, ret, true)
    ret2
end
function get_name(instance::GFileInfo)
    ret = ccall(("g_file_info_get_name", libgio), Cstring, (Ptr{GObject},), instance)
    ret2 = string_or_nothing(ret, false)
    ret2
end
function get_size(instance::GFileInfo)
    ret = ccall(("g_file_info_get_size", libgio), Int64, (Ptr{GObject},), instance)
    ret
end
function get_sort_order(instance::GFileInfo)
    ret = ccall(("g_file_info_get_sort_order", libgio), Int32, (Ptr{GObject},), instance)
    ret
end
function get_symbolic_icon(instance::GFileInfo)
    ret = ccall(("g_file_info_get_symbolic_icon", libgio), Ptr{GObject}, (Ptr{GObject},), instance)
    ret2 = GLib.find_leaf_type_if_not_null(ret, false)
    ret2
end
function get_symlink_target(instance::GFileInfo)
    ret = ccall(("g_file_info_get_symlink_target", libgio), Cstring, (Ptr{GObject},), instance)
    ret2 = string_or_nothing(ret, false)
    ret2
end
function has_attribute(instance::GFileInfo, _attribute::Union{AbstractString, Symbol})
    ret = ccall(("g_file_info_has_attribute", libgio), Cint, (Ptr{GObject}, Cstring), instance, _attribute)
    ret2 = convert(Bool, ret)
    ret2
end
function has_namespace(instance::GFileInfo, _name_space::Union{AbstractString, Symbol})
    ret = ccall(("g_file_info_has_namespace", libgio), Cint, (Ptr{GObject}, Cstring), instance, _name_space)
    ret2 = convert(Bool, ret)
    ret2
end
function list_attributes(instance::GFileInfo, _name_space::Maybe(Union{AbstractString, Symbol}))
    _name_space_maybe = nothing_to_null(_name_space)
    ret = ccall(("g_file_info_list_attributes", libgio), Ptr{Cstring}, (Ptr{GObject}, Cstring), instance, _name_space_maybe)
    ret2 = begin
            _len = length_zt(ret)
            arrtemp = bytestring.(unsafe_wrap(Vector{Cstring}, ret, _len))
            GLib.g_strfreev(ret)
            arrtemp
        end
    ret2
end
function remove_attribute(instance::GFileInfo, _attribute::Union{AbstractString, Symbol})
    ret = ccall(("g_file_info_remove_attribute", libgio), Nothing, (Ptr{GObject}, Cstring), instance, _attribute)
    nothing
end
function set_access_date_time(instance::GFileInfo, _atime::GDateTime)
    ret = ccall(("g_file_info_set_access_date_time", libgio), Nothing, (Ptr{GObject}, Ptr{GDateTime}), instance, _atime)
    nothing
end
function set_attribute(instance::GFileInfo, _attribute::Union{AbstractString, Symbol}, _type, _value_p::Nothing)
    ret = ccall(("g_file_info_set_attribute", libgio), Nothing, (Ptr{GObject}, Cstring, UInt32, Ptr{Nothing}), instance, _attribute, _type, _value_p)
    nothing
end
function set_attribute_boolean(instance::GFileInfo, _attribute::Union{AbstractString, Symbol}, _attr_value::Bool)
    ret = ccall(("g_file_info_set_attribute_boolean", libgio), Nothing, (Ptr{GObject}, Cstring, Cint), instance, _attribute, _attr_value)
    nothing
end
function set_attribute_byte_string(instance::GFileInfo, _attribute::Union{AbstractString, Symbol}, _attr_value::Union{AbstractString, Symbol})
    ret = ccall(("g_file_info_set_attribute_byte_string", libgio), Nothing, (Ptr{GObject}, Cstring, Cstring), instance, _attribute, _attr_value)
    nothing
end
function set_attribute_int32(instance::GFileInfo, _attribute::Union{AbstractString, Symbol}, _attr_value::Integer)
    ret = ccall(("g_file_info_set_attribute_int32", libgio), Nothing, (Ptr{GObject}, Cstring, Int32), instance, _attribute, _attr_value)
    nothing
end
function set_attribute_int64(instance::GFileInfo, _attribute::Union{AbstractString, Symbol}, _attr_value::Integer)
    ret = ccall(("g_file_info_set_attribute_int64", libgio), Nothing, (Ptr{GObject}, Cstring, Int64), instance, _attribute, _attr_value)
    nothing
end
function set_attribute_mask(instance::GFileInfo, _mask::GFileAttributeMatcher)
    ret = ccall(("g_file_info_set_attribute_mask", libgio), Nothing, (Ptr{GObject}, Ptr{GFileAttributeMatcher}), instance, _mask)
    nothing
end
function set_attribute_object(instance::GFileInfo, _attribute::Union{AbstractString, Symbol}, _attr_value::GObject)
    ret = ccall(("g_file_info_set_attribute_object", libgio), Nothing, (Ptr{GObject}, Cstring, Ptr{GObject}), instance, _attribute, _attr_value)
    nothing
end
function set_attribute_status(instance::GFileInfo, _attribute::Union{AbstractString, Symbol}, _status)
    ret = ccall(("g_file_info_set_attribute_status", libgio), Cint, (Ptr{GObject}, Cstring, UInt32), instance, _attribute, _status)
    ret2 = convert(Bool, ret)
    ret2
end
function set_attribute_string(instance::GFileInfo, _attribute::Union{AbstractString, Symbol}, _attr_value::Union{AbstractString, Symbol})
    ret = ccall(("g_file_info_set_attribute_string", libgio), Nothing, (Ptr{GObject}, Cstring, Cstring), instance, _attribute, _attr_value)
    nothing
end
function set_attribute_stringv(instance::GFileInfo, _attribute::Union{AbstractString, Symbol}, _attr_value)
    ret = ccall(("g_file_info_set_attribute_stringv", libgio), Nothing, (Ptr{GObject}, Cstring, Ptr{Cstring}), instance, _attribute, _attr_value)
    nothing
end
function set_attribute_uint32(instance::GFileInfo, _attribute::Union{AbstractString, Symbol}, _attr_value::Integer)
    ret = ccall(("g_file_info_set_attribute_uint32", libgio), Nothing, (Ptr{GObject}, Cstring, UInt32), instance, _attribute, _attr_value)
    nothing
end
function set_attribute_uint64(instance::GFileInfo, _attribute::Union{AbstractString, Symbol}, _attr_value::Integer)
    ret = ccall(("g_file_info_set_attribute_uint64", libgio), Nothing, (Ptr{GObject}, Cstring, UInt64), instance, _attribute, _attr_value)
    nothing
end
function set_content_type(instance::GFileInfo, _content_type::Union{AbstractString, Symbol})
    ret = ccall(("g_file_info_set_content_type", libgio), Nothing, (Ptr{GObject}, Cstring), instance, _content_type)
    nothing
end
function set_creation_date_time(instance::GFileInfo, _creation_time::GDateTime)
    ret = ccall(("g_file_info_set_creation_date_time", libgio), Nothing, (Ptr{GObject}, Ptr{GDateTime}), instance, _creation_time)
    nothing
end
function set_display_name(instance::GFileInfo, _display_name::Union{AbstractString, Symbol})
    ret = ccall(("g_file_info_set_display_name", libgio), Nothing, (Ptr{GObject}, Cstring), instance, _display_name)
    nothing
end
function set_edit_name(instance::GFileInfo, _edit_name::Union{AbstractString, Symbol})
    ret = ccall(("g_file_info_set_edit_name", libgio), Nothing, (Ptr{GObject}, Cstring), instance, _edit_name)
    nothing
end
function set_file_type(instance::GFileInfo, _type)
    ret = ccall(("g_file_info_set_file_type", libgio), Nothing, (Ptr{GObject}, UInt32), instance, _type)
    nothing
end
function set_icon(instance::GFileInfo, _icon::GIcon)
    ret = ccall(("g_file_info_set_icon", libgio), Nothing, (Ptr{GObject}, Ptr{GObject}), instance, _icon)
    nothing
end
function set_is_hidden(instance::GFileInfo, _is_hidden::Bool)
    ret = ccall(("g_file_info_set_is_hidden", libgio), Nothing, (Ptr{GObject}, Cint), instance, _is_hidden)
    nothing
end
function set_is_symlink(instance::GFileInfo, _is_symlink::Bool)
    ret = ccall(("g_file_info_set_is_symlink", libgio), Nothing, (Ptr{GObject}, Cint), instance, _is_symlink)
    nothing
end
function set_modification_date_time(instance::GFileInfo, _mtime::GDateTime)
    ret = ccall(("g_file_info_set_modification_date_time", libgio), Nothing, (Ptr{GObject}, Ptr{GDateTime}), instance, _mtime)
    nothing
end
function set_name(instance::GFileInfo, _name::Union{AbstractString, Symbol})
    ret = ccall(("g_file_info_set_name", libgio), Nothing, (Ptr{GObject}, Cstring), instance, _name)
    nothing
end
function set_size(instance::GFileInfo, _size::Integer)
    ret = ccall(("g_file_info_set_size", libgio), Nothing, (Ptr{GObject}, Int64), instance, _size)
    nothing
end
function set_sort_order(instance::GFileInfo, _sort_order::Integer)
    ret = ccall(("g_file_info_set_sort_order", libgio), Nothing, (Ptr{GObject}, Int32), instance, _sort_order)
    nothing
end
function set_symbolic_icon(instance::GFileInfo, _icon::GIcon)
    ret = ccall(("g_file_info_set_symbolic_icon", libgio), Nothing, (Ptr{GObject}, Ptr{GObject}), instance, _icon)
    nothing
end
function set_symlink_target(instance::GFileInfo, _symlink_target::Union{AbstractString, Symbol})
    ret = ccall(("g_file_info_set_symlink_target", libgio), Nothing, (Ptr{GObject}, Cstring), instance, _symlink_target)
    nothing
end
function unset_attribute_mask(instance::GFileInfo)
    ret = ccall(("g_file_info_unset_attribute_mask", libgio), Nothing, (Ptr{GObject},), instance)
    nothing
end
function query_info(instance::GFileInputStream, _attributes::Union{AbstractString, Symbol}, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_file_input_stream_query_info", libgio), Ptr{GObject}, (Ptr{GObject}, Cstring, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _attributes, _cancellable_maybe, err)
    check_err(err)
    ret2 = convert(GFileInfo, ret, true)
    ret2
end
function query_info_async(instance::GFileInputStream, _attributes::Union{AbstractString, Symbol}, _io_priority::Integer, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    ret = ccall(("g_file_input_stream_query_info_async", libgio), Nothing, (Ptr{GObject}, Cstring, Int32, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _attributes, _io_priority, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function query_info_finish(instance::GFileInputStream, _result::GAsyncResult)
    err = err_buf()
    ret = ccall(("g_file_input_stream_query_info_finish", libgio), Ptr{GObject}, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _result, err)
    check_err(err)
    ret2 = convert(GFileInfo, ret, true)
    ret2
end
function can_seek(instance::GFileInputStream)
    can_seek(GSeekable(instance))
end
function can_truncate(instance::GFileInputStream)
    can_truncate(GSeekable(instance))
end
function seek(instance::GFileInputStream, _offset::Integer, _type, _cancellable::Maybe(GCancellable))
    seek(GSeekable(instance), _offset, _type, _cancellable)
end
function tell(instance::GFileInputStream)
    tell(GSeekable(instance))
end
function truncate(instance::GFileInputStream, _offset::Integer, _cancellable::Maybe(GCancellable))
    truncate(GSeekable(instance), _offset, _cancellable)
end
function cancel(instance::GFileMonitor)
    ret = ccall(("g_file_monitor_cancel", libgio), Cint, (Ptr{GObject},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function emit_event(instance::GFileMonitor, _child::GFile, _other_file::GFile, _event_type)
    ret = ccall(("g_file_monitor_emit_event", libgio), Nothing, (Ptr{GObject}, Ptr{GObject}, Ptr{GObject}, UInt32), instance, _child, _other_file, _event_type)
    nothing
end
function is_cancelled(instance::GFileMonitor)
    ret = ccall(("g_file_monitor_is_cancelled", libgio), Cint, (Ptr{GObject},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function set_rate_limit(instance::GFileMonitor, _limit_msecs::Integer)
    ret = ccall(("g_file_monitor_set_rate_limit", libgio), Nothing, (Ptr{GObject}, Int32), instance, _limit_msecs)
    nothing
end
function get_etag(instance::GFileOutputStream)
    ret = ccall(("g_file_output_stream_get_etag", libgio), Cstring, (Ptr{GObject},), instance)
    ret2 = string_or_nothing(ret, true)
    ret2
end
function query_info(instance::GFileOutputStream, _attributes::Union{AbstractString, Symbol}, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_file_output_stream_query_info", libgio), Ptr{GObject}, (Ptr{GObject}, Cstring, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _attributes, _cancellable_maybe, err)
    check_err(err)
    ret2 = convert(GFileInfo, ret, true)
    ret2
end
function query_info_async(instance::GFileOutputStream, _attributes::Union{AbstractString, Symbol}, _io_priority::Integer, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    ret = ccall(("g_file_output_stream_query_info_async", libgio), Nothing, (Ptr{GObject}, Cstring, Int32, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _attributes, _io_priority, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function query_info_finish(instance::GFileOutputStream, _result::GAsyncResult)
    err = err_buf()
    ret = ccall(("g_file_output_stream_query_info_finish", libgio), Ptr{GObject}, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _result, err)
    check_err(err)
    ret2 = convert(GFileInfo, ret, true)
    ret2
end
function can_seek(instance::GFileOutputStream)
    can_seek(GSeekable(instance))
end
function can_truncate(instance::GFileOutputStream)
    can_truncate(GSeekable(instance))
end
function seek(instance::GFileOutputStream, _offset::Integer, _type, _cancellable::Maybe(GCancellable))
    seek(GSeekable(instance), _offset, _type, _cancellable)
end
function tell(instance::GFileOutputStream)
    tell(GSeekable(instance))
end
function truncate(instance::GFileOutputStream, _offset::Integer, _cancellable::Maybe(GCancellable))
    truncate(GSeekable(instance), _offset, _cancellable)
end
function FilenameCompleter_new()
    ret = ccall(("g_filename_completer_new", libgio), Ptr{GObject}, ())
    ret2 = GFilenameCompleterLeaf(ret, true)
    ret2
end
function get_completion_suffix(instance::GFilenameCompleter, _initial_text::Union{AbstractString, Symbol})
    ret = ccall(("g_filename_completer_get_completion_suffix", libgio), Cstring, (Ptr{GObject}, Cstring), instance, _initial_text)
    ret2 = string_or_nothing(ret, true)
    ret2
end
function get_completions(instance::GFilenameCompleter, _initial_text::Union{AbstractString, Symbol})
    ret = ccall(("g_filename_completer_get_completions", libgio), Ptr{Cstring}, (Ptr{GObject}, Cstring), instance, _initial_text)
    ret2 = begin
            _len = length_zt(ret)
            arrtemp = bytestring.(unsafe_wrap(Vector{Cstring}, ret, _len))
            GLib.g_strfreev(ret)
            arrtemp
        end
    ret2
end
function set_dirs_only(instance::GFilenameCompleter, _dirs_only::Bool)
    ret = ccall(("g_filename_completer_set_dirs_only", libgio), Nothing, (Ptr{GObject}, Cint), instance, _dirs_only)
    nothing
end
function get_base_stream(instance::GFilterInputStream)
    ret = ccall(("g_filter_input_stream_get_base_stream", libgio), Ptr{GObject}, (Ptr{GObject},), instance)
    ret2 = convert(GInputStream, ret, false)
    ret2
end
function get_close_base_stream(instance::GFilterInputStream)
    ret = ccall(("g_filter_input_stream_get_close_base_stream", libgio), Cint, (Ptr{GObject},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function set_close_base_stream(instance::GFilterInputStream, _close_base::Bool)
    ret = ccall(("g_filter_input_stream_set_close_base_stream", libgio), Nothing, (Ptr{GObject}, Cint), instance, _close_base)
    nothing
end
function get_base_stream(instance::GFilterOutputStream)
    ret = ccall(("g_filter_output_stream_get_base_stream", libgio), Ptr{GObject}, (Ptr{GObject},), instance)
    ret2 = convert(GOutputStream, ret, false)
    ret2
end
function get_close_base_stream(instance::GFilterOutputStream)
    ret = ccall(("g_filter_output_stream_get_close_base_stream", libgio), Cint, (Ptr{GObject},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function set_close_base_stream(instance::GFilterOutputStream, _close_base::Bool)
    ret = ccall(("g_filter_output_stream_set_close_base_stream", libgio), Nothing, (Ptr{GObject}, Cint), instance, _close_base)
    nothing
end
function splice_finish(_result::GAsyncResult)
    err = err_buf()
    ret = ccall(("g_io_stream_splice_finish", libgio), Cint, (Ptr{GObject}, Ptr{Ptr{GError}}), _result, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function clear_pending(instance::GIOStream)
    ret = ccall(("g_io_stream_clear_pending", libgio), Nothing, (Ptr{GObject},), instance)
    nothing
end
function close(instance::GIOStream, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_io_stream_close", libgio), Cint, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _cancellable_maybe, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function close_async(instance::GIOStream, _io_priority::Integer, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    ret = ccall(("g_io_stream_close_async", libgio), Nothing, (Ptr{GObject}, Int32, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _io_priority, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function close_finish(instance::GIOStream, _result::GAsyncResult)
    err = err_buf()
    ret = ccall(("g_io_stream_close_finish", libgio), Cint, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _result, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function get_input_stream(instance::GIOStream)
    ret = ccall(("g_io_stream_get_input_stream", libgio), Ptr{GObject}, (Ptr{GObject},), instance)
    ret2 = convert(GInputStream, ret, false)
    ret2
end
function get_output_stream(instance::GIOStream)
    ret = ccall(("g_io_stream_get_output_stream", libgio), Ptr{GObject}, (Ptr{GObject},), instance)
    ret2 = convert(GOutputStream, ret, false)
    ret2
end
function has_pending(instance::GIOStream)
    ret = ccall(("g_io_stream_has_pending", libgio), Cint, (Ptr{GObject},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function is_closed(instance::GIOStream)
    ret = ccall(("g_io_stream_is_closed", libgio), Cint, (Ptr{GObject},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function set_pending(instance::GIOStream)
    err = err_buf()
    ret = ccall(("g_io_stream_set_pending", libgio), Cint, (Ptr{GObject}, Ptr{Ptr{GError}}), instance, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function splice_async(instance::GIOStream, _stream2::GIOStream, _flags, _io_priority::Integer, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    ret = ccall(("g_io_stream_splice_async", libgio), Nothing, (Ptr{GObject}, Ptr{GObject}, UInt32, Int32, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _stream2, _flags, _io_priority, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function InetAddress_new_any(_family)
    ret = ccall(("g_inet_address_new_any", libgio), Ptr{GObject}, (UInt32,), _family)
    ret2 = GInetAddressLeaf(ret, true)
    ret2
end
function InetAddress_new_from_bytes(_bytes, _family)
    _bytes_arr = convert(Vector{UInt8}, _bytes)
    ret = ccall(("g_inet_address_new_from_bytes", libgio), Ptr{GObject}, (Ptr{UInt8}, UInt32), _bytes_arr, _family)
    ret2 = GInetAddressLeaf(ret, true)
    ret2
end
function InetAddress_new_from_string(_string::Union{AbstractString, Symbol})
    ret = ccall(("g_inet_address_new_from_string", libgio), Ptr{GObject}, (Cstring,), _string)
    ret2 = convert_if_not_null(GInetAddress, ret, true)
    ret2
end
function InetAddress_new_loopback(_family)
    ret = ccall(("g_inet_address_new_loopback", libgio), Ptr{GObject}, (UInt32,), _family)
    ret2 = GInetAddressLeaf(ret, true)
    ret2
end
function equal(instance::GInetAddress, _other_address::GInetAddress)
    ret = ccall(("g_inet_address_equal", libgio), Cint, (Ptr{GObject}, Ptr{GObject}), instance, _other_address)
    ret2 = convert(Bool, ret)
    ret2
end
function get_family(instance::GInetAddress)
    ret = ccall(("g_inet_address_get_family", libgio), UInt32, (Ptr{GObject},), instance)
    ret2 = SocketFamily(ret)
    ret2
end
function get_is_any(instance::GInetAddress)
    ret = ccall(("g_inet_address_get_is_any", libgio), Cint, (Ptr{GObject},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function get_is_link_local(instance::GInetAddress)
    ret = ccall(("g_inet_address_get_is_link_local", libgio), Cint, (Ptr{GObject},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function get_is_loopback(instance::GInetAddress)
    ret = ccall(("g_inet_address_get_is_loopback", libgio), Cint, (Ptr{GObject},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function get_is_mc_global(instance::GInetAddress)
    ret = ccall(("g_inet_address_get_is_mc_global", libgio), Cint, (Ptr{GObject},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function get_is_mc_link_local(instance::GInetAddress)
    ret = ccall(("g_inet_address_get_is_mc_link_local", libgio), Cint, (Ptr{GObject},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function get_is_mc_node_local(instance::GInetAddress)
    ret = ccall(("g_inet_address_get_is_mc_node_local", libgio), Cint, (Ptr{GObject},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function get_is_mc_org_local(instance::GInetAddress)
    ret = ccall(("g_inet_address_get_is_mc_org_local", libgio), Cint, (Ptr{GObject},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function get_is_mc_site_local(instance::GInetAddress)
    ret = ccall(("g_inet_address_get_is_mc_site_local", libgio), Cint, (Ptr{GObject},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function get_is_multicast(instance::GInetAddress)
    ret = ccall(("g_inet_address_get_is_multicast", libgio), Cint, (Ptr{GObject},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function get_is_site_local(instance::GInetAddress)
    ret = ccall(("g_inet_address_get_is_site_local", libgio), Cint, (Ptr{GObject},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function get_native_size(instance::GInetAddress)
    ret = ccall(("g_inet_address_get_native_size", libgio), UInt64, (Ptr{GObject},), instance)
    ret
end
function to_string(instance::GInetAddress)
    ret = ccall(("g_inet_address_to_string", libgio), Cstring, (Ptr{GObject},), instance)
    ret2 = string_or_nothing(ret, true)
    ret2
end
function InetAddressMask_new(_addr::GInetAddress, _length::Integer)
    err = err_buf()
    ret = ccall(("g_inet_address_mask_new", libgio), Ptr{GObject}, (Ptr{GObject}, UInt32, Ptr{Ptr{GError}}), _addr, _length, err)
    check_err(err)
    ret2 = GInetAddressMaskLeaf(ret, true)
    ret2
end
function InetAddressMask_new_from_string(_mask_string::Union{AbstractString, Symbol})
    err = err_buf()
    ret = ccall(("g_inet_address_mask_new_from_string", libgio), Ptr{GObject}, (Cstring, Ptr{Ptr{GError}}), _mask_string, err)
    check_err(err)
    ret2 = GInetAddressMaskLeaf(ret, true)
    ret2
end
function equal(instance::GInetAddressMask, _mask2::GInetAddressMask)
    ret = ccall(("g_inet_address_mask_equal", libgio), Cint, (Ptr{GObject}, Ptr{GObject}), instance, _mask2)
    ret2 = convert(Bool, ret)
    ret2
end
function get_address(instance::GInetAddressMask)
    ret = ccall(("g_inet_address_mask_get_address", libgio), Ptr{GObject}, (Ptr{GObject},), instance)
    ret2 = convert(GInetAddress, ret, false)
    ret2
end
function get_family(instance::GInetAddressMask)
    ret = ccall(("g_inet_address_mask_get_family", libgio), UInt32, (Ptr{GObject},), instance)
    ret2 = SocketFamily(ret)
    ret2
end
function get_length(instance::GInetAddressMask)
    ret = ccall(("g_inet_address_mask_get_length", libgio), UInt32, (Ptr{GObject},), instance)
    ret
end
function matches(instance::GInetAddressMask, _address::GInetAddress)
    ret = ccall(("g_inet_address_mask_matches", libgio), Cint, (Ptr{GObject}, Ptr{GObject}), instance, _address)
    ret2 = convert(Bool, ret)
    ret2
end
function to_string(instance::GInetAddressMask)
    ret = ccall(("g_inet_address_mask_to_string", libgio), Cstring, (Ptr{GObject},), instance)
    ret2 = string_or_nothing(ret, true)
    ret2
end
function init(instance::GInetAddressMask, _cancellable::Maybe(GCancellable))
    init(GInitable(instance), _cancellable)
end
function InetSocketAddress_new(_address::GInetAddress, _port::Integer)
    ret = ccall(("g_inet_socket_address_new", libgio), Ptr{GObject}, (Ptr{GObject}, UInt16), _address, _port)
    ret2 = GInetSocketAddressLeaf(ret, true)
    ret2
end
function InetSocketAddress_new_from_string(_address::Union{AbstractString, Symbol}, _port::Integer)
    ret = ccall(("g_inet_socket_address_new_from_string", libgio), Ptr{GObject}, (Cstring, UInt32), _address, _port)
    ret2 = convert_if_not_null(GSocketAddress, ret, true)
    ret2
end
function get_address(instance::GInetSocketAddress)
    ret = ccall(("g_inet_socket_address_get_address", libgio), Ptr{GObject}, (Ptr{GObject},), instance)
    ret2 = convert(GInetAddress, ret, false)
    ret2
end
function get_flowinfo(instance::GInetSocketAddress)
    ret = ccall(("g_inet_socket_address_get_flowinfo", libgio), UInt32, (Ptr{GObject},), instance)
    ret
end
function get_port(instance::GInetSocketAddress)
    ret = ccall(("g_inet_socket_address_get_port", libgio), UInt16, (Ptr{GObject},), instance)
    ret
end
function get_scope_id(instance::GInetSocketAddress)
    ret = ccall(("g_inet_socket_address_get_scope_id", libgio), UInt32, (Ptr{GObject},), instance)
    ret
end
function enumerate(instance::GInetSocketAddress)
    enumerate(GSocketConnectable(instance))
end
function proxy_enumerate(instance::GInetSocketAddress)
    proxy_enumerate(GSocketConnectable(instance))
end
function to_string(instance::GInetSocketAddress)
    to_string(GSocketConnectable(instance))
end
function clear_pending(instance::GInputStream)
    ret = ccall(("g_input_stream_clear_pending", libgio), Nothing, (Ptr{GObject},), instance)
    nothing
end
function close(instance::GInputStream, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_input_stream_close", libgio), Cint, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _cancellable_maybe, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function close_async(instance::GInputStream, _io_priority::Integer, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    ret = ccall(("g_input_stream_close_async", libgio), Nothing, (Ptr{GObject}, Int32, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _io_priority, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function close_finish(instance::GInputStream, _result::GAsyncResult)
    err = err_buf()
    ret = ccall(("g_input_stream_close_finish", libgio), Cint, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _result, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function has_pending(instance::GInputStream)
    ret = ccall(("g_input_stream_has_pending", libgio), Cint, (Ptr{GObject},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function is_closed(instance::GInputStream)
    ret = ccall(("g_input_stream_is_closed", libgio), Cint, (Ptr{GObject},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function read(instance::GInputStream, _cancellable::Maybe(GCancellable))
    m_buffer = Ref{Ptr{UInt8}}()
    _cancellable_maybe = nothing_to_null(_cancellable)
    _count = length(_buffer)
    err = err_buf()
    ret = ccall(("g_input_stream_read", libgio), Int64, (Ptr{GObject}, Ptr{Ptr{UInt8}}, UInt64, Ptr{GObject}, Ptr{Ptr{GError}}), instance, m_buffer, _count, _cancellable_maybe, err)
    check_err(err)
    _buffer = m_buffer[]
    _buffer = collect(unsafe_wrap(Vector{UInt8}, _buffer, m_count[]))
    (ret, _buffer)
end
function read_all(instance::GInputStream, _cancellable::Maybe(GCancellable))
    m_buffer = Ref{Ptr{UInt8}}()
    m_bytes_read = Ref{UInt64}()
    _cancellable_maybe = nothing_to_null(_cancellable)
    _count = length(_buffer)
    err = err_buf()
    ret = ccall(("g_input_stream_read_all", libgio), Cint, (Ptr{GObject}, Ptr{Ptr{UInt8}}, UInt64, Ptr{UInt64}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, m_buffer, _count, m_bytes_read, _cancellable_maybe, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    _buffer = m_buffer[]
    _buffer = collect(unsafe_wrap(Vector{UInt8}, _buffer, m_count[]))
    _bytes_read = m_bytes_read[]
    (ret2, _buffer, _bytes_read)
end
function read_all_async(instance::GInputStream, _io_priority::Integer, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    m_buffer = Ref{Ptr{UInt8}}()
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    _count = length(_buffer)
    ret = ccall(("g_input_stream_read_all_async", libgio), Nothing, (Ptr{GObject}, Ptr{Ptr{UInt8}}, UInt64, Int32, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, m_buffer, _count, _io_priority, _cancellable_maybe, _callback_cfunc, _callback_closure)
    _buffer = m_buffer[]
    _buffer = collect(unsafe_wrap(Vector{UInt8}, _buffer, m_count[]))
    _buffer
end
function read_all_finish(instance::GInputStream, _result::GAsyncResult)
    m_bytes_read = Ref{UInt64}()
    err = err_buf()
    ret = ccall(("g_input_stream_read_all_finish", libgio), Cint, (Ptr{GObject}, Ptr{GObject}, Ptr{UInt64}, Ptr{Ptr{GError}}), instance, _result, m_bytes_read, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    _bytes_read = m_bytes_read[]
    (ret2, _bytes_read)
end
function read_async(instance::GInputStream, _io_priority::Integer, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    m_buffer = Ref{Ptr{UInt8}}()
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    _count = length(_buffer)
    ret = ccall(("g_input_stream_read_async", libgio), Nothing, (Ptr{GObject}, Ptr{Ptr{UInt8}}, UInt64, Int32, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, m_buffer, _count, _io_priority, _cancellable_maybe, _callback_cfunc, _callback_closure)
    _buffer = m_buffer[]
    _buffer = collect(unsafe_wrap(Vector{UInt8}, _buffer, m_count[]))
    _buffer
end
function read_bytes(instance::GInputStream, _count::Integer, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_input_stream_read_bytes", libgio), Ptr{GBytes}, (Ptr{GObject}, UInt64, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _count, _cancellable_maybe, err)
    check_err(err)
    ret2 = convert(GBytes, ret, true)
    ret2
end
function read_bytes_async(instance::GInputStream, _count::Integer, _io_priority::Integer, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    ret = ccall(("g_input_stream_read_bytes_async", libgio), Nothing, (Ptr{GObject}, UInt64, Int32, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _count, _io_priority, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function read_bytes_finish(instance::GInputStream, _result::GAsyncResult)
    err = err_buf()
    ret = ccall(("g_input_stream_read_bytes_finish", libgio), Ptr{GBytes}, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _result, err)
    check_err(err)
    ret2 = convert(GBytes, ret, true)
    ret2
end
function read_finish(instance::GInputStream, _result::GAsyncResult)
    err = err_buf()
    ret = ccall(("g_input_stream_read_finish", libgio), Int64, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _result, err)
    check_err(err)
    ret
end
function set_pending(instance::GInputStream)
    err = err_buf()
    ret = ccall(("g_input_stream_set_pending", libgio), Cint, (Ptr{GObject}, Ptr{Ptr{GError}}), instance, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function skip(instance::GInputStream, _count::Integer, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_input_stream_skip", libgio), Int64, (Ptr{GObject}, UInt64, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _count, _cancellable_maybe, err)
    check_err(err)
    ret
end
function skip_async(instance::GInputStream, _count::Integer, _io_priority::Integer, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    ret = ccall(("g_input_stream_skip_async", libgio), Nothing, (Ptr{GObject}, UInt64, Int32, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _count, _io_priority, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function skip_finish(instance::GInputStream, _result::GAsyncResult)
    err = err_buf()
    ret = ccall(("g_input_stream_skip_finish", libgio), Int64, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _result, err)
    check_err(err)
    ret
end
function ListStore_new(_item_type::Integer)
    ret = ccall(("g_list_store_new", libgio), Ptr{GObject}, (UInt64,), _item_type)
    ret2 = GListStoreLeaf(ret, true)
    ret2
end
function append(instance::GListStore, _item::GObject)
    ret = ccall(("g_list_store_append", libgio), Nothing, (Ptr{GObject}, Ptr{GObject}), instance, _item)
    nothing
end
function find(instance::GListStore, _item::GObject)
    m_position = Ref{UInt32}()
    ret = ccall(("g_list_store_find", libgio), Cint, (Ptr{GObject}, Ptr{GObject}, Ptr{UInt32}), instance, _item, m_position)
    ret2 = convert(Bool, ret)
    _position = m_position[]
    (ret2, _position)
end
function find_with_equal_func_full(instance::GListStore, _item::Maybe(GObject), _equal_func::Function)
    _item_maybe = nothing_to_null(_item)
    begin
        _equal_func_cfunc = @cfunction(GEqualFuncFull, Cint, (Ptr{Nothing}, Ptr{Nothing}, Ref{Function}))
        begin
            ref = Ref{Any}(_equal_func)
            _equal_func_closure = unsafe_load(convert(Ptr{Ptr{Nothing}}, Base.unsafe_convert(Ptr{Any}, ref)))
        end
    end
    m_position = Ref{UInt32}()
    ret = ccall(("g_list_store_find_with_equal_func_full", libgio), Cint, (Ptr{GObject}, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}, Ptr{UInt32}), instance, _item_maybe, _equal_func_cfunc, _equal_func_closure, m_position)
    ret2 = convert(Bool, ret)
    _position = m_position[]
    (ret2, _position)
end
function insert(instance::GListStore, _position::Integer, _item::GObject)
    ret = ccall(("g_list_store_insert", libgio), Nothing, (Ptr{GObject}, UInt32, Ptr{GObject}), instance, _position, _item)
    nothing
end
function insert_sorted(instance::GListStore, _item::GObject, _compare_func::Function)
    begin
        _compare_func_cfunc = @cfunction(GCompareDataFunc, Int32, (Ptr{Nothing}, Ptr{Nothing}, Ref{Function}))
        begin
            ref = Ref{Any}(_compare_func)
            _compare_func_closure = unsafe_load(convert(Ptr{Ptr{Nothing}}, Base.unsafe_convert(Ptr{Any}, ref)))
        end
    end
    ret = ccall(("g_list_store_insert_sorted", libgio), UInt32, (Ptr{GObject}, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _item, _compare_func_cfunc, _compare_func_closure)
    ret
end
function remove(instance::GListStore, _position::Integer)
    ret = ccall(("g_list_store_remove", libgio), Nothing, (Ptr{GObject}, UInt32), instance, _position)
    nothing
end
function remove_all(instance::GListStore)
    ret = ccall(("g_list_store_remove_all", libgio), Nothing, (Ptr{GObject},), instance)
    nothing
end
function sort(instance::GListStore, _compare_func::Function)
    begin
        _compare_func_cfunc = @cfunction(GCompareDataFunc, Int32, (Ptr{Nothing}, Ptr{Nothing}, Ref{Function}))
        begin
            ref = Ref{Any}(_compare_func)
            _compare_func_closure = unsafe_load(convert(Ptr{Ptr{Nothing}}, Base.unsafe_convert(Ptr{Any}, ref)))
        end
    end
    ret = ccall(("g_list_store_sort", libgio), Nothing, (Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _compare_func_cfunc, _compare_func_closure)
    nothing
end
function splice(instance::GListStore, _position::Integer, _n_removals::Integer, _additions)
    _additions_arr = convert(Vector{Ptr{GObject}}, _additions)
    _n_additions = length(_additions)
    ret = ccall(("g_list_store_splice", libgio), Nothing, (Ptr{GObject}, UInt32, UInt32, Ptr{Ptr{GObject}}, UInt32), instance, _position, _n_removals, _additions_arr, _n_additions)
    nothing
end
function get_item_type(instance::GListStore)
    get_item_type(GListModel(instance))
end
function get_n_items(instance::GListStore)
    get_n_items(GListModel(instance))
end
function get_item(instance::GListStore, _position::Integer)
    get_item(GListModel(instance), _position)
end
function items_changed(instance::GListStore, _position::Integer, _removed::Integer, _added::Integer)
    items_changed(GListModel(instance), _position, _removed, _added)
end
function MemoryInputStream_new()
    ret = ccall(("g_memory_input_stream_new", libgio), Ptr{GObject}, ())
    ret2 = GMemoryInputStreamLeaf(ret, true)
    ret2
end
function MemoryInputStream_new_from_bytes(_bytes::GBytes)
    ret = ccall(("g_memory_input_stream_new_from_bytes", libgio), Ptr{GObject}, (Ptr{GBytes},), _bytes)
    ret2 = GMemoryInputStreamLeaf(ret, true)
    ret2
end
function add_bytes(instance::GMemoryInputStream, _bytes::GBytes)
    ret = ccall(("g_memory_input_stream_add_bytes", libgio), Nothing, (Ptr{GObject}, Ptr{GBytes}), instance, _bytes)
    nothing
end
function can_poll(instance::GMemoryInputStream)
    can_poll(GPollableInputStream(instance))
end
function create_source(instance::GMemoryInputStream, _cancellable::Maybe(GCancellable))
    create_source(GPollableInputStream(instance), _cancellable)
end
function is_readable(instance::GMemoryInputStream)
    is_readable(GPollableInputStream(instance))
end
function read_nonblocking(instance::GMemoryInputStream, _cancellable::Maybe(GCancellable))
    read_nonblocking(GPollableInputStream(instance), _cancellable)
end
function can_seek(instance::GMemoryInputStream)
    can_seek(GSeekable(instance))
end
function can_truncate(instance::GMemoryInputStream)
    can_truncate(GSeekable(instance))
end
function seek(instance::GMemoryInputStream, _offset::Integer, _type, _cancellable::Maybe(GCancellable))
    seek(GSeekable(instance), _offset, _type, _cancellable)
end
function tell(instance::GMemoryInputStream)
    tell(GSeekable(instance))
end
function truncate(instance::GMemoryInputStream, _offset::Integer, _cancellable::Maybe(GCancellable))
    truncate(GSeekable(instance), _offset, _cancellable)
end
function MemoryOutputStream_new_resizable()
    ret = ccall(("g_memory_output_stream_new_resizable", libgio), Ptr{GObject}, ())
    ret2 = GMemoryOutputStreamLeaf(ret, true)
    ret2
end
function get_data(instance::GMemoryOutputStream)
    ret = ccall(("g_memory_output_stream_get_data", libgio), Ptr{Nothing}, (Ptr{GObject},), instance)
    ret2 = convert(Nothing, ret)
    ret2
end
function get_data_size(instance::GMemoryOutputStream)
    ret = ccall(("g_memory_output_stream_get_data_size", libgio), UInt64, (Ptr{GObject},), instance)
    ret
end
function get_size(instance::GMemoryOutputStream)
    ret = ccall(("g_memory_output_stream_get_size", libgio), UInt64, (Ptr{GObject},), instance)
    ret
end
function steal_as_bytes(instance::GMemoryOutputStream)
    ret = ccall(("g_memory_output_stream_steal_as_bytes", libgio), Ptr{GBytes}, (Ptr{GObject},), instance)
    ret2 = convert(GBytes, ret, true)
    ret2
end
function steal_data(instance::GMemoryOutputStream)
    ret = ccall(("g_memory_output_stream_steal_data", libgio), Ptr{Nothing}, (Ptr{GObject},), instance)
    ret2 = convert(Nothing, ret)
    ret2
end
function can_poll(instance::GMemoryOutputStream)
    can_poll(GPollableOutputStream(instance))
end
function create_source(instance::GMemoryOutputStream, _cancellable::Maybe(GCancellable))
    create_source(GPollableOutputStream(instance), _cancellable)
end
function is_writable(instance::GMemoryOutputStream)
    is_writable(GPollableOutputStream(instance))
end
function write_nonblocking(instance::GMemoryOutputStream, _buffer, _cancellable::Maybe(GCancellable))
    write_nonblocking(GPollableOutputStream(instance), _buffer, _cancellable)
end
function writev_nonblocking(instance::GMemoryOutputStream, _vectors, _cancellable::Maybe(GCancellable))
    writev_nonblocking(GPollableOutputStream(instance), _vectors, _cancellable)
end
function can_seek(instance::GMemoryOutputStream)
    can_seek(GSeekable(instance))
end
function can_truncate(instance::GMemoryOutputStream)
    can_truncate(GSeekable(instance))
end
function seek(instance::GMemoryOutputStream, _offset::Integer, _type, _cancellable::Maybe(GCancellable))
    seek(GSeekable(instance), _offset, _type, _cancellable)
end
function tell(instance::GMemoryOutputStream)
    tell(GSeekable(instance))
end
function truncate(instance::GMemoryOutputStream, _offset::Integer, _cancellable::Maybe(GCancellable))
    truncate(GSeekable(instance), _offset, _cancellable)
end
function Menu_new()
    ret = ccall(("g_menu_new", libgio), Ptr{GObject}, ())
    ret2 = GMenuLeaf(ret, true)
    ret2
end
function append(instance::GMenu, _label::Maybe(Union{AbstractString, Symbol}), _detailed_action::Maybe(Union{AbstractString, Symbol}))
    _label_maybe = nothing_to_null(_label)
    _detailed_action_maybe = nothing_to_null(_detailed_action)
    ret = ccall(("g_menu_append", libgio), Nothing, (Ptr{GObject}, Cstring, Cstring), instance, _label_maybe, _detailed_action_maybe)
    nothing
end
function append_item(instance::GMenu, _item::GMenuItem)
    ret = ccall(("g_menu_append_item", libgio), Nothing, (Ptr{GObject}, Ptr{GObject}), instance, _item)
    nothing
end
function append_section(instance::GMenu, _label::Maybe(Union{AbstractString, Symbol}), _section::GMenuModel)
    _label_maybe = nothing_to_null(_label)
    ret = ccall(("g_menu_append_section", libgio), Nothing, (Ptr{GObject}, Cstring, Ptr{GObject}), instance, _label_maybe, _section)
    nothing
end
function append_submenu(instance::GMenu, _label::Maybe(Union{AbstractString, Symbol}), _submenu::GMenuModel)
    _label_maybe = nothing_to_null(_label)
    ret = ccall(("g_menu_append_submenu", libgio), Nothing, (Ptr{GObject}, Cstring, Ptr{GObject}), instance, _label_maybe, _submenu)
    nothing
end
function freeze(instance::GMenu)
    ret = ccall(("g_menu_freeze", libgio), Nothing, (Ptr{GObject},), instance)
    nothing
end
function insert(instance::GMenu, _position::Integer, _label::Maybe(Union{AbstractString, Symbol}), _detailed_action::Maybe(Union{AbstractString, Symbol}))
    _label_maybe = nothing_to_null(_label)
    _detailed_action_maybe = nothing_to_null(_detailed_action)
    ret = ccall(("g_menu_insert", libgio), Nothing, (Ptr{GObject}, Int32, Cstring, Cstring), instance, _position, _label_maybe, _detailed_action_maybe)
    nothing
end
function insert_item(instance::GMenu, _position::Integer, _item::GMenuItem)
    ret = ccall(("g_menu_insert_item", libgio), Nothing, (Ptr{GObject}, Int32, Ptr{GObject}), instance, _position, _item)
    nothing
end
function insert_section(instance::GMenu, _position::Integer, _label::Maybe(Union{AbstractString, Symbol}), _section::GMenuModel)
    _label_maybe = nothing_to_null(_label)
    ret = ccall(("g_menu_insert_section", libgio), Nothing, (Ptr{GObject}, Int32, Cstring, Ptr{GObject}), instance, _position, _label_maybe, _section)
    nothing
end
function insert_submenu(instance::GMenu, _position::Integer, _label::Maybe(Union{AbstractString, Symbol}), _submenu::GMenuModel)
    _label_maybe = nothing_to_null(_label)
    ret = ccall(("g_menu_insert_submenu", libgio), Nothing, (Ptr{GObject}, Int32, Cstring, Ptr{GObject}), instance, _position, _label_maybe, _submenu)
    nothing
end
function prepend(instance::GMenu, _label::Maybe(Union{AbstractString, Symbol}), _detailed_action::Maybe(Union{AbstractString, Symbol}))
    _label_maybe = nothing_to_null(_label)
    _detailed_action_maybe = nothing_to_null(_detailed_action)
    ret = ccall(("g_menu_prepend", libgio), Nothing, (Ptr{GObject}, Cstring, Cstring), instance, _label_maybe, _detailed_action_maybe)
    nothing
end
function prepend_item(instance::GMenu, _item::GMenuItem)
    ret = ccall(("g_menu_prepend_item", libgio), Nothing, (Ptr{GObject}, Ptr{GObject}), instance, _item)
    nothing
end
function prepend_section(instance::GMenu, _label::Maybe(Union{AbstractString, Symbol}), _section::GMenuModel)
    _label_maybe = nothing_to_null(_label)
    ret = ccall(("g_menu_prepend_section", libgio), Nothing, (Ptr{GObject}, Cstring, Ptr{GObject}), instance, _label_maybe, _section)
    nothing
end
function prepend_submenu(instance::GMenu, _label::Maybe(Union{AbstractString, Symbol}), _submenu::GMenuModel)
    _label_maybe = nothing_to_null(_label)
    ret = ccall(("g_menu_prepend_submenu", libgio), Nothing, (Ptr{GObject}, Cstring, Ptr{GObject}), instance, _label_maybe, _submenu)
    nothing
end
function remove(instance::GMenu, _position::Integer)
    ret = ccall(("g_menu_remove", libgio), Nothing, (Ptr{GObject}, Int32), instance, _position)
    nothing
end
function remove_all(instance::GMenu)
    ret = ccall(("g_menu_remove_all", libgio), Nothing, (Ptr{GObject},), instance)
    nothing
end
function get_name(instance::GMenuAttributeIter)
    ret = ccall(("g_menu_attribute_iter_get_name", libgio), Cstring, (Ptr{GObject},), instance)
    ret2 = string_or_nothing(ret, false)
    ret2
end
function get_next(instance::GMenuAttributeIter)
    m_out_name = Ref{Cstring}()
    m_value = Ref{Ptr{GVariant}}()
    ret = ccall(("g_menu_attribute_iter_get_next", libgio), Cint, (Ptr{GObject}, Ptr{Cstring}, Ptr{Ptr{GVariant}}), instance, m_out_name, m_value)
    ret2 = convert(Bool, ret)
    _out_name = m_out_name[]
    _out_name = string_or_nothing(_out_name, false)
    _value = m_value[]
    _value = convert(GVariant, _value)
    (ret2, _out_name, _value)
end
function get_value(instance::GMenuAttributeIter)
    ret = ccall(("g_menu_attribute_iter_get_value", libgio), Ptr{GVariant}, (Ptr{GObject},), instance)
    ret2 = convert(GVariant, ret)
    ret2
end
function next(instance::GMenuAttributeIter)
    ret = ccall(("g_menu_attribute_iter_next", libgio), Cint, (Ptr{GObject},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function MenuItem_new(_label::Maybe(Union{AbstractString, Symbol}), _detailed_action::Maybe(Union{AbstractString, Symbol}))
    _label_maybe = nothing_to_null(_label)
    _detailed_action_maybe = nothing_to_null(_detailed_action)
    ret = ccall(("g_menu_item_new", libgio), Ptr{GObject}, (Cstring, Cstring), _label_maybe, _detailed_action_maybe)
    ret2 = GMenuItemLeaf(ret, true)
    ret2
end
function MenuItem_new_from_model(_model::GMenuModel, _item_index::Integer)
    ret = ccall(("g_menu_item_new_from_model", libgio), Ptr{GObject}, (Ptr{GObject}, Int32), _model, _item_index)
    ret2 = GMenuItemLeaf(ret, true)
    ret2
end
function MenuItem_new_section(_label::Maybe(Union{AbstractString, Symbol}), _section::GMenuModel)
    _label_maybe = nothing_to_null(_label)
    ret = ccall(("g_menu_item_new_section", libgio), Ptr{GObject}, (Cstring, Ptr{GObject}), _label_maybe, _section)
    ret2 = GMenuItemLeaf(ret, true)
    ret2
end
function MenuItem_new_submenu(_label::Maybe(Union{AbstractString, Symbol}), _submenu::GMenuModel)
    _label_maybe = nothing_to_null(_label)
    ret = ccall(("g_menu_item_new_submenu", libgio), Ptr{GObject}, (Cstring, Ptr{GObject}), _label_maybe, _submenu)
    ret2 = GMenuItemLeaf(ret, true)
    ret2
end
function get_attribute_value(instance::GMenuItem, _attribute::Union{AbstractString, Symbol}, _expected_type::Maybe(GVariantType))
    _expected_type_maybe = nothing_to_null(_expected_type)
    ret = ccall(("g_menu_item_get_attribute_value", libgio), Ptr{GVariant}, (Ptr{GObject}, Cstring, Ptr{GVariantType}), instance, _attribute, _expected_type_maybe)
    ret2 = convert(GVariant, ret)
    ret2
end
function get_link(instance::GMenuItem, _link::Union{AbstractString, Symbol})
    ret = ccall(("g_menu_item_get_link", libgio), Ptr{GObject}, (Ptr{GObject}, Cstring), instance, _link)
    ret2 = convert_if_not_null(GMenuModel, ret, true)
    ret2
end
function set_action_and_target_value(instance::GMenuItem, _action::Maybe(Union{AbstractString, Symbol}), _target_value::Maybe(GVariant))
    _action_maybe = nothing_to_null(_action)
    _target_value_maybe = nothing_to_null(_target_value)
    ret = ccall(("g_menu_item_set_action_and_target_value", libgio), Nothing, (Ptr{GObject}, Cstring, Ptr{GVariant}), instance, _action_maybe, _target_value_maybe)
    nothing
end
function set_attribute_value(instance::GMenuItem, _attribute::Union{AbstractString, Symbol}, _value::Maybe(GVariant))
    _value_maybe = nothing_to_null(_value)
    ret = ccall(("g_menu_item_set_attribute_value", libgio), Nothing, (Ptr{GObject}, Cstring, Ptr{GVariant}), instance, _attribute, _value_maybe)
    nothing
end
function set_detailed_action(instance::GMenuItem, _detailed_action::Union{AbstractString, Symbol})
    ret = ccall(("g_menu_item_set_detailed_action", libgio), Nothing, (Ptr{GObject}, Cstring), instance, _detailed_action)
    nothing
end
function set_icon(instance::GMenuItem, _icon::GIcon)
    ret = ccall(("g_menu_item_set_icon", libgio), Nothing, (Ptr{GObject}, Ptr{GObject}), instance, _icon)
    nothing
end
function set_label(instance::GMenuItem, _label::Maybe(Union{AbstractString, Symbol}))
    _label_maybe = nothing_to_null(_label)
    ret = ccall(("g_menu_item_set_label", libgio), Nothing, (Ptr{GObject}, Cstring), instance, _label_maybe)
    nothing
end
function set_link(instance::GMenuItem, _link::Union{AbstractString, Symbol}, _model::Maybe(GMenuModel))
    _model_maybe = nothing_to_null(_model)
    ret = ccall(("g_menu_item_set_link", libgio), Nothing, (Ptr{GObject}, Cstring, Ptr{GObject}), instance, _link, _model_maybe)
    nothing
end
function set_section(instance::GMenuItem, _section::Maybe(GMenuModel))
    _section_maybe = nothing_to_null(_section)
    ret = ccall(("g_menu_item_set_section", libgio), Nothing, (Ptr{GObject}, Ptr{GObject}), instance, _section_maybe)
    nothing
end
function set_submenu(instance::GMenuItem, _submenu::Maybe(GMenuModel))
    _submenu_maybe = nothing_to_null(_submenu)
    ret = ccall(("g_menu_item_set_submenu", libgio), Nothing, (Ptr{GObject}, Ptr{GObject}), instance, _submenu_maybe)
    nothing
end
function get_name(instance::GMenuLinkIter)
    ret = ccall(("g_menu_link_iter_get_name", libgio), Cstring, (Ptr{GObject},), instance)
    ret2 = string_or_nothing(ret, false)
    ret2
end
function get_next(instance::GMenuLinkIter)
    m_out_link = Ref{Cstring}()
    m_value = Ref{Ptr{GObject}}()
    ret = ccall(("g_menu_link_iter_get_next", libgio), Cint, (Ptr{GObject}, Ptr{Cstring}, Ptr{Ptr{GObject}}), instance, m_out_link, m_value)
    ret2 = convert(Bool, ret)
    _out_link = m_out_link[]
    _out_link = string_or_nothing(_out_link, false)
    _value = m_value[]
    _value = convert(GMenuModel, _value, true)
    (ret2, _out_link, _value)
end
function get_value(instance::GMenuLinkIter)
    ret = ccall(("g_menu_link_iter_get_value", libgio), Ptr{GObject}, (Ptr{GObject},), instance)
    ret2 = convert(GMenuModel, ret, true)
    ret2
end
function next(instance::GMenuLinkIter)
    ret = ccall(("g_menu_link_iter_next", libgio), Cint, (Ptr{GObject},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function get_item_attribute_value(instance::GMenuModel, _item_index::Integer, _attribute::Union{AbstractString, Symbol}, _expected_type::Maybe(GVariantType))
    _expected_type_maybe = nothing_to_null(_expected_type)
    ret = ccall(("g_menu_model_get_item_attribute_value", libgio), Ptr{GVariant}, (Ptr{GObject}, Int32, Cstring, Ptr{GVariantType}), instance, _item_index, _attribute, _expected_type_maybe)
    ret2 = convert(GVariant, ret)
    ret2
end
function get_item_link(instance::GMenuModel, _item_index::Integer, _link::Union{AbstractString, Symbol})
    ret = ccall(("g_menu_model_get_item_link", libgio), Ptr{GObject}, (Ptr{GObject}, Int32, Cstring), instance, _item_index, _link)
    ret2 = convert_if_not_null(GMenuModel, ret, true)
    ret2
end
function get_n_items(instance::GMenuModel)
    ret = ccall(("g_menu_model_get_n_items", libgio), Int32, (Ptr{GObject},), instance)
    ret
end
function is_mutable(instance::GMenuModel)
    ret = ccall(("g_menu_model_is_mutable", libgio), Cint, (Ptr{GObject},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function items_changed(instance::GMenuModel, _position::Integer, _removed::Integer, _added::Integer)
    ret = ccall(("g_menu_model_items_changed", libgio), Nothing, (Ptr{GObject}, Int32, Int32, Int32), instance, _position, _removed, _added)
    nothing
end
function iterate_item_attributes(instance::GMenuModel, _item_index::Integer)
    ret = ccall(("g_menu_model_iterate_item_attributes", libgio), Ptr{GObject}, (Ptr{GObject}, Int32), instance, _item_index)
    ret2 = convert(GMenuAttributeIter, ret, true)
    ret2
end
function iterate_item_links(instance::GMenuModel, _item_index::Integer)
    ret = ccall(("g_menu_model_iterate_item_links", libgio), Ptr{GObject}, (Ptr{GObject}, Int32), instance, _item_index)
    ret2 = convert(GMenuLinkIter, ret, true)
    ret2
end
function MountOperation_new()
    ret = ccall(("g_mount_operation_new", libgio), Ptr{GObject}, ())
    ret2 = GMountOperationLeaf(ret, true)
    ret2
end
function get_anonymous(instance::GMountOperation)
    ret = ccall(("g_mount_operation_get_anonymous", libgio), Cint, (Ptr{GObject},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function get_choice(instance::GMountOperation)
    ret = ccall(("g_mount_operation_get_choice", libgio), Int32, (Ptr{GObject},), instance)
    ret
end
function get_domain(instance::GMountOperation)
    ret = ccall(("g_mount_operation_get_domain", libgio), Cstring, (Ptr{GObject},), instance)
    ret2 = string_or_nothing(ret, false)
    ret2
end
function get_is_tcrypt_hidden_volume(instance::GMountOperation)
    ret = ccall(("g_mount_operation_get_is_tcrypt_hidden_volume", libgio), Cint, (Ptr{GObject},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function get_is_tcrypt_system_volume(instance::GMountOperation)
    ret = ccall(("g_mount_operation_get_is_tcrypt_system_volume", libgio), Cint, (Ptr{GObject},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function get_password(instance::GMountOperation)
    ret = ccall(("g_mount_operation_get_password", libgio), Cstring, (Ptr{GObject},), instance)
    ret2 = string_or_nothing(ret, false)
    ret2
end
function get_password_save(instance::GMountOperation)
    ret = ccall(("g_mount_operation_get_password_save", libgio), UInt32, (Ptr{GObject},), instance)
    ret2 = PasswordSave(ret)
    ret2
end
function get_pim(instance::GMountOperation)
    ret = ccall(("g_mount_operation_get_pim", libgio), UInt32, (Ptr{GObject},), instance)
    ret
end
function get_username(instance::GMountOperation)
    ret = ccall(("g_mount_operation_get_username", libgio), Cstring, (Ptr{GObject},), instance)
    ret2 = string_or_nothing(ret, false)
    ret2
end
function reply(instance::GMountOperation, _result)
    ret = ccall(("g_mount_operation_reply", libgio), Nothing, (Ptr{GObject}, UInt32), instance, _result)
    nothing
end
function set_anonymous(instance::GMountOperation, _anonymous::Bool)
    ret = ccall(("g_mount_operation_set_anonymous", libgio), Nothing, (Ptr{GObject}, Cint), instance, _anonymous)
    nothing
end
function set_choice(instance::GMountOperation, _choice::Integer)
    ret = ccall(("g_mount_operation_set_choice", libgio), Nothing, (Ptr{GObject}, Int32), instance, _choice)
    nothing
end
function set_domain(instance::GMountOperation, _domain::Maybe(Union{AbstractString, Symbol}))
    _domain_maybe = nothing_to_null(_domain)
    ret = ccall(("g_mount_operation_set_domain", libgio), Nothing, (Ptr{GObject}, Cstring), instance, _domain_maybe)
    nothing
end
function set_is_tcrypt_hidden_volume(instance::GMountOperation, _hidden_volume::Bool)
    ret = ccall(("g_mount_operation_set_is_tcrypt_hidden_volume", libgio), Nothing, (Ptr{GObject}, Cint), instance, _hidden_volume)
    nothing
end
function set_is_tcrypt_system_volume(instance::GMountOperation, _system_volume::Bool)
    ret = ccall(("g_mount_operation_set_is_tcrypt_system_volume", libgio), Nothing, (Ptr{GObject}, Cint), instance, _system_volume)
    nothing
end
function set_password(instance::GMountOperation, _password::Maybe(Union{AbstractString, Symbol}))
    _password_maybe = nothing_to_null(_password)
    ret = ccall(("g_mount_operation_set_password", libgio), Nothing, (Ptr{GObject}, Cstring), instance, _password_maybe)
    nothing
end
function set_password_save(instance::GMountOperation, _save)
    ret = ccall(("g_mount_operation_set_password_save", libgio), Nothing, (Ptr{GObject}, UInt32), instance, _save)
    nothing
end
function set_pim(instance::GMountOperation, _pim::Integer)
    ret = ccall(("g_mount_operation_set_pim", libgio), Nothing, (Ptr{GObject}, UInt32), instance, _pim)
    nothing
end
function set_username(instance::GMountOperation, _username::Maybe(Union{AbstractString, Symbol}))
    _username_maybe = nothing_to_null(_username)
    ret = ccall(("g_mount_operation_set_username", libgio), Nothing, (Ptr{GObject}, Cstring), instance, _username_maybe)
    nothing
end
function NativeSocketAddress_new(_native::Maybe(Nothing), _len::Integer)
    _native_maybe = nothing_to_null(_native)
    ret = ccall(("g_native_socket_address_new", libgio), Ptr{GObject}, (Ptr{Nothing}, UInt64), _native_maybe, _len)
    ret2 = GNativeSocketAddressLeaf(ret, true)
    ret2
end
function enumerate(instance::GNativeSocketAddress)
    enumerate(GSocketConnectable(instance))
end
function proxy_enumerate(instance::GNativeSocketAddress)
    proxy_enumerate(GSocketConnectable(instance))
end
function to_string(instance::GNativeSocketAddress)
    to_string(GSocketConnectable(instance))
end
function NetworkAddress_new(_hostname::Union{AbstractString, Symbol}, _port::Integer)
    ret = ccall(("g_network_address_new", libgio), Ptr{GObject}, (Cstring, UInt16), _hostname, _port)
    ret2 = GNetworkAddressLeaf(ret, true)
    ret2
end
function NetworkAddress_new_loopback(_port::Integer)
    ret = ccall(("g_network_address_new_loopback", libgio), Ptr{GObject}, (UInt16,), _port)
    ret2 = GNetworkAddressLeaf(ret, true)
    ret2
end
function parse(_host_and_port::Union{AbstractString, Symbol}, _default_port::Integer)
    err = err_buf()
    ret = ccall(("g_network_address_parse", libgio), Ptr{GObject}, (Cstring, UInt16, Ptr{Ptr{GError}}), _host_and_port, _default_port, err)
    check_err(err)
    ret2 = convert(GNetworkAddress, ret, true)
    ret2
end
function parse_uri(_uri::Union{AbstractString, Symbol}, _default_port::Integer)
    err = err_buf()
    ret = ccall(("g_network_address_parse_uri", libgio), Ptr{GObject}, (Cstring, UInt16, Ptr{Ptr{GError}}), _uri, _default_port, err)
    check_err(err)
    ret2 = convert(GNetworkAddress, ret, true)
    ret2
end
function get_hostname(instance::GNetworkAddress)
    ret = ccall(("g_network_address_get_hostname", libgio), Cstring, (Ptr{GObject},), instance)
    ret2 = string_or_nothing(ret, false)
    ret2
end
function get_port(instance::GNetworkAddress)
    ret = ccall(("g_network_address_get_port", libgio), UInt16, (Ptr{GObject},), instance)
    ret
end
function get_scheme(instance::GNetworkAddress)
    ret = ccall(("g_network_address_get_scheme", libgio), Cstring, (Ptr{GObject},), instance)
    ret2 = string_or_nothing(ret, false)
    ret2
end
function enumerate(instance::GNetworkAddress)
    enumerate(GSocketConnectable(instance))
end
function proxy_enumerate(instance::GNetworkAddress)
    proxy_enumerate(GSocketConnectable(instance))
end
function to_string(instance::GNetworkAddress)
    to_string(GSocketConnectable(instance))
end
function NetworkService_new(_service::Union{AbstractString, Symbol}, _protocol::Union{AbstractString, Symbol}, _domain::Union{AbstractString, Symbol})
    ret = ccall(("g_network_service_new", libgio), Ptr{GObject}, (Cstring, Cstring, Cstring), _service, _protocol, _domain)
    ret2 = GNetworkServiceLeaf(ret, true)
    ret2
end
function get_domain(instance::GNetworkService)
    ret = ccall(("g_network_service_get_domain", libgio), Cstring, (Ptr{GObject},), instance)
    ret2 = string_or_nothing(ret, false)
    ret2
end
function get_protocol(instance::GNetworkService)
    ret = ccall(("g_network_service_get_protocol", libgio), Cstring, (Ptr{GObject},), instance)
    ret2 = string_or_nothing(ret, false)
    ret2
end
function get_scheme(instance::GNetworkService)
    ret = ccall(("g_network_service_get_scheme", libgio), Cstring, (Ptr{GObject},), instance)
    ret2 = string_or_nothing(ret, false)
    ret2
end
function get_service(instance::GNetworkService)
    ret = ccall(("g_network_service_get_service", libgio), Cstring, (Ptr{GObject},), instance)
    ret2 = string_or_nothing(ret, false)
    ret2
end
function set_scheme(instance::GNetworkService, _scheme::Union{AbstractString, Symbol})
    ret = ccall(("g_network_service_set_scheme", libgio), Nothing, (Ptr{GObject}, Cstring), instance, _scheme)
    nothing
end
function enumerate(instance::GNetworkService)
    enumerate(GSocketConnectable(instance))
end
function proxy_enumerate(instance::GNetworkService)
    proxy_enumerate(GSocketConnectable(instance))
end
function to_string(instance::GNetworkService)
    to_string(GSocketConnectable(instance))
end
function Notification_new(_title::Union{AbstractString, Symbol})
    ret = ccall(("g_notification_new", libgio), Ptr{GObject}, (Cstring,), _title)
    ret2 = GNotificationLeaf(ret, true)
    ret2
end
function add_button(instance::GNotification, _label::Union{AbstractString, Symbol}, _detailed_action::Union{AbstractString, Symbol})
    ret = ccall(("g_notification_add_button", libgio), Nothing, (Ptr{GObject}, Cstring, Cstring), instance, _label, _detailed_action)
    nothing
end
function add_button_with_target(instance::GNotification, _label::Union{AbstractString, Symbol}, _action::Union{AbstractString, Symbol}, _target::Maybe(GVariant))
    _target_maybe = nothing_to_null(_target)
    ret = ccall(("g_notification_add_button_with_target_value", libgio), Nothing, (Ptr{GObject}, Cstring, Cstring, Ptr{GVariant}), instance, _label, _action, _target_maybe)
    nothing
end
function set_body(instance::GNotification, _body::Maybe(Union{AbstractString, Symbol}))
    _body_maybe = nothing_to_null(_body)
    ret = ccall(("g_notification_set_body", libgio), Nothing, (Ptr{GObject}, Cstring), instance, _body_maybe)
    nothing
end
function set_category(instance::GNotification, _category::Maybe(Union{AbstractString, Symbol}))
    _category_maybe = nothing_to_null(_category)
    ret = ccall(("g_notification_set_category", libgio), Nothing, (Ptr{GObject}, Cstring), instance, _category_maybe)
    nothing
end
function set_default_action(instance::GNotification, _detailed_action::Union{AbstractString, Symbol})
    ret = ccall(("g_notification_set_default_action", libgio), Nothing, (Ptr{GObject}, Cstring), instance, _detailed_action)
    nothing
end
function set_default_action_and_target(instance::GNotification, _action::Union{AbstractString, Symbol}, _target::Maybe(GVariant))
    _target_maybe = nothing_to_null(_target)
    ret = ccall(("g_notification_set_default_action_and_target_value", libgio), Nothing, (Ptr{GObject}, Cstring, Ptr{GVariant}), instance, _action, _target_maybe)
    nothing
end
function set_icon(instance::GNotification, _icon::GIcon)
    ret = ccall(("g_notification_set_icon", libgio), Nothing, (Ptr{GObject}, Ptr{GObject}), instance, _icon)
    nothing
end
function set_priority(instance::GNotification, _priority)
    ret = ccall(("g_notification_set_priority", libgio), Nothing, (Ptr{GObject}, UInt32), instance, _priority)
    nothing
end
function set_title(instance::GNotification, _title::Union{AbstractString, Symbol})
    ret = ccall(("g_notification_set_title", libgio), Nothing, (Ptr{GObject}, Cstring), instance, _title)
    nothing
end
function clear_pending(instance::GOutputStream)
    ret = ccall(("g_output_stream_clear_pending", libgio), Nothing, (Ptr{GObject},), instance)
    nothing
end
function close(instance::GOutputStream, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_output_stream_close", libgio), Cint, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _cancellable_maybe, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function close_async(instance::GOutputStream, _io_priority::Integer, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    ret = ccall(("g_output_stream_close_async", libgio), Nothing, (Ptr{GObject}, Int32, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _io_priority, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function close_finish(instance::GOutputStream, _result::GAsyncResult)
    err = err_buf()
    ret = ccall(("g_output_stream_close_finish", libgio), Cint, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _result, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function flush(instance::GOutputStream, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_output_stream_flush", libgio), Cint, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _cancellable_maybe, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function flush_async(instance::GOutputStream, _io_priority::Integer, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    ret = ccall(("g_output_stream_flush_async", libgio), Nothing, (Ptr{GObject}, Int32, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _io_priority, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function flush_finish(instance::GOutputStream, _result::GAsyncResult)
    err = err_buf()
    ret = ccall(("g_output_stream_flush_finish", libgio), Cint, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _result, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function has_pending(instance::GOutputStream)
    ret = ccall(("g_output_stream_has_pending", libgio), Cint, (Ptr{GObject},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function is_closed(instance::GOutputStream)
    ret = ccall(("g_output_stream_is_closed", libgio), Cint, (Ptr{GObject},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function is_closing(instance::GOutputStream)
    ret = ccall(("g_output_stream_is_closing", libgio), Cint, (Ptr{GObject},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function set_pending(instance::GOutputStream)
    err = err_buf()
    ret = ccall(("g_output_stream_set_pending", libgio), Cint, (Ptr{GObject}, Ptr{Ptr{GError}}), instance, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function splice(instance::GOutputStream, _source::GInputStream, _flags, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_output_stream_splice", libgio), Int64, (Ptr{GObject}, Ptr{GObject}, UInt32, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _source, _flags, _cancellable_maybe, err)
    check_err(err)
    ret
end
function splice_async(instance::GOutputStream, _source::GInputStream, _flags, _io_priority::Integer, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    ret = ccall(("g_output_stream_splice_async", libgio), Nothing, (Ptr{GObject}, Ptr{GObject}, UInt32, Int32, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _source, _flags, _io_priority, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function splice_finish(instance::GOutputStream, _result::GAsyncResult)
    err = err_buf()
    ret = ccall(("g_output_stream_splice_finish", libgio), Int64, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _result, err)
    check_err(err)
    ret
end
function write(instance::GOutputStream, _buffer, _cancellable::Maybe(GCancellable))
    _buffer_arr = convert(Vector{UInt8}, _buffer)
    _cancellable_maybe = nothing_to_null(_cancellable)
    _count = length(_buffer)
    err = err_buf()
    ret = ccall(("g_output_stream_write", libgio), Int64, (Ptr{GObject}, Ptr{UInt8}, UInt64, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _buffer_arr, _count, _cancellable_maybe, err)
    check_err(err)
    ret
end
function write_all(instance::GOutputStream, _buffer, _cancellable::Maybe(GCancellable))
    _buffer_arr = convert(Vector{UInt8}, _buffer)
    m_bytes_written = Ref{UInt64}()
    _cancellable_maybe = nothing_to_null(_cancellable)
    _count = length(_buffer)
    err = err_buf()
    ret = ccall(("g_output_stream_write_all", libgio), Cint, (Ptr{GObject}, Ptr{UInt8}, UInt64, Ptr{UInt64}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _buffer_arr, _count, m_bytes_written, _cancellable_maybe, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    _bytes_written = m_bytes_written[]
    (ret2, _bytes_written)
end
function write_all_async(instance::GOutputStream, _buffer, _io_priority::Integer, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _buffer_arr = convert(Vector{UInt8}, _buffer)
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    _count = length(_buffer)
    ret = ccall(("g_output_stream_write_all_async", libgio), Nothing, (Ptr{GObject}, Ptr{UInt8}, UInt64, Int32, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _buffer_arr, _count, _io_priority, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function write_all_finish(instance::GOutputStream, _result::GAsyncResult)
    m_bytes_written = Ref{UInt64}()
    err = err_buf()
    ret = ccall(("g_output_stream_write_all_finish", libgio), Cint, (Ptr{GObject}, Ptr{GObject}, Ptr{UInt64}, Ptr{Ptr{GError}}), instance, _result, m_bytes_written, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    _bytes_written = m_bytes_written[]
    (ret2, _bytes_written)
end
function write_async(instance::GOutputStream, _buffer, _io_priority::Integer, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _buffer_arr = convert(Vector{UInt8}, _buffer)
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    _count = length(_buffer)
    ret = ccall(("g_output_stream_write_async", libgio), Nothing, (Ptr{GObject}, Ptr{UInt8}, UInt64, Int32, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _buffer_arr, _count, _io_priority, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function write_bytes(instance::GOutputStream, _bytes::GBytes, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_output_stream_write_bytes", libgio), Int64, (Ptr{GObject}, Ptr{GBytes}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _bytes, _cancellable_maybe, err)
    check_err(err)
    ret
end
function write_bytes_async(instance::GOutputStream, _bytes::GBytes, _io_priority::Integer, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    ret = ccall(("g_output_stream_write_bytes_async", libgio), Nothing, (Ptr{GObject}, Ptr{GBytes}, Int32, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _bytes, _io_priority, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function write_bytes_finish(instance::GOutputStream, _result::GAsyncResult)
    err = err_buf()
    ret = ccall(("g_output_stream_write_bytes_finish", libgio), Int64, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _result, err)
    check_err(err)
    ret
end
function write_finish(instance::GOutputStream, _result::GAsyncResult)
    err = err_buf()
    ret = ccall(("g_output_stream_write_finish", libgio), Int64, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _result, err)
    check_err(err)
    ret
end
function writev_all_async(instance::GOutputStream, _vectors, _io_priority::Integer, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _vectors_arr = convert(Vector{_GOutputVector}, _vectors)
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    _n_vectors = length(_vectors)
    ret = ccall(("g_output_stream_writev_all_async", libgio), Nothing, (Ptr{GObject}, Ptr{_GOutputVector}, UInt64, Int32, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _vectors_arr, _n_vectors, _io_priority, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function writev_all_finish(instance::GOutputStream, _result::GAsyncResult)
    m_bytes_written = Ref{UInt64}()
    err = err_buf()
    ret = ccall(("g_output_stream_writev_all_finish", libgio), Cint, (Ptr{GObject}, Ptr{GObject}, Ptr{UInt64}, Ptr{Ptr{GError}}), instance, _result, m_bytes_written, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    _bytes_written = m_bytes_written[]
    (ret2, _bytes_written)
end
function writev_async(instance::GOutputStream, _vectors, _io_priority::Integer, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _vectors_arr = convert(Vector{_GOutputVector}, _vectors)
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    _n_vectors = length(_vectors)
    ret = ccall(("g_output_stream_writev_async", libgio), Nothing, (Ptr{GObject}, Ptr{_GOutputVector}, UInt64, Int32, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _vectors_arr, _n_vectors, _io_priority, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function writev_finish(instance::GOutputStream, _result::GAsyncResult)
    m_bytes_written = Ref{UInt64}()
    err = err_buf()
    ret = ccall(("g_output_stream_writev_finish", libgio), Cint, (Ptr{GObject}, Ptr{GObject}, Ptr{UInt64}, Ptr{Ptr{GError}}), instance, _result, m_bytes_written, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    _bytes_written = m_bytes_written[]
    (ret2, _bytes_written)
end
function acquire(instance::GPermission, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_permission_acquire", libgio), Cint, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _cancellable_maybe, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function acquire_async(instance::GPermission, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    ret = ccall(("g_permission_acquire_async", libgio), Nothing, (Ptr{GObject}, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function acquire_finish(instance::GPermission, _result::GAsyncResult)
    err = err_buf()
    ret = ccall(("g_permission_acquire_finish", libgio), Cint, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _result, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function get_allowed(instance::GPermission)
    ret = ccall(("g_permission_get_allowed", libgio), Cint, (Ptr{GObject},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function get_can_acquire(instance::GPermission)
    ret = ccall(("g_permission_get_can_acquire", libgio), Cint, (Ptr{GObject},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function get_can_release(instance::GPermission)
    ret = ccall(("g_permission_get_can_release", libgio), Cint, (Ptr{GObject},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function impl_update(instance::GPermission, _allowed::Bool, _can_acquire::Bool, _can_release::Bool)
    ret = ccall(("g_permission_impl_update", libgio), Nothing, (Ptr{GObject}, Cint, Cint, Cint), instance, _allowed, _can_acquire, _can_release)
    nothing
end
function release(instance::GPermission, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_permission_release", libgio), Cint, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _cancellable_maybe, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function release_async(instance::GPermission, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    ret = ccall(("g_permission_release_async", libgio), Nothing, (Ptr{GObject}, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function release_finish(instance::GPermission, _result::GAsyncResult)
    err = err_buf()
    ret = ccall(("g_permission_release_finish", libgio), Cint, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _result, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function PropertyAction_new(_name::Union{AbstractString, Symbol}, _object::GObject, _property_name::Union{AbstractString, Symbol})
    ret = ccall(("g_property_action_new", libgio), Ptr{GObject}, (Cstring, Ptr{GObject}, Cstring), _name, _object, _property_name)
    ret2 = GPropertyActionLeaf(ret, true)
    ret2
end
function activate(instance::GPropertyAction, _parameter::Maybe(GVariant))
    activate(GAction(instance), _parameter)
end
function change_state(instance::GPropertyAction, _value::GVariant)
    change_state(GAction(instance), _value)
end
function get_enabled(instance::GPropertyAction)
    get_enabled(GAction(instance))
end
function get_name(instance::GPropertyAction)
    get_name(GAction(instance))
end
function get_parameter_type(instance::GPropertyAction)
    get_parameter_type(GAction(instance))
end
function get_state(instance::GPropertyAction)
    get_state(GAction(instance))
end
function get_state_hint(instance::GPropertyAction)
    get_state_hint(GAction(instance))
end
function get_state_type(instance::GPropertyAction)
    get_state_type(GAction(instance))
end
function ProxyAddress_new(_inetaddr::GInetAddress, _port::Integer, _protocol::Union{AbstractString, Symbol}, _dest_hostname::Union{AbstractString, Symbol}, _dest_port::Integer, _username::Maybe(Union{AbstractString, Symbol}), _password::Maybe(Union{AbstractString, Symbol}))
    _username_maybe = nothing_to_null(_username)
    _password_maybe = nothing_to_null(_password)
    ret = ccall(("g_proxy_address_new", libgio), Ptr{GObject}, (Ptr{GObject}, UInt16, Cstring, Cstring, UInt16, Cstring, Cstring), _inetaddr, _port, _protocol, _dest_hostname, _dest_port, _username_maybe, _password_maybe)
    ret2 = GProxyAddressLeaf(ret, true)
    ret2
end
function get_destination_hostname(instance::GProxyAddress)
    ret = ccall(("g_proxy_address_get_destination_hostname", libgio), Cstring, (Ptr{GObject},), instance)
    ret2 = string_or_nothing(ret, false)
    ret2
end
function get_destination_port(instance::GProxyAddress)
    ret = ccall(("g_proxy_address_get_destination_port", libgio), UInt16, (Ptr{GObject},), instance)
    ret
end
function get_destination_protocol(instance::GProxyAddress)
    ret = ccall(("g_proxy_address_get_destination_protocol", libgio), Cstring, (Ptr{GObject},), instance)
    ret2 = string_or_nothing(ret, false)
    ret2
end
function get_password(instance::GProxyAddress)
    ret = ccall(("g_proxy_address_get_password", libgio), Cstring, (Ptr{GObject},), instance)
    ret2 = string_or_nothing(ret, false)
    ret2
end
function get_protocol(instance::GProxyAddress)
    ret = ccall(("g_proxy_address_get_protocol", libgio), Cstring, (Ptr{GObject},), instance)
    ret2 = string_or_nothing(ret, false)
    ret2
end
function get_uri(instance::GProxyAddress)
    ret = ccall(("g_proxy_address_get_uri", libgio), Cstring, (Ptr{GObject},), instance)
    ret2 = string_or_nothing(ret, false)
    ret2
end
function get_username(instance::GProxyAddress)
    ret = ccall(("g_proxy_address_get_username", libgio), Cstring, (Ptr{GObject},), instance)
    ret2 = string_or_nothing(ret, false)
    ret2
end
function enumerate(instance::GProxyAddress)
    enumerate(GSocketConnectable(instance))
end
function proxy_enumerate(instance::GProxyAddress)
    proxy_enumerate(GSocketConnectable(instance))
end
function to_string(instance::GProxyAddress)
    to_string(GSocketConnectable(instance))
end
function get_timeout(instance::GResolver)
    ret = ccall(("g_resolver_get_timeout", libgio), UInt32, (Ptr{GObject},), instance)
    ret
end
function lookup_by_address(instance::GResolver, _address::GInetAddress, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_resolver_lookup_by_address", libgio), Cstring, (Ptr{GObject}, Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _address, _cancellable_maybe, err)
    check_err(err)
    ret2 = string_or_nothing(ret, true)
    ret2
end
function lookup_by_address_async(instance::GResolver, _address::GInetAddress, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    ret = ccall(("g_resolver_lookup_by_address_async", libgio), Nothing, (Ptr{GObject}, Ptr{GObject}, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _address, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function lookup_by_address_finish(instance::GResolver, _result::GAsyncResult)
    err = err_buf()
    ret = ccall(("g_resolver_lookup_by_address_finish", libgio), Cstring, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _result, err)
    check_err(err)
    ret2 = string_or_nothing(ret, true)
    ret2
end
function lookup_by_name(instance::GResolver, _hostname::Union{AbstractString, Symbol}, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_resolver_lookup_by_name", libgio), Ptr{GLib._GList{Ptr{GObject}}}, (Ptr{GObject}, Cstring, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _hostname, _cancellable_maybe, err)
    check_err(err)
    ret2 = GLib.GList(ret, true)
    ret2
end
function lookup_by_name_async(instance::GResolver, _hostname::Union{AbstractString, Symbol}, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    ret = ccall(("g_resolver_lookup_by_name_async", libgio), Nothing, (Ptr{GObject}, Cstring, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _hostname, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function lookup_by_name_finish(instance::GResolver, _result::GAsyncResult)
    err = err_buf()
    ret = ccall(("g_resolver_lookup_by_name_finish", libgio), Ptr{GLib._GList{Ptr{GObject}}}, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _result, err)
    check_err(err)
    ret2 = GLib.GList(ret, true)
    ret2
end
function lookup_by_name_with_flags(instance::GResolver, _hostname::Union{AbstractString, Symbol}, _flags, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_resolver_lookup_by_name_with_flags", libgio), Ptr{GLib._GList{Ptr{GObject}}}, (Ptr{GObject}, Cstring, UInt32, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _hostname, _flags, _cancellable_maybe, err)
    check_err(err)
    ret2 = GLib.GList(ret, true)
    ret2
end
function lookup_by_name_with_flags_async(instance::GResolver, _hostname::Union{AbstractString, Symbol}, _flags, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    ret = ccall(("g_resolver_lookup_by_name_with_flags_async", libgio), Nothing, (Ptr{GObject}, Cstring, UInt32, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _hostname, _flags, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function lookup_by_name_with_flags_finish(instance::GResolver, _result::GAsyncResult)
    err = err_buf()
    ret = ccall(("g_resolver_lookup_by_name_with_flags_finish", libgio), Ptr{GLib._GList{Ptr{GObject}}}, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _result, err)
    check_err(err)
    ret2 = GLib.GList(ret, true)
    ret2
end
function lookup_records(instance::GResolver, _rrname::Union{AbstractString, Symbol}, _record_type, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_resolver_lookup_records", libgio), Ptr{GLib._GList{GVariant}}, (Ptr{GObject}, Cstring, UInt32, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _rrname, _record_type, _cancellable_maybe, err)
    check_err(err)
    ret2 = GLib.GList(ret, true)
    ret2
end
function lookup_records_async(instance::GResolver, _rrname::Union{AbstractString, Symbol}, _record_type, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    ret = ccall(("g_resolver_lookup_records_async", libgio), Nothing, (Ptr{GObject}, Cstring, UInt32, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _rrname, _record_type, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function lookup_records_finish(instance::GResolver, _result::GAsyncResult)
    err = err_buf()
    ret = ccall(("g_resolver_lookup_records_finish", libgio), Ptr{GLib._GList{GVariant}}, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _result, err)
    check_err(err)
    ret2 = GLib.GList(ret, true)
    ret2
end
function lookup_service(instance::GResolver, _service::Union{AbstractString, Symbol}, _protocol::Union{AbstractString, Symbol}, _domain::Union{AbstractString, Symbol}, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_resolver_lookup_service", libgio), Ptr{GLib._GList{GSrvTarget}}, (Ptr{GObject}, Cstring, Cstring, Cstring, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _service, _protocol, _domain, _cancellable_maybe, err)
    check_err(err)
    ret2 = GLib.GList(ret, true)
    ret2
end
function lookup_service_async(instance::GResolver, _service::Union{AbstractString, Symbol}, _protocol::Union{AbstractString, Symbol}, _domain::Union{AbstractString, Symbol}, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    ret = ccall(("g_resolver_lookup_service_async", libgio), Nothing, (Ptr{GObject}, Cstring, Cstring, Cstring, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _service, _protocol, _domain, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function lookup_service_finish(instance::GResolver, _result::GAsyncResult)
    err = err_buf()
    ret = ccall(("g_resolver_lookup_service_finish", libgio), Ptr{GLib._GList{GSrvTarget}}, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _result, err)
    check_err(err)
    ret2 = GLib.GList(ret, true)
    ret2
end
function set_default(instance::GResolver)
    ret = ccall(("g_resolver_set_default", libgio), Nothing, (Ptr{GObject},), instance)
    nothing
end
function set_timeout(instance::GResolver, _timeout_ms::Integer)
    ret = ccall(("g_resolver_set_timeout", libgio), Nothing, (Ptr{GObject}, UInt32), instance, _timeout_ms)
    nothing
end
function Settings_new(_schema_id::Union{AbstractString, Symbol})
    ret = ccall(("g_settings_new", libgio), Ptr{GObject}, (Cstring,), _schema_id)
    ret2 = GSettingsLeaf(ret, true)
    ret2
end
function Settings_new_full(_schema::GSettingsSchema, _backend::Maybe(GSettingsBackend), _path::Maybe(Union{AbstractString, Symbol}))
    _backend_maybe = nothing_to_null(_backend)
    _path_maybe = nothing_to_null(_path)
    ret = ccall(("g_settings_new_full", libgio), Ptr{GObject}, (Ptr{GSettingsSchema}, Ptr{GObject}, Cstring), _schema, _backend_maybe, _path_maybe)
    ret2 = GSettingsLeaf(ret, true)
    ret2
end
function Settings_new_with_backend(_schema_id::Union{AbstractString, Symbol}, _backend::GSettingsBackend)
    ret = ccall(("g_settings_new_with_backend", libgio), Ptr{GObject}, (Cstring, Ptr{GObject}), _schema_id, _backend)
    ret2 = GSettingsLeaf(ret, true)
    ret2
end
function Settings_new_with_backend_and_path(_schema_id::Union{AbstractString, Symbol}, _backend::GSettingsBackend, _path::Union{AbstractString, Symbol})
    ret = ccall(("g_settings_new_with_backend_and_path", libgio), Ptr{GObject}, (Cstring, Ptr{GObject}, Cstring), _schema_id, _backend, _path)
    ret2 = GSettingsLeaf(ret, true)
    ret2
end
function Settings_new_with_path(_schema_id::Union{AbstractString, Symbol}, _path::Union{AbstractString, Symbol})
    ret = ccall(("g_settings_new_with_path", libgio), Ptr{GObject}, (Cstring, Cstring), _schema_id, _path)
    ret2 = GSettingsLeaf(ret, true)
    ret2
end
function sync()
    ret = ccall(("g_settings_sync", libgio), Nothing, ())
    nothing
end
function unbind(_object::GObject, _property::Union{AbstractString, Symbol})
    ret = ccall(("g_settings_unbind", libgio), Nothing, (Ptr{GObject}, Cstring), _object, _property)
    nothing
end
function apply(instance::GSettings)
    ret = ccall(("g_settings_apply", libgio), Nothing, (Ptr{GObject},), instance)
    nothing
end
function bind(instance::GSettings, _key::Union{AbstractString, Symbol}, _object::GObject, _property::Union{AbstractString, Symbol}, _flags)
    ret = ccall(("g_settings_bind", libgio), Nothing, (Ptr{GObject}, Cstring, Ptr{GObject}, Cstring, UInt32), instance, _key, _object, _property, _flags)
    nothing
end
function bind_writable(instance::GSettings, _key::Union{AbstractString, Symbol}, _object::GObject, _property::Union{AbstractString, Symbol}, _inverted::Bool)
    ret = ccall(("g_settings_bind_writable", libgio), Nothing, (Ptr{GObject}, Cstring, Ptr{GObject}, Cstring, Cint), instance, _key, _object, _property, _inverted)
    nothing
end
function create_action(instance::GSettings, _key::Union{AbstractString, Symbol})
    ret = ccall(("g_settings_create_action", libgio), Ptr{GObject}, (Ptr{GObject}, Cstring), instance, _key)
    ret2 = begin
            leaftype = GLib.find_leaf_type(ret)
            convert(leaftype, ret, true)
        end
    ret2
end
function delay(instance::GSettings)
    ret = ccall(("g_settings_delay", libgio), Nothing, (Ptr{GObject},), instance)
    nothing
end
function get_boolean(instance::GSettings, _key::Union{AbstractString, Symbol})
    ret = ccall(("g_settings_get_boolean", libgio), Cint, (Ptr{GObject}, Cstring), instance, _key)
    ret2 = convert(Bool, ret)
    ret2
end
function get_child(instance::GSettings, _name::Union{AbstractString, Symbol})
    ret = ccall(("g_settings_get_child", libgio), Ptr{GObject}, (Ptr{GObject}, Cstring), instance, _name)
    ret2 = convert(GSettings, ret, true)
    ret2
end
function get_default_value(instance::GSettings, _key::Union{AbstractString, Symbol})
    ret = ccall(("g_settings_get_default_value", libgio), Ptr{GVariant}, (Ptr{GObject}, Cstring), instance, _key)
    ret2 = convert(GVariant, ret)
    ret2
end
function get_double(instance::GSettings, _key::Union{AbstractString, Symbol})
    ret = ccall(("g_settings_get_double", libgio), Float64, (Ptr{GObject}, Cstring), instance, _key)
    ret
end
function get_enum(instance::GSettings, _key::Union{AbstractString, Symbol})
    ret = ccall(("g_settings_get_enum", libgio), Int32, (Ptr{GObject}, Cstring), instance, _key)
    ret
end
function get_flags(instance::GSettings, _key::Union{AbstractString, Symbol})
    ret = ccall(("g_settings_get_flags", libgio), UInt32, (Ptr{GObject}, Cstring), instance, _key)
    ret
end
function get_has_unapplied(instance::GSettings)
    ret = ccall(("g_settings_get_has_unapplied", libgio), Cint, (Ptr{GObject},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function get_int(instance::GSettings, _key::Union{AbstractString, Symbol})
    ret = ccall(("g_settings_get_int", libgio), Int32, (Ptr{GObject}, Cstring), instance, _key)
    ret
end
function get_int64(instance::GSettings, _key::Union{AbstractString, Symbol})
    ret = ccall(("g_settings_get_int64", libgio), Int64, (Ptr{GObject}, Cstring), instance, _key)
    ret
end
function get_mapped(instance::GSettings, _key::Union{AbstractString, Symbol}, _mapping::Function)
    begin
        _mapping_cfunc = @cfunction(GSettingsGetMapping, Cint, (Ptr{GVariant}, Ptr{Nothing}, Ref{Function}))
        begin
            ref = Ref{Any}(_mapping)
            _mapping_closure = unsafe_load(convert(Ptr{Ptr{Nothing}}, Base.unsafe_convert(Ptr{Any}, ref)))
        end
    end
    ret = ccall(("g_settings_get_mapped", libgio), Ptr{Nothing}, (Ptr{GObject}, Cstring, Ptr{Cvoid}, Ptr{Nothing}), instance, _key, _mapping_cfunc, _mapping_closure)
    ret2 = convert(Nothing, ret)
    ret2
end
function get_string(instance::GSettings, _key::Union{AbstractString, Symbol})
    ret = ccall(("g_settings_get_string", libgio), Cstring, (Ptr{GObject}, Cstring), instance, _key)
    ret2 = string_or_nothing(ret, true)
    ret2
end
function get_strv(instance::GSettings, _key::Union{AbstractString, Symbol})
    ret = ccall(("g_settings_get_strv", libgio), Ptr{Cstring}, (Ptr{GObject}, Cstring), instance, _key)
    ret2 = begin
            _len = length_zt(ret)
            arrtemp = bytestring.(unsafe_wrap(Vector{Cstring}, ret, _len))
            GLib.g_strfreev(ret)
            arrtemp
        end
    ret2
end
function get_uint(instance::GSettings, _key::Union{AbstractString, Symbol})
    ret = ccall(("g_settings_get_uint", libgio), UInt32, (Ptr{GObject}, Cstring), instance, _key)
    ret
end
function get_uint64(instance::GSettings, _key::Union{AbstractString, Symbol})
    ret = ccall(("g_settings_get_uint64", libgio), UInt64, (Ptr{GObject}, Cstring), instance, _key)
    ret
end
function get_user_value(instance::GSettings, _key::Union{AbstractString, Symbol})
    ret = ccall(("g_settings_get_user_value", libgio), Ptr{GVariant}, (Ptr{GObject}, Cstring), instance, _key)
    ret2 = convert(GVariant, ret)
    ret2
end
function get_value(instance::GSettings, _key::Union{AbstractString, Symbol})
    ret = ccall(("g_settings_get_value", libgio), Ptr{GVariant}, (Ptr{GObject}, Cstring), instance, _key)
    ret2 = convert(GVariant, ret)
    ret2
end
function is_writable(instance::GSettings, _name::Union{AbstractString, Symbol})
    ret = ccall(("g_settings_is_writable", libgio), Cint, (Ptr{GObject}, Cstring), instance, _name)
    ret2 = convert(Bool, ret)
    ret2
end
function list_children(instance::GSettings)
    ret = ccall(("g_settings_list_children", libgio), Ptr{Cstring}, (Ptr{GObject},), instance)
    ret2 = begin
            _len = length_zt(ret)
            arrtemp = bytestring.(unsafe_wrap(Vector{Cstring}, ret, _len))
            GLib.g_strfreev(ret)
            arrtemp
        end
    ret2
end
function reset(instance::GSettings, _key::Union{AbstractString, Symbol})
    ret = ccall(("g_settings_reset", libgio), Nothing, (Ptr{GObject}, Cstring), instance, _key)
    nothing
end
function revert(instance::GSettings)
    ret = ccall(("g_settings_revert", libgio), Nothing, (Ptr{GObject},), instance)
    nothing
end
function set_boolean(instance::GSettings, _key::Union{AbstractString, Symbol}, _value::Bool)
    ret = ccall(("g_settings_set_boolean", libgio), Cint, (Ptr{GObject}, Cstring, Cint), instance, _key, _value)
    ret2 = convert(Bool, ret)
    ret2
end
function set_double(instance::GSettings, _key::Union{AbstractString, Symbol}, _value::Real)
    ret = ccall(("g_settings_set_double", libgio), Cint, (Ptr{GObject}, Cstring, Float64), instance, _key, _value)
    ret2 = convert(Bool, ret)
    ret2
end
function set_enum(instance::GSettings, _key::Union{AbstractString, Symbol}, _value::Integer)
    ret = ccall(("g_settings_set_enum", libgio), Cint, (Ptr{GObject}, Cstring, Int32), instance, _key, _value)
    ret2 = convert(Bool, ret)
    ret2
end
function set_flags(instance::GSettings, _key::Union{AbstractString, Symbol}, _value::Integer)
    ret = ccall(("g_settings_set_flags", libgio), Cint, (Ptr{GObject}, Cstring, UInt32), instance, _key, _value)
    ret2 = convert(Bool, ret)
    ret2
end
function set_int(instance::GSettings, _key::Union{AbstractString, Symbol}, _value::Integer)
    ret = ccall(("g_settings_set_int", libgio), Cint, (Ptr{GObject}, Cstring, Int32), instance, _key, _value)
    ret2 = convert(Bool, ret)
    ret2
end
function set_int64(instance::GSettings, _key::Union{AbstractString, Symbol}, _value::Integer)
    ret = ccall(("g_settings_set_int64", libgio), Cint, (Ptr{GObject}, Cstring, Int64), instance, _key, _value)
    ret2 = convert(Bool, ret)
    ret2
end
function set_string(instance::GSettings, _key::Union{AbstractString, Symbol}, _value::Union{AbstractString, Symbol})
    ret = ccall(("g_settings_set_string", libgio), Cint, (Ptr{GObject}, Cstring, Cstring), instance, _key, _value)
    ret2 = convert(Bool, ret)
    ret2
end
function set_strv(instance::GSettings, _key::Union{AbstractString, Symbol}, _value)
    _value_maybe = nothing_to_null(_value)
    ret = ccall(("g_settings_set_strv", libgio), Cint, (Ptr{GObject}, Cstring, Ptr{Cstring}), instance, _key, _value_maybe)
    ret2 = convert(Bool, ret)
    ret2
end
function set_uint(instance::GSettings, _key::Union{AbstractString, Symbol}, _value::Integer)
    ret = ccall(("g_settings_set_uint", libgio), Cint, (Ptr{GObject}, Cstring, UInt32), instance, _key, _value)
    ret2 = convert(Bool, ret)
    ret2
end
function set_uint64(instance::GSettings, _key::Union{AbstractString, Symbol}, _value::Integer)
    ret = ccall(("g_settings_set_uint64", libgio), Cint, (Ptr{GObject}, Cstring, UInt64), instance, _key, _value)
    ret2 = convert(Bool, ret)
    ret2
end
function set_value(instance::GSettings, _key::Union{AbstractString, Symbol}, _value::GVariant)
    ret = ccall(("g_settings_set_value", libgio), Cint, (Ptr{GObject}, Cstring, Ptr{GVariant}), instance, _key, _value)
    ret2 = convert(Bool, ret)
    ret2
end
function changed(instance::GSettingsBackend, _key::Union{AbstractString, Symbol}, _origin_tag::Maybe(Nothing))
    _origin_tag_maybe = nothing_to_null(_origin_tag)
    ret = ccall(("g_settings_backend_changed", libgio), Nothing, (Ptr{GObject}, Cstring, Ptr{Nothing}), instance, _key, _origin_tag_maybe)
    nothing
end
function keys_changed(instance::GSettingsBackend, _path::Union{AbstractString, Symbol}, _items, _origin_tag::Maybe(Nothing))
    _origin_tag_maybe = nothing_to_null(_origin_tag)
    ret = ccall(("g_settings_backend_keys_changed", libgio), Nothing, (Ptr{GObject}, Cstring, Ptr{Cstring}, Ptr{Nothing}), instance, _path, _items, _origin_tag_maybe)
    nothing
end
function path_changed(instance::GSettingsBackend, _path::Union{AbstractString, Symbol}, _origin_tag::Maybe(Nothing))
    _origin_tag_maybe = nothing_to_null(_origin_tag)
    ret = ccall(("g_settings_backend_path_changed", libgio), Nothing, (Ptr{GObject}, Cstring, Ptr{Nothing}), instance, _path, _origin_tag_maybe)
    nothing
end
function path_writable_changed(instance::GSettingsBackend, _path::Union{AbstractString, Symbol})
    ret = ccall(("g_settings_backend_path_writable_changed", libgio), Nothing, (Ptr{GObject}, Cstring), instance, _path)
    nothing
end
function writable_changed(instance::GSettingsBackend, _key::Union{AbstractString, Symbol})
    ret = ccall(("g_settings_backend_writable_changed", libgio), Nothing, (Ptr{GObject}, Cstring), instance, _key)
    nothing
end
function SimpleAction_new(_name::Union{AbstractString, Symbol}, _parameter_type::Maybe(GVariantType))
    _parameter_type_maybe = nothing_to_null(_parameter_type)
    ret = ccall(("g_simple_action_new", libgio), Ptr{GObject}, (Cstring, Ptr{GVariantType}), _name, _parameter_type_maybe)
    ret2 = GSimpleActionLeaf(ret, true)
    ret2
end
function SimpleAction_new_stateful(_name::Union{AbstractString, Symbol}, _parameter_type::Maybe(GVariantType), _state::GVariant)
    _parameter_type_maybe = nothing_to_null(_parameter_type)
    ret = ccall(("g_simple_action_new_stateful", libgio), Ptr{GObject}, (Cstring, Ptr{GVariantType}, Ptr{GVariant}), _name, _parameter_type_maybe, _state)
    ret2 = GSimpleActionLeaf(ret, true)
    ret2
end
function set_enabled(instance::GSimpleAction, _enabled::Bool)
    ret = ccall(("g_simple_action_set_enabled", libgio), Nothing, (Ptr{GObject}, Cint), instance, _enabled)
    nothing
end
function set_state(instance::GSimpleAction, _value::GVariant)
    ret = ccall(("g_simple_action_set_state", libgio), Nothing, (Ptr{GObject}, Ptr{GVariant}), instance, _value)
    nothing
end
function set_state_hint(instance::GSimpleAction, _state_hint::Maybe(GVariant))
    _state_hint_maybe = nothing_to_null(_state_hint)
    ret = ccall(("g_simple_action_set_state_hint", libgio), Nothing, (Ptr{GObject}, Ptr{GVariant}), instance, _state_hint_maybe)
    nothing
end
function activate(instance::GSimpleAction, _parameter::Maybe(GVariant))
    activate(GAction(instance), _parameter)
end
function change_state(instance::GSimpleAction, _value::GVariant)
    change_state(GAction(instance), _value)
end
function get_enabled(instance::GSimpleAction)
    get_enabled(GAction(instance))
end
function get_name(instance::GSimpleAction)
    get_name(GAction(instance))
end
function get_parameter_type(instance::GSimpleAction)
    get_parameter_type(GAction(instance))
end
function get_state(instance::GSimpleAction)
    get_state(GAction(instance))
end
function get_state_hint(instance::GSimpleAction)
    get_state_hint(GAction(instance))
end
function get_state_type(instance::GSimpleAction)
    get_state_type(GAction(instance))
end
function SimpleActionGroup_new()
    ret = ccall(("g_simple_action_group_new", libgio), Ptr{GObject}, ())
    ret2 = GSimpleActionGroupLeaf(ret, true)
    ret2
end
function action_added(instance::GSimpleActionGroup, _action_name::Union{AbstractString, Symbol})
    action_added(GActionGroup(instance), _action_name)
end
function action_enabled_changed(instance::GSimpleActionGroup, _action_name::Union{AbstractString, Symbol}, _enabled::Bool)
    action_enabled_changed(GActionGroup(instance), _action_name, _enabled)
end
function action_removed(instance::GSimpleActionGroup, _action_name::Union{AbstractString, Symbol})
    action_removed(GActionGroup(instance), _action_name)
end
function action_state_changed(instance::GSimpleActionGroup, _action_name::Union{AbstractString, Symbol}, _state::GVariant)
    action_state_changed(GActionGroup(instance), _action_name, _state)
end
function activate_action(instance::GSimpleActionGroup, _action_name::Union{AbstractString, Symbol}, _parameter::Maybe(GVariant))
    activate_action(GActionGroup(instance), _action_name, _parameter)
end
function change_action_state(instance::GSimpleActionGroup, _action_name::Union{AbstractString, Symbol}, _value::GVariant)
    change_action_state(GActionGroup(instance), _action_name, _value)
end
function get_action_enabled(instance::GSimpleActionGroup, _action_name::Union{AbstractString, Symbol})
    get_action_enabled(GActionGroup(instance), _action_name)
end
function get_action_parameter_type(instance::GSimpleActionGroup, _action_name::Union{AbstractString, Symbol})
    get_action_parameter_type(GActionGroup(instance), _action_name)
end
function get_action_state(instance::GSimpleActionGroup, _action_name::Union{AbstractString, Symbol})
    get_action_state(GActionGroup(instance), _action_name)
end
function get_action_state_hint(instance::GSimpleActionGroup, _action_name::Union{AbstractString, Symbol})
    get_action_state_hint(GActionGroup(instance), _action_name)
end
function get_action_state_type(instance::GSimpleActionGroup, _action_name::Union{AbstractString, Symbol})
    get_action_state_type(GActionGroup(instance), _action_name)
end
function has_action(instance::GSimpleActionGroup, _action_name::Union{AbstractString, Symbol})
    has_action(GActionGroup(instance), _action_name)
end
function list_actions(instance::GSimpleActionGroup)
    list_actions(GActionGroup(instance))
end
function query_action(instance::GSimpleActionGroup, _action_name::Union{AbstractString, Symbol})
    query_action(GActionGroup(instance), _action_name)
end
function add_action(instance::GSimpleActionGroup, _action::GAction)
    add_action(GActionMap(instance), _action)
end
function add_action_entries(instance::GSimpleActionGroup, _entries, _user_data::Maybe(Nothing))
    add_action_entries(GActionMap(instance), _entries, _user_data)
end
function lookup_action(instance::GSimpleActionGroup, _action_name::Union{AbstractString, Symbol})
    lookup_action(GActionMap(instance), _action_name)
end
function remove_action(instance::GSimpleActionGroup, _action_name::Union{AbstractString, Symbol})
    remove_action(GActionMap(instance), _action_name)
end
function remove_action_entries(instance::GSimpleActionGroup, _entries)
    remove_action_entries(GActionMap(instance), _entries)
end
function get_source_object(instance::GSimpleAsyncResult)
    get_source_object(GAsyncResult(instance))
end
function get_user_data(instance::GSimpleAsyncResult)
    get_user_data(GAsyncResult(instance))
end
function is_tagged(instance::GSimpleAsyncResult, _source_tag::Maybe(Nothing))
    is_tagged(GAsyncResult(instance), _source_tag)
end
function legacy_propagate_error(instance::GSimpleAsyncResult)
    legacy_propagate_error(GAsyncResult(instance))
end
function SimpleIOStream_new(_input_stream::GInputStream, _output_stream::GOutputStream)
    ret = ccall(("g_simple_io_stream_new", libgio), Ptr{GObject}, (Ptr{GObject}, Ptr{GObject}), _input_stream, _output_stream)
    ret2 = GSimpleIOStreamLeaf(ret, true)
    ret2
end
function SimplePermission_new(_allowed::Bool)
    ret = ccall(("g_simple_permission_new", libgio), Ptr{GObject}, (Cint,), _allowed)
    ret2 = GSimplePermissionLeaf(ret, true)
    ret2
end
function Socket_new(_family, _type, _protocol)
    err = err_buf()
    ret = ccall(("g_socket_new", libgio), Ptr{GObject}, (UInt32, UInt32, UInt32, Ptr{Ptr{GError}}), _family, _type, _protocol, err)
    check_err(err)
    ret2 = GSocketLeaf(ret, true)
    ret2
end
function Socket_new_from_fd(_fd::Integer)
    err = err_buf()
    ret = ccall(("g_socket_new_from_fd", libgio), Ptr{GObject}, (Int32, Ptr{Ptr{GError}}), _fd, err)
    check_err(err)
    ret2 = GSocketLeaf(ret, true)
    ret2
end
function accept(instance::GSocket, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_socket_accept", libgio), Ptr{GObject}, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _cancellable_maybe, err)
    check_err(err)
    ret2 = convert(GSocket, ret, true)
    ret2
end
function bind(instance::GSocket, _address::GSocketAddress, _allow_reuse::Bool)
    err = err_buf()
    ret = ccall(("g_socket_bind", libgio), Cint, (Ptr{GObject}, Ptr{GObject}, Cint, Ptr{Ptr{GError}}), instance, _address, _allow_reuse, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function check_connect_result(instance::GSocket)
    err = err_buf()
    ret = ccall(("g_socket_check_connect_result", libgio), Cint, (Ptr{GObject}, Ptr{Ptr{GError}}), instance, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function close(instance::GSocket)
    err = err_buf()
    ret = ccall(("g_socket_close", libgio), Cint, (Ptr{GObject}, Ptr{Ptr{GError}}), instance, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function condition_check(instance::GSocket, _condition)
    ret = ccall(("g_socket_condition_check", libgio), UInt32, (Ptr{GObject}, UInt32), instance, _condition)
    ret2 = IOCondition(ret)
    ret2
end
function condition_timed_wait(instance::GSocket, _condition, _timeout_us::Integer, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_socket_condition_timed_wait", libgio), Cint, (Ptr{GObject}, UInt32, Int64, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _condition, _timeout_us, _cancellable_maybe, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function condition_wait(instance::GSocket, _condition, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_socket_condition_wait", libgio), Cint, (Ptr{GObject}, UInt32, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _condition, _cancellable_maybe, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function connect(instance::GSocket, _address::GSocketAddress, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_socket_connect", libgio), Cint, (Ptr{GObject}, Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _address, _cancellable_maybe, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function connection_factory_create_connection(instance::GSocket)
    ret = ccall(("g_socket_connection_factory_create_connection", libgio), Ptr{GObject}, (Ptr{GObject},), instance)
    ret2 = convert(GSocketConnection, ret, true)
    ret2
end
function get_available_bytes(instance::GSocket)
    ret = ccall(("g_socket_get_available_bytes", libgio), Int64, (Ptr{GObject},), instance)
    ret
end
function get_blocking(instance::GSocket)
    ret = ccall(("g_socket_get_blocking", libgio), Cint, (Ptr{GObject},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function get_broadcast(instance::GSocket)
    ret = ccall(("g_socket_get_broadcast", libgio), Cint, (Ptr{GObject},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function get_credentials(instance::GSocket)
    err = err_buf()
    ret = ccall(("g_socket_get_credentials", libgio), Ptr{GObject}, (Ptr{GObject}, Ptr{Ptr{GError}}), instance, err)
    check_err(err)
    ret2 = convert(GCredentials, ret, true)
    ret2
end
function get_family(instance::GSocket)
    ret = ccall(("g_socket_get_family", libgio), UInt32, (Ptr{GObject},), instance)
    ret2 = SocketFamily(ret)
    ret2
end
function get_fd(instance::GSocket)
    ret = ccall(("g_socket_get_fd", libgio), Int32, (Ptr{GObject},), instance)
    ret
end
function get_keepalive(instance::GSocket)
    ret = ccall(("g_socket_get_keepalive", libgio), Cint, (Ptr{GObject},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function get_listen_backlog(instance::GSocket)
    ret = ccall(("g_socket_get_listen_backlog", libgio), Int32, (Ptr{GObject},), instance)
    ret
end
function get_local_address(instance::GSocket)
    err = err_buf()
    ret = ccall(("g_socket_get_local_address", libgio), Ptr{GObject}, (Ptr{GObject}, Ptr{Ptr{GError}}), instance, err)
    check_err(err)
    ret2 = convert(GSocketAddress, ret, true)
    ret2
end
function get_multicast_loopback(instance::GSocket)
    ret = ccall(("g_socket_get_multicast_loopback", libgio), Cint, (Ptr{GObject},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function get_multicast_ttl(instance::GSocket)
    ret = ccall(("g_socket_get_multicast_ttl", libgio), UInt32, (Ptr{GObject},), instance)
    ret
end
function get_option(instance::GSocket, _level::Integer, _optname::Integer)
    m_value = Ref{Int32}()
    err = err_buf()
    ret = ccall(("g_socket_get_option", libgio), Cint, (Ptr{GObject}, Int32, Int32, Ptr{Int32}, Ptr{Ptr{GError}}), instance, _level, _optname, m_value, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    _value = m_value[]
    (ret2, _value)
end
function get_protocol(instance::GSocket)
    ret = ccall(("g_socket_get_protocol", libgio), UInt32, (Ptr{GObject},), instance)
    ret2 = SocketProtocol(ret)
    ret2
end
function get_remote_address(instance::GSocket)
    err = err_buf()
    ret = ccall(("g_socket_get_remote_address", libgio), Ptr{GObject}, (Ptr{GObject}, Ptr{Ptr{GError}}), instance, err)
    check_err(err)
    ret2 = convert(GSocketAddress, ret, true)
    ret2
end
function get_socket_type(instance::GSocket)
    ret = ccall(("g_socket_get_socket_type", libgio), UInt32, (Ptr{GObject},), instance)
    ret2 = SocketType(ret)
    ret2
end
function get_timeout(instance::GSocket)
    ret = ccall(("g_socket_get_timeout", libgio), UInt32, (Ptr{GObject},), instance)
    ret
end
function get_ttl(instance::GSocket)
    ret = ccall(("g_socket_get_ttl", libgio), UInt32, (Ptr{GObject},), instance)
    ret
end
function is_closed(instance::GSocket)
    ret = ccall(("g_socket_is_closed", libgio), Cint, (Ptr{GObject},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function is_connected(instance::GSocket)
    ret = ccall(("g_socket_is_connected", libgio), Cint, (Ptr{GObject},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function join_multicast_group(instance::GSocket, _group::GInetAddress, _source_specific::Bool, _iface::Maybe(Union{AbstractString, Symbol}))
    _iface_maybe = nothing_to_null(_iface)
    err = err_buf()
    ret = ccall(("g_socket_join_multicast_group", libgio), Cint, (Ptr{GObject}, Ptr{GObject}, Cint, Cstring, Ptr{Ptr{GError}}), instance, _group, _source_specific, _iface_maybe, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function join_multicast_group_ssm(instance::GSocket, _group::GInetAddress, _source_specific::Maybe(GInetAddress), _iface::Maybe(Union{AbstractString, Symbol}))
    _source_specific_maybe = nothing_to_null(_source_specific)
    _iface_maybe = nothing_to_null(_iface)
    err = err_buf()
    ret = ccall(("g_socket_join_multicast_group_ssm", libgio), Cint, (Ptr{GObject}, Ptr{GObject}, Ptr{GObject}, Cstring, Ptr{Ptr{GError}}), instance, _group, _source_specific_maybe, _iface_maybe, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function leave_multicast_group(instance::GSocket, _group::GInetAddress, _source_specific::Bool, _iface::Maybe(Union{AbstractString, Symbol}))
    _iface_maybe = nothing_to_null(_iface)
    err = err_buf()
    ret = ccall(("g_socket_leave_multicast_group", libgio), Cint, (Ptr{GObject}, Ptr{GObject}, Cint, Cstring, Ptr{Ptr{GError}}), instance, _group, _source_specific, _iface_maybe, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function leave_multicast_group_ssm(instance::GSocket, _group::GInetAddress, _source_specific::Maybe(GInetAddress), _iface::Maybe(Union{AbstractString, Symbol}))
    _source_specific_maybe = nothing_to_null(_source_specific)
    _iface_maybe = nothing_to_null(_iface)
    err = err_buf()
    ret = ccall(("g_socket_leave_multicast_group_ssm", libgio), Cint, (Ptr{GObject}, Ptr{GObject}, Ptr{GObject}, Cstring, Ptr{Ptr{GError}}), instance, _group, _source_specific_maybe, _iface_maybe, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function listen(instance::GSocket)
    err = err_buf()
    ret = ccall(("g_socket_listen", libgio), Cint, (Ptr{GObject}, Ptr{Ptr{GError}}), instance, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function receive(instance::GSocket, _cancellable::Maybe(GCancellable))
    m_buffer = Ref{Ptr{UInt8}}()
    _cancellable_maybe = nothing_to_null(_cancellable)
    _size = length(_buffer)
    err = err_buf()
    ret = ccall(("g_socket_receive", libgio), Int64, (Ptr{GObject}, Ptr{Ptr{UInt8}}, UInt64, Ptr{GObject}, Ptr{Ptr{GError}}), instance, m_buffer, _size, _cancellable_maybe, err)
    check_err(err)
    _buffer = m_buffer[]
    _buffer = collect(unsafe_wrap(Vector{UInt8}, _buffer, m_size[]))
    (ret, _buffer)
end
function receive_bytes(instance::GSocket, _size::Integer, _timeout_us::Integer, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_socket_receive_bytes", libgio), Ptr{GBytes}, (Ptr{GObject}, UInt64, Int64, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _size, _timeout_us, _cancellable_maybe, err)
    check_err(err)
    ret2 = convert(GBytes, ret, true)
    ret2
end
function receive_bytes_from(instance::GSocket, _size::Integer, _timeout_us::Integer, _cancellable::Maybe(GCancellable))
    m_address = Ref{Ptr{GObject}}()
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_socket_receive_bytes_from", libgio), Ptr{GBytes}, (Ptr{GObject}, Ptr{Ptr{GObject}}, UInt64, Int64, Ptr{GObject}, Ptr{Ptr{GError}}), instance, m_address, _size, _timeout_us, _cancellable_maybe, err)
    check_err(err)
    ret2 = convert(GBytes, ret, true)
    _address = m_address[]
    _address = convert(GSocketAddress, _address, true)
    (ret2, _address)
end
function receive_from(instance::GSocket, _cancellable::Maybe(GCancellable))
    m_address = Ref{Ptr{GObject}}()
    m_buffer = Ref{Ptr{UInt8}}()
    _cancellable_maybe = nothing_to_null(_cancellable)
    _size = length(_buffer)
    err = err_buf()
    ret = ccall(("g_socket_receive_from", libgio), Int64, (Ptr{GObject}, Ptr{Ptr{GObject}}, Ptr{Ptr{UInt8}}, UInt64, Ptr{GObject}, Ptr{Ptr{GError}}), instance, m_address, m_buffer, _size, _cancellable_maybe, err)
    check_err(err)
    _address = m_address[]
    _address = convert(GSocketAddress, _address, true)
    _buffer = m_buffer[]
    _buffer = collect(unsafe_wrap(Vector{UInt8}, _buffer, m_size[]))
    (ret, _address, _buffer)
end
function receive_message(instance::GSocket, _vectors, _flags::Integer, _cancellable::Maybe(GCancellable))
    m_address = Ref{Ptr{GObject}}()
    _vectors_arr = convert(Vector{_GInputVector}, _vectors)
    m_messages = Ref{Ptr{Ptr{GObject}}}()
    m_num_messages = Ref{Int32}()
    m_flags = Ref{Int32}()
    m_flags[] = Base.cconvert(Int32, _flags)
    _cancellable_maybe = nothing_to_null(_cancellable)
    _num_vectors = length(_vectors)
    err = err_buf()
    ret = ccall(("g_socket_receive_message", libgio), Int64, (Ptr{GObject}, Ptr{Ptr{GObject}}, Ptr{_GInputVector}, Int32, Ptr{Ptr{Ptr{GObject}}}, Ptr{Int32}, Ptr{Int32}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, m_address, _vectors_arr, _num_vectors, m_messages, m_num_messages, m_flags, _cancellable_maybe, err)
    check_err(err)
    _address = m_address[]
    _address = convert(GSocketAddress, _address, true)
    _messages = m_messages[]
    _messages = begin
            arrtemp = copy(unsafe_wrap(Vector{Ptr{GObject}}, _messages, m_num_messages[]))
            GLib.g_free(_messages)
            arrtemp
        end
    _num_messages = m_num_messages[]
    _flags = m_flags[]
    (ret, _address, _messages, _flags)
end
function receive_with_blocking(instance::GSocket, _blocking::Bool, _cancellable::Maybe(GCancellable))
    m_buffer = Ref{Ptr{UInt8}}()
    _cancellable_maybe = nothing_to_null(_cancellable)
    _size = length(_buffer)
    err = err_buf()
    ret = ccall(("g_socket_receive_with_blocking", libgio), Int64, (Ptr{GObject}, Ptr{Ptr{UInt8}}, UInt64, Cint, Ptr{GObject}, Ptr{Ptr{GError}}), instance, m_buffer, _size, _blocking, _cancellable_maybe, err)
    check_err(err)
    _buffer = m_buffer[]
    _buffer = collect(unsafe_wrap(Vector{UInt8}, _buffer, m_size[]))
    (ret, _buffer)
end
function send(instance::GSocket, _buffer, _cancellable::Maybe(GCancellable))
    _buffer_arr = convert(Vector{UInt8}, _buffer)
    _cancellable_maybe = nothing_to_null(_cancellable)
    _size = length(_buffer)
    err = err_buf()
    ret = ccall(("g_socket_send", libgio), Int64, (Ptr{GObject}, Ptr{UInt8}, UInt64, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _buffer_arr, _size, _cancellable_maybe, err)
    check_err(err)
    ret
end
function send_to(instance::GSocket, _address::Maybe(GSocketAddress), _buffer, _cancellable::Maybe(GCancellable))
    _address_maybe = nothing_to_null(_address)
    _buffer_arr = convert(Vector{UInt8}, _buffer)
    _cancellable_maybe = nothing_to_null(_cancellable)
    _size = length(_buffer)
    err = err_buf()
    ret = ccall(("g_socket_send_to", libgio), Int64, (Ptr{GObject}, Ptr{GObject}, Ptr{UInt8}, UInt64, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _address_maybe, _buffer_arr, _size, _cancellable_maybe, err)
    check_err(err)
    ret
end
function send_with_blocking(instance::GSocket, _buffer, _blocking::Bool, _cancellable::Maybe(GCancellable))
    _buffer_arr = convert(Vector{UInt8}, _buffer)
    _cancellable_maybe = nothing_to_null(_cancellable)
    _size = length(_buffer)
    err = err_buf()
    ret = ccall(("g_socket_send_with_blocking", libgio), Int64, (Ptr{GObject}, Ptr{UInt8}, UInt64, Cint, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _buffer_arr, _size, _blocking, _cancellable_maybe, err)
    check_err(err)
    ret
end
function set_blocking(instance::GSocket, _blocking::Bool)
    ret = ccall(("g_socket_set_blocking", libgio), Nothing, (Ptr{GObject}, Cint), instance, _blocking)
    nothing
end
function set_broadcast(instance::GSocket, _broadcast::Bool)
    ret = ccall(("g_socket_set_broadcast", libgio), Nothing, (Ptr{GObject}, Cint), instance, _broadcast)
    nothing
end
function set_keepalive(instance::GSocket, _keepalive::Bool)
    ret = ccall(("g_socket_set_keepalive", libgio), Nothing, (Ptr{GObject}, Cint), instance, _keepalive)
    nothing
end
function set_listen_backlog(instance::GSocket, _backlog::Integer)
    ret = ccall(("g_socket_set_listen_backlog", libgio), Nothing, (Ptr{GObject}, Int32), instance, _backlog)
    nothing
end
function set_multicast_loopback(instance::GSocket, _loopback::Bool)
    ret = ccall(("g_socket_set_multicast_loopback", libgio), Nothing, (Ptr{GObject}, Cint), instance, _loopback)
    nothing
end
function set_multicast_ttl(instance::GSocket, _ttl::Integer)
    ret = ccall(("g_socket_set_multicast_ttl", libgio), Nothing, (Ptr{GObject}, UInt32), instance, _ttl)
    nothing
end
function set_option(instance::GSocket, _level::Integer, _optname::Integer, _value::Integer)
    err = err_buf()
    ret = ccall(("g_socket_set_option", libgio), Cint, (Ptr{GObject}, Int32, Int32, Int32, Ptr{Ptr{GError}}), instance, _level, _optname, _value, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function set_timeout(instance::GSocket, _timeout::Integer)
    ret = ccall(("g_socket_set_timeout", libgio), Nothing, (Ptr{GObject}, UInt32), instance, _timeout)
    nothing
end
function set_ttl(instance::GSocket, _ttl::Integer)
    ret = ccall(("g_socket_set_ttl", libgio), Nothing, (Ptr{GObject}, UInt32), instance, _ttl)
    nothing
end
function shutdown(instance::GSocket, _shutdown_read::Bool, _shutdown_write::Bool)
    err = err_buf()
    ret = ccall(("g_socket_shutdown", libgio), Cint, (Ptr{GObject}, Cint, Cint, Ptr{Ptr{GError}}), instance, _shutdown_read, _shutdown_write, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function speaks_ipv4(instance::GSocket)
    ret = ccall(("g_socket_speaks_ipv4", libgio), Cint, (Ptr{GObject},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function create_source(instance::GSocket, _condition, _cancellable::Maybe(GCancellable))
    create_source(GDatagramBased(instance), _condition, _cancellable)
end
function init(instance::GSocket, _cancellable::Maybe(GCancellable))
    init(GInitable(instance), _cancellable)
end
function SocketAddress_new_from_native(_native::Nothing, _len::Integer)
    ret = ccall(("g_socket_address_new_from_native", libgio), Ptr{GObject}, (Ptr{Nothing}, UInt64), _native, _len)
    ret2 = convert(GSocketAddress, ret, true)
    ret2
end
function get_family(instance::GSocketAddress)
    ret = ccall(("g_socket_address_get_family", libgio), UInt32, (Ptr{GObject},), instance)
    ret2 = SocketFamily(ret)
    ret2
end
function get_native_size(instance::GSocketAddress)
    ret = ccall(("g_socket_address_get_native_size", libgio), Int64, (Ptr{GObject},), instance)
    ret
end
function to_native(instance::GSocketAddress, _dest::Maybe(Nothing), _destlen::Integer)
    _dest_maybe = nothing_to_null(_dest)
    err = err_buf()
    ret = ccall(("g_socket_address_to_native", libgio), Cint, (Ptr{GObject}, Ptr{Nothing}, UInt64, Ptr{Ptr{GError}}), instance, _dest_maybe, _destlen, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function enumerate(instance::GSocketAddress)
    enumerate(GSocketConnectable(instance))
end
function proxy_enumerate(instance::GSocketAddress)
    proxy_enumerate(GSocketConnectable(instance))
end
function to_string(instance::GSocketAddress)
    to_string(GSocketConnectable(instance))
end
function next(instance::GSocketAddressEnumerator, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_socket_address_enumerator_next", libgio), Ptr{GObject}, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _cancellable_maybe, err)
    check_err(err)
    ret2 = convert_if_not_null(GSocketAddress, ret, true)
    ret2
end
function next_async(instance::GSocketAddressEnumerator, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    ret = ccall(("g_socket_address_enumerator_next_async", libgio), Nothing, (Ptr{GObject}, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function next_finish(instance::GSocketAddressEnumerator, _result::GAsyncResult)
    err = err_buf()
    ret = ccall(("g_socket_address_enumerator_next_finish", libgio), Ptr{GObject}, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _result, err)
    check_err(err)
    ret2 = convert_if_not_null(GSocketAddress, ret, true)
    ret2
end
function SocketClient_new()
    ret = ccall(("g_socket_client_new", libgio), Ptr{GObject}, ())
    ret2 = GSocketClientLeaf(ret, true)
    ret2
end
function add_application_proxy(instance::GSocketClient, _protocol::Union{AbstractString, Symbol})
    ret = ccall(("g_socket_client_add_application_proxy", libgio), Nothing, (Ptr{GObject}, Cstring), instance, _protocol)
    nothing
end
function connect(instance::GSocketClient, _connectable::GSocketConnectable, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_socket_client_connect", libgio), Ptr{GObject}, (Ptr{GObject}, Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _connectable, _cancellable_maybe, err)
    check_err(err)
    ret2 = convert(GSocketConnection, ret, true)
    ret2
end
function connect_async(instance::GSocketClient, _connectable::GSocketConnectable, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    ret = ccall(("g_socket_client_connect_async", libgio), Nothing, (Ptr{GObject}, Ptr{GObject}, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _connectable, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function connect_finish(instance::GSocketClient, _result::GAsyncResult)
    err = err_buf()
    ret = ccall(("g_socket_client_connect_finish", libgio), Ptr{GObject}, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _result, err)
    check_err(err)
    ret2 = convert(GSocketConnection, ret, true)
    ret2
end
function connect_to_host(instance::GSocketClient, _host_and_port::Union{AbstractString, Symbol}, _default_port::Integer, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_socket_client_connect_to_host", libgio), Ptr{GObject}, (Ptr{GObject}, Cstring, UInt16, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _host_and_port, _default_port, _cancellable_maybe, err)
    check_err(err)
    ret2 = convert(GSocketConnection, ret, true)
    ret2
end
function connect_to_host_async(instance::GSocketClient, _host_and_port::Union{AbstractString, Symbol}, _default_port::Integer, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    ret = ccall(("g_socket_client_connect_to_host_async", libgio), Nothing, (Ptr{GObject}, Cstring, UInt16, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _host_and_port, _default_port, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function connect_to_host_finish(instance::GSocketClient, _result::GAsyncResult)
    err = err_buf()
    ret = ccall(("g_socket_client_connect_to_host_finish", libgio), Ptr{GObject}, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _result, err)
    check_err(err)
    ret2 = convert(GSocketConnection, ret, true)
    ret2
end
function connect_to_service(instance::GSocketClient, _domain::Union{AbstractString, Symbol}, _service::Union{AbstractString, Symbol}, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_socket_client_connect_to_service", libgio), Ptr{GObject}, (Ptr{GObject}, Cstring, Cstring, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _domain, _service, _cancellable_maybe, err)
    check_err(err)
    ret2 = convert(GSocketConnection, ret, true)
    ret2
end
function connect_to_service_async(instance::GSocketClient, _domain::Union{AbstractString, Symbol}, _service::Union{AbstractString, Symbol}, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    ret = ccall(("g_socket_client_connect_to_service_async", libgio), Nothing, (Ptr{GObject}, Cstring, Cstring, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _domain, _service, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function connect_to_service_finish(instance::GSocketClient, _result::GAsyncResult)
    err = err_buf()
    ret = ccall(("g_socket_client_connect_to_service_finish", libgio), Ptr{GObject}, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _result, err)
    check_err(err)
    ret2 = convert(GSocketConnection, ret, true)
    ret2
end
function connect_to_uri(instance::GSocketClient, _uri::Union{AbstractString, Symbol}, _default_port::Integer, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_socket_client_connect_to_uri", libgio), Ptr{GObject}, (Ptr{GObject}, Cstring, UInt16, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _uri, _default_port, _cancellable_maybe, err)
    check_err(err)
    ret2 = convert(GSocketConnection, ret, true)
    ret2
end
function connect_to_uri_async(instance::GSocketClient, _uri::Union{AbstractString, Symbol}, _default_port::Integer, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    ret = ccall(("g_socket_client_connect_to_uri_async", libgio), Nothing, (Ptr{GObject}, Cstring, UInt16, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _uri, _default_port, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function connect_to_uri_finish(instance::GSocketClient, _result::GAsyncResult)
    err = err_buf()
    ret = ccall(("g_socket_client_connect_to_uri_finish", libgio), Ptr{GObject}, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _result, err)
    check_err(err)
    ret2 = convert(GSocketConnection, ret, true)
    ret2
end
function get_enable_proxy(instance::GSocketClient)
    ret = ccall(("g_socket_client_get_enable_proxy", libgio), Cint, (Ptr{GObject},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function get_family(instance::GSocketClient)
    ret = ccall(("g_socket_client_get_family", libgio), UInt32, (Ptr{GObject},), instance)
    ret2 = SocketFamily(ret)
    ret2
end
function get_local_address(instance::GSocketClient)
    ret = ccall(("g_socket_client_get_local_address", libgio), Ptr{GObject}, (Ptr{GObject},), instance)
    ret2 = convert_if_not_null(GSocketAddress, ret, false)
    ret2
end
function get_protocol(instance::GSocketClient)
    ret = ccall(("g_socket_client_get_protocol", libgio), UInt32, (Ptr{GObject},), instance)
    ret2 = SocketProtocol(ret)
    ret2
end
function get_proxy_resolver(instance::GSocketClient)
    ret = ccall(("g_socket_client_get_proxy_resolver", libgio), Ptr{GObject}, (Ptr{GObject},), instance)
    ret2 = begin
            leaftype = GLib.find_leaf_type(ret)
            convert(leaftype, ret, false)
        end
    ret2
end
function get_socket_type(instance::GSocketClient)
    ret = ccall(("g_socket_client_get_socket_type", libgio), UInt32, (Ptr{GObject},), instance)
    ret2 = SocketType(ret)
    ret2
end
function get_timeout(instance::GSocketClient)
    ret = ccall(("g_socket_client_get_timeout", libgio), UInt32, (Ptr{GObject},), instance)
    ret
end
function get_tls(instance::GSocketClient)
    ret = ccall(("g_socket_client_get_tls", libgio), Cint, (Ptr{GObject},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function set_enable_proxy(instance::GSocketClient, _enable::Bool)
    ret = ccall(("g_socket_client_set_enable_proxy", libgio), Nothing, (Ptr{GObject}, Cint), instance, _enable)
    nothing
end
function set_family(instance::GSocketClient, _family)
    ret = ccall(("g_socket_client_set_family", libgio), Nothing, (Ptr{GObject}, UInt32), instance, _family)
    nothing
end
function set_local_address(instance::GSocketClient, _address::Maybe(GSocketAddress))
    _address_maybe = nothing_to_null(_address)
    ret = ccall(("g_socket_client_set_local_address", libgio), Nothing, (Ptr{GObject}, Ptr{GObject}), instance, _address_maybe)
    nothing
end
function set_protocol(instance::GSocketClient, _protocol)
    ret = ccall(("g_socket_client_set_protocol", libgio), Nothing, (Ptr{GObject}, UInt32), instance, _protocol)
    nothing
end
function set_proxy_resolver(instance::GSocketClient, _proxy_resolver::Maybe(GProxyResolver))
    _proxy_resolver_maybe = nothing_to_null(_proxy_resolver)
    ret = ccall(("g_socket_client_set_proxy_resolver", libgio), Nothing, (Ptr{GObject}, Ptr{GObject}), instance, _proxy_resolver_maybe)
    nothing
end
function set_socket_type(instance::GSocketClient, _type)
    ret = ccall(("g_socket_client_set_socket_type", libgio), Nothing, (Ptr{GObject}, UInt32), instance, _type)
    nothing
end
function set_timeout(instance::GSocketClient, _timeout::Integer)
    ret = ccall(("g_socket_client_set_timeout", libgio), Nothing, (Ptr{GObject}, UInt32), instance, _timeout)
    nothing
end
function set_tls(instance::GSocketClient, _tls::Bool)
    ret = ccall(("g_socket_client_set_tls", libgio), Nothing, (Ptr{GObject}, Cint), instance, _tls)
    nothing
end
function factory_lookup_type(_family, _type, _protocol_id::Integer)
    ret = ccall(("g_socket_connection_factory_lookup_type", libgio), UInt64, (UInt32, UInt32, Int32), _family, _type, _protocol_id)
    ret
end
function factory_register_type(_g_type::Integer, _family, _type, _protocol::Integer)
    ret = ccall(("g_socket_connection_factory_register_type", libgio), Nothing, (UInt64, UInt32, UInt32, Int32), _g_type, _family, _type, _protocol)
    nothing
end
function connect(instance::GSocketConnection, _address::GSocketAddress, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_socket_connection_connect", libgio), Cint, (Ptr{GObject}, Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _address, _cancellable_maybe, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function connect_async(instance::GSocketConnection, _address::GSocketAddress, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    ret = ccall(("g_socket_connection_connect_async", libgio), Nothing, (Ptr{GObject}, Ptr{GObject}, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _address, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function connect_finish(instance::GSocketConnection, _result::GAsyncResult)
    err = err_buf()
    ret = ccall(("g_socket_connection_connect_finish", libgio), Cint, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _result, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function get_local_address(instance::GSocketConnection)
    err = err_buf()
    ret = ccall(("g_socket_connection_get_local_address", libgio), Ptr{GObject}, (Ptr{GObject}, Ptr{Ptr{GError}}), instance, err)
    check_err(err)
    ret2 = convert(GSocketAddress, ret, true)
    ret2
end
function get_remote_address(instance::GSocketConnection)
    err = err_buf()
    ret = ccall(("g_socket_connection_get_remote_address", libgio), Ptr{GObject}, (Ptr{GObject}, Ptr{Ptr{GError}}), instance, err)
    check_err(err)
    ret2 = convert(GSocketAddress, ret, true)
    ret2
end
function get_socket(instance::GSocketConnection)
    ret = ccall(("g_socket_connection_get_socket", libgio), Ptr{GObject}, (Ptr{GObject},), instance)
    ret2 = convert(GSocket, ret, false)
    ret2
end
function is_connected(instance::GSocketConnection)
    ret = ccall(("g_socket_connection_is_connected", libgio), Cint, (Ptr{GObject},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function deserialize(_level::Integer, _type::Integer, _data)
    _data_arr = convert(Vector{UInt8}, _data)
    _size = length(_data)
    ret = ccall(("g_socket_control_message_deserialize", libgio), Ptr{GObject}, (Int32, Int32, UInt64, Ptr{UInt8}), _level, _type, _size, _data_arr)
    ret2 = convert_if_not_null(GSocketControlMessage, ret, true)
    ret2
end
function get_level(instance::GSocketControlMessage)
    ret = ccall(("g_socket_control_message_get_level", libgio), Int32, (Ptr{GObject},), instance)
    ret
end
function get_msg_type(instance::GSocketControlMessage)
    ret = ccall(("g_socket_control_message_get_msg_type", libgio), Int32, (Ptr{GObject},), instance)
    ret
end
function get_size(instance::GSocketControlMessage)
    ret = ccall(("g_socket_control_message_get_size", libgio), UInt64, (Ptr{GObject},), instance)
    ret
end
function serialize(instance::GSocketControlMessage, _data::Nothing)
    ret = ccall(("g_socket_control_message_serialize", libgio), Nothing, (Ptr{GObject}, Ptr{Nothing}), instance, _data)
    nothing
end
function SocketListener_new()
    ret = ccall(("g_socket_listener_new", libgio), Ptr{GObject}, ())
    ret2 = GSocketListenerLeaf(ret, true)
    ret2
end
function accept(instance::GSocketListener, _cancellable::Maybe(GCancellable))
    m_source_object = Ref{Ptr{GObject}}()
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_socket_listener_accept", libgio), Ptr{GObject}, (Ptr{GObject}, Ptr{Ptr{GObject}}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, m_source_object, _cancellable_maybe, err)
    check_err(err)
    ret2 = convert(GSocketConnection, ret, true)
    _source_object = m_source_object[]
    _source_object = convert_if_not_null(GObject, _source_object, false)
    (ret2, _source_object)
end
function accept_async(instance::GSocketListener, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    ret = ccall(("g_socket_listener_accept_async", libgio), Nothing, (Ptr{GObject}, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function accept_finish(instance::GSocketListener, _result::GAsyncResult)
    m_source_object = Ref{Ptr{GObject}}()
    err = err_buf()
    ret = ccall(("g_socket_listener_accept_finish", libgio), Ptr{GObject}, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GObject}}, Ptr{Ptr{GError}}), instance, _result, m_source_object, err)
    check_err(err)
    ret2 = convert(GSocketConnection, ret, true)
    _source_object = m_source_object[]
    _source_object = convert_if_not_null(GObject, _source_object, false)
    (ret2, _source_object)
end
function accept_socket(instance::GSocketListener, _cancellable::Maybe(GCancellable))
    m_source_object = Ref{Ptr{GObject}}()
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_socket_listener_accept_socket", libgio), Ptr{GObject}, (Ptr{GObject}, Ptr{Ptr{GObject}}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, m_source_object, _cancellable_maybe, err)
    check_err(err)
    ret2 = convert(GSocket, ret, true)
    _source_object = m_source_object[]
    _source_object = convert_if_not_null(GObject, _source_object, false)
    (ret2, _source_object)
end
function accept_socket_async(instance::GSocketListener, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    ret = ccall(("g_socket_listener_accept_socket_async", libgio), Nothing, (Ptr{GObject}, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function accept_socket_finish(instance::GSocketListener, _result::GAsyncResult)
    m_source_object = Ref{Ptr{GObject}}()
    err = err_buf()
    ret = ccall(("g_socket_listener_accept_socket_finish", libgio), Ptr{GObject}, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GObject}}, Ptr{Ptr{GError}}), instance, _result, m_source_object, err)
    check_err(err)
    ret2 = convert(GSocket, ret, true)
    _source_object = m_source_object[]
    _source_object = convert_if_not_null(GObject, _source_object, false)
    (ret2, _source_object)
end
function add_address(instance::GSocketListener, _address::GSocketAddress, _type, _protocol, _source_object::Maybe(GObject))
    _source_object_maybe = nothing_to_null(_source_object)
    m_effective_address = Ref{Ptr{GObject}}()
    err = err_buf()
    ret = ccall(("g_socket_listener_add_address", libgio), Cint, (Ptr{GObject}, Ptr{GObject}, UInt32, UInt32, Ptr{GObject}, Ptr{Ptr{GObject}}, Ptr{Ptr{GError}}), instance, _address, _type, _protocol, _source_object_maybe, m_effective_address, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    _effective_address = m_effective_address[]
    _effective_address = convert(GSocketAddress, _effective_address, true)
    (ret2, _effective_address)
end
function add_any_inet_port(instance::GSocketListener, _source_object::Maybe(GObject))
    _source_object_maybe = nothing_to_null(_source_object)
    err = err_buf()
    ret = ccall(("g_socket_listener_add_any_inet_port", libgio), UInt16, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _source_object_maybe, err)
    check_err(err)
    ret
end
function add_inet_port(instance::GSocketListener, _port::Integer, _source_object::Maybe(GObject))
    _source_object_maybe = nothing_to_null(_source_object)
    err = err_buf()
    ret = ccall(("g_socket_listener_add_inet_port", libgio), Cint, (Ptr{GObject}, UInt16, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _port, _source_object_maybe, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function add_socket(instance::GSocketListener, _socket::GSocket, _source_object::Maybe(GObject))
    _source_object_maybe = nothing_to_null(_source_object)
    err = err_buf()
    ret = ccall(("g_socket_listener_add_socket", libgio), Cint, (Ptr{GObject}, Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _socket, _source_object_maybe, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function close(instance::GSocketListener)
    ret = ccall(("g_socket_listener_close", libgio), Nothing, (Ptr{GObject},), instance)
    nothing
end
function set_backlog(instance::GSocketListener, _listen_backlog::Integer)
    ret = ccall(("g_socket_listener_set_backlog", libgio), Nothing, (Ptr{GObject}, Int32), instance, _listen_backlog)
    nothing
end
function SocketService_new()
    ret = ccall(("g_socket_service_new", libgio), Ptr{GObject}, ())
    ret2 = GSocketServiceLeaf(ret, true)
    ret2
end
function is_active(instance::GSocketService)
    ret = ccall(("g_socket_service_is_active", libgio), Cint, (Ptr{GObject},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function start(instance::GSocketService)
    ret = ccall(("g_socket_service_start", libgio), Nothing, (Ptr{GObject},), instance)
    nothing
end
function stop(instance::GSocketService)
    ret = ccall(("g_socket_service_stop", libgio), Nothing, (Ptr{GObject},), instance)
    nothing
end
function Subprocess_new(_argv, _flags)
    err = err_buf()
    ret = ccall(("g_subprocess_newv", libgio), Ptr{GObject}, (Ptr{Cstring}, UInt32, Ptr{Ptr{GError}}), _argv, _flags, err)
    check_err(err)
    ret2 = GSubprocessLeaf(ret, true)
    ret2
end
function communicate(instance::GSubprocess, _stdin_buf::Maybe(GBytes), _cancellable::Maybe(GCancellable))
    _stdin_buf_maybe = nothing_to_null(_stdin_buf)
    _cancellable_maybe = nothing_to_null(_cancellable)
    m_stdout_buf = Ref{Ptr{GBytes}}()
    m_stderr_buf = Ref{Ptr{GBytes}}()
    err = err_buf()
    ret = ccall(("g_subprocess_communicate", libgio), Cint, (Ptr{GObject}, Ptr{GBytes}, Ptr{GObject}, Ptr{Ptr{GBytes}}, Ptr{Ptr{GBytes}}, Ptr{Ptr{GError}}), instance, _stdin_buf_maybe, _cancellable_maybe, m_stdout_buf, m_stderr_buf, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    _stdout_buf = m_stdout_buf[]
    _stdout_buf = convert_if_not_null(GBytes, _stdout_buf, true)
    _stderr_buf = m_stderr_buf[]
    _stderr_buf = convert_if_not_null(GBytes, _stderr_buf, true)
    (ret2, _stdout_buf, _stderr_buf)
end
function communicate_async(instance::GSubprocess, _stdin_buf::Maybe(GBytes), _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _stdin_buf_maybe = nothing_to_null(_stdin_buf)
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    ret = ccall(("g_subprocess_communicate_async", libgio), Nothing, (Ptr{GObject}, Ptr{GBytes}, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _stdin_buf_maybe, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function communicate_finish(instance::GSubprocess, _result::GAsyncResult)
    m_stdout_buf = Ref{Ptr{GBytes}}()
    m_stderr_buf = Ref{Ptr{GBytes}}()
    err = err_buf()
    ret = ccall(("g_subprocess_communicate_finish", libgio), Cint, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GBytes}}, Ptr{Ptr{GBytes}}, Ptr{Ptr{GError}}), instance, _result, m_stdout_buf, m_stderr_buf, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    _stdout_buf = m_stdout_buf[]
    _stdout_buf = convert_if_not_null(GBytes, _stdout_buf, true)
    _stderr_buf = m_stderr_buf[]
    _stderr_buf = convert_if_not_null(GBytes, _stderr_buf, true)
    (ret2, _stdout_buf, _stderr_buf)
end
function communicate_utf8(instance::GSubprocess, _stdin_buf::Maybe(Union{AbstractString, Symbol}), _cancellable::Maybe(GCancellable))
    _stdin_buf_maybe = nothing_to_null(_stdin_buf)
    _cancellable_maybe = nothing_to_null(_cancellable)
    m_stdout_buf = Ref{Cstring}()
    m_stderr_buf = Ref{Cstring}()
    err = err_buf()
    ret = ccall(("g_subprocess_communicate_utf8", libgio), Cint, (Ptr{GObject}, Cstring, Ptr{GObject}, Ptr{Cstring}, Ptr{Cstring}, Ptr{Ptr{GError}}), instance, _stdin_buf_maybe, _cancellable_maybe, m_stdout_buf, m_stderr_buf, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    _stdout_buf = m_stdout_buf[]
    _stdout_buf = string_or_nothing(_stdout_buf, true)
    _stderr_buf = m_stderr_buf[]
    _stderr_buf = string_or_nothing(_stderr_buf, true)
    (ret2, _stdout_buf, _stderr_buf)
end
function communicate_utf8_async(instance::GSubprocess, _stdin_buf::Maybe(Union{AbstractString, Symbol}), _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _stdin_buf_maybe = nothing_to_null(_stdin_buf)
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    ret = ccall(("g_subprocess_communicate_utf8_async", libgio), Nothing, (Ptr{GObject}, Cstring, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _stdin_buf_maybe, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function communicate_utf8_finish(instance::GSubprocess, _result::GAsyncResult)
    m_stdout_buf = Ref{Cstring}()
    m_stderr_buf = Ref{Cstring}()
    err = err_buf()
    ret = ccall(("g_subprocess_communicate_utf8_finish", libgio), Cint, (Ptr{GObject}, Ptr{GObject}, Ptr{Cstring}, Ptr{Cstring}, Ptr{Ptr{GError}}), instance, _result, m_stdout_buf, m_stderr_buf, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    _stdout_buf = m_stdout_buf[]
    _stdout_buf = string_or_nothing(_stdout_buf, true)
    _stderr_buf = m_stderr_buf[]
    _stderr_buf = string_or_nothing(_stderr_buf, true)
    (ret2, _stdout_buf, _stderr_buf)
end
function force_exit(instance::GSubprocess)
    ret = ccall(("g_subprocess_force_exit", libgio), Nothing, (Ptr{GObject},), instance)
    nothing
end
function get_exit_status(instance::GSubprocess)
    ret = ccall(("g_subprocess_get_exit_status", libgio), Int32, (Ptr{GObject},), instance)
    ret
end
function get_identifier(instance::GSubprocess)
    ret = ccall(("g_subprocess_get_identifier", libgio), Cstring, (Ptr{GObject},), instance)
    ret2 = string_or_nothing(ret, false)
    ret2
end
function get_if_exited(instance::GSubprocess)
    ret = ccall(("g_subprocess_get_if_exited", libgio), Cint, (Ptr{GObject},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function get_if_signaled(instance::GSubprocess)
    ret = ccall(("g_subprocess_get_if_signaled", libgio), Cint, (Ptr{GObject},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function get_status(instance::GSubprocess)
    ret = ccall(("g_subprocess_get_status", libgio), Int32, (Ptr{GObject},), instance)
    ret
end
function get_stderr_pipe(instance::GSubprocess)
    ret = ccall(("g_subprocess_get_stderr_pipe", libgio), Ptr{GObject}, (Ptr{GObject},), instance)
    ret2 = convert_if_not_null(GInputStream, ret, false)
    ret2
end
function get_stdin_pipe(instance::GSubprocess)
    ret = ccall(("g_subprocess_get_stdin_pipe", libgio), Ptr{GObject}, (Ptr{GObject},), instance)
    ret2 = convert_if_not_null(GOutputStream, ret, false)
    ret2
end
function get_stdout_pipe(instance::GSubprocess)
    ret = ccall(("g_subprocess_get_stdout_pipe", libgio), Ptr{GObject}, (Ptr{GObject},), instance)
    ret2 = convert_if_not_null(GInputStream, ret, false)
    ret2
end
function get_successful(instance::GSubprocess)
    ret = ccall(("g_subprocess_get_successful", libgio), Cint, (Ptr{GObject},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function get_term_sig(instance::GSubprocess)
    ret = ccall(("g_subprocess_get_term_sig", libgio), Int32, (Ptr{GObject},), instance)
    ret
end
function send_signal(instance::GSubprocess, _signal_num::Integer)
    ret = ccall(("g_subprocess_send_signal", libgio), Nothing, (Ptr{GObject}, Int32), instance, _signal_num)
    nothing
end
function wait(instance::GSubprocess, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_subprocess_wait", libgio), Cint, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _cancellable_maybe, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function wait_async(instance::GSubprocess, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    ret = ccall(("g_subprocess_wait_async", libgio), Nothing, (Ptr{GObject}, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function wait_check(instance::GSubprocess, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_subprocess_wait_check", libgio), Cint, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _cancellable_maybe, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function wait_check_async(instance::GSubprocess, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    ret = ccall(("g_subprocess_wait_check_async", libgio), Nothing, (Ptr{GObject}, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function wait_check_finish(instance::GSubprocess, _result::GAsyncResult)
    err = err_buf()
    ret = ccall(("g_subprocess_wait_check_finish", libgio), Cint, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _result, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function wait_finish(instance::GSubprocess, _result::GAsyncResult)
    err = err_buf()
    ret = ccall(("g_subprocess_wait_finish", libgio), Cint, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _result, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function init(instance::GSubprocess, _cancellable::Maybe(GCancellable))
    init(GInitable(instance), _cancellable)
end
function SubprocessLauncher_new(_flags)
    ret = ccall(("g_subprocess_launcher_new", libgio), Ptr{GObject}, (UInt32,), _flags)
    ret2 = GSubprocessLauncherLeaf(ret, true)
    ret2
end
function close(instance::GSubprocessLauncher)
    ret = ccall(("g_subprocess_launcher_close", libgio), Nothing, (Ptr{GObject},), instance)
    nothing
end
function getenv(instance::GSubprocessLauncher, _variable::Union{AbstractString, Symbol})
    ret = ccall(("g_subprocess_launcher_getenv", libgio), Cstring, (Ptr{GObject}, Cstring), instance, _variable)
    ret2 = string_or_nothing(ret, false)
    ret2
end
function set_cwd(instance::GSubprocessLauncher, _cwd::Union{AbstractString, Symbol})
    ret = ccall(("g_subprocess_launcher_set_cwd", libgio), Nothing, (Ptr{GObject}, Cstring), instance, _cwd)
    nothing
end
function set_environ(instance::GSubprocessLauncher, _env)
    ret = ccall(("g_subprocess_launcher_set_environ", libgio), Nothing, (Ptr{GObject}, Ptr{Cstring}), instance, _env)
    nothing
end
function set_flags(instance::GSubprocessLauncher, _flags)
    ret = ccall(("g_subprocess_launcher_set_flags", libgio), Nothing, (Ptr{GObject}, UInt32), instance, _flags)
    nothing
end
function set_stderr_file_path(instance::GSubprocessLauncher, _path::Maybe(Union{AbstractString, Symbol}))
    _path_maybe = nothing_to_null(_path)
    ret = ccall(("g_subprocess_launcher_set_stderr_file_path", libgio), Nothing, (Ptr{GObject}, Cstring), instance, _path_maybe)
    nothing
end
function set_stdin_file_path(instance::GSubprocessLauncher, _path::Maybe(Union{AbstractString, Symbol}))
    _path_maybe = nothing_to_null(_path)
    ret = ccall(("g_subprocess_launcher_set_stdin_file_path", libgio), Nothing, (Ptr{GObject}, Cstring), instance, _path_maybe)
    nothing
end
function set_stdout_file_path(instance::GSubprocessLauncher, _path::Maybe(Union{AbstractString, Symbol}))
    _path_maybe = nothing_to_null(_path)
    ret = ccall(("g_subprocess_launcher_set_stdout_file_path", libgio), Nothing, (Ptr{GObject}, Cstring), instance, _path_maybe)
    nothing
end
function setenv(instance::GSubprocessLauncher, _variable::Union{AbstractString, Symbol}, _value::Union{AbstractString, Symbol}, _overwrite::Bool)
    ret = ccall(("g_subprocess_launcher_setenv", libgio), Nothing, (Ptr{GObject}, Cstring, Cstring, Cint), instance, _variable, _value, _overwrite)
    nothing
end
function spawnv(instance::GSubprocessLauncher, _argv)
    err = err_buf()
    ret = ccall(("g_subprocess_launcher_spawnv", libgio), Ptr{GObject}, (Ptr{GObject}, Ptr{Cstring}, Ptr{Ptr{GError}}), instance, _argv, err)
    check_err(err)
    ret2 = convert(GSubprocess, ret, true)
    ret2
end
function take_fd(instance::GSubprocessLauncher, _source_fd::Integer, _target_fd::Integer)
    ret = ccall(("g_subprocess_launcher_take_fd", libgio), Nothing, (Ptr{GObject}, Int32, Int32), instance, _source_fd, _target_fd)
    nothing
end
function take_stderr_fd(instance::GSubprocessLauncher, _fd::Integer)
    ret = ccall(("g_subprocess_launcher_take_stderr_fd", libgio), Nothing, (Ptr{GObject}, Int32), instance, _fd)
    nothing
end
function take_stdin_fd(instance::GSubprocessLauncher, _fd::Integer)
    ret = ccall(("g_subprocess_launcher_take_stdin_fd", libgio), Nothing, (Ptr{GObject}, Int32), instance, _fd)
    nothing
end
function take_stdout_fd(instance::GSubprocessLauncher, _fd::Integer)
    ret = ccall(("g_subprocess_launcher_take_stdout_fd", libgio), Nothing, (Ptr{GObject}, Int32), instance, _fd)
    nothing
end
function unsetenv(instance::GSubprocessLauncher, _variable::Union{AbstractString, Symbol})
    ret = ccall(("g_subprocess_launcher_unsetenv", libgio), Nothing, (Ptr{GObject}, Cstring), instance, _variable)
    nothing
end
function Task_new(_source_object::Maybe(GObject), _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _source_object_maybe = nothing_to_null(_source_object)
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    ret = ccall(("g_task_new", libgio), Ptr{GObject}, (Ptr{GObject}, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), _source_object_maybe, _cancellable_maybe, _callback_cfunc, _callback_closure)
    ret2 = GTaskLeaf(ret, true)
    ret2
end
function is_valid(_result::GAsyncResult, _source_object::Maybe(GObject))
    _source_object_maybe = nothing_to_null(_source_object)
    ret = ccall(("g_task_is_valid", libgio), Cint, (Ptr{GObject}, Ptr{GObject}), _result, _source_object_maybe)
    ret2 = convert(Bool, ret)
    ret2
end
function report_error(_source_object::Maybe(GObject), _callback::Maybe(Function), _source_tag::Maybe(Nothing), _error)
    _source_object_maybe = nothing_to_null(_source_object)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    _source_tag_maybe = nothing_to_null(_source_tag)
    ret = ccall(("g_task_report_error", libgio), Nothing, (Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}, Ptr{Nothing}, Ptr{GError}), _source_object_maybe, _callback_cfunc, _callback_closure, _source_tag_maybe, _error)
    nothing
end
function get_cancellable(instance::GTask)
    ret = ccall(("g_task_get_cancellable", libgio), Ptr{GObject}, (Ptr{GObject},), instance)
    ret2 = convert_if_not_null(GCancellable, ret, false)
    ret2
end
function get_check_cancellable(instance::GTask)
    ret = ccall(("g_task_get_check_cancellable", libgio), Cint, (Ptr{GObject},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function get_completed(instance::GTask)
    ret = ccall(("g_task_get_completed", libgio), Cint, (Ptr{GObject},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function get_context(instance::GTask)
    ret = ccall(("g_task_get_context", libgio), Ptr{GMainContext}, (Ptr{GObject},), instance)
    ret2 = convert(GMainContext, ret, false)
    ret2
end
function get_name(instance::GTask)
    ret = ccall(("g_task_get_name", libgio), Cstring, (Ptr{GObject},), instance)
    ret2 = string_or_nothing(ret, false)
    ret2
end
function get_priority(instance::GTask)
    ret = ccall(("g_task_get_priority", libgio), Int32, (Ptr{GObject},), instance)
    ret
end
function get_return_on_cancel(instance::GTask)
    ret = ccall(("g_task_get_return_on_cancel", libgio), Cint, (Ptr{GObject},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function get_source_object(instance::GTask)
    ret = ccall(("g_task_get_source_object", libgio), Ptr{GObject}, (Ptr{GObject},), instance)
    ret2 = convert_if_not_null(GObject, ret, false)
    ret2
end
function get_source_tag(instance::GTask)
    ret = ccall(("g_task_get_source_tag", libgio), Ptr{Nothing}, (Ptr{GObject},), instance)
    ret2 = convert(Nothing, ret)
    ret2
end
function get_task_data(instance::GTask)
    ret = ccall(("g_task_get_task_data", libgio), Ptr{Nothing}, (Ptr{GObject},), instance)
    ret2 = convert(Nothing, ret)
    ret2
end
function had_error(instance::GTask)
    ret = ccall(("g_task_had_error", libgio), Cint, (Ptr{GObject},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function propagate_boolean(instance::GTask)
    err = err_buf()
    ret = ccall(("g_task_propagate_boolean", libgio), Cint, (Ptr{GObject}, Ptr{Ptr{GError}}), instance, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function propagate_int(instance::GTask)
    err = err_buf()
    ret = ccall(("g_task_propagate_int", libgio), Int64, (Ptr{GObject}, Ptr{Ptr{GError}}), instance, err)
    check_err(err)
    ret
end
function propagate_pointer(instance::GTask)
    err = err_buf()
    ret = ccall(("g_task_propagate_pointer", libgio), Ptr{Nothing}, (Ptr{GObject}, Ptr{Ptr{GError}}), instance, err)
    check_err(err)
    ret2 = convert(Nothing, ret)
    ret2
end
function propagate_value(instance::GTask)
    m_value = Ref{_GValue}()
    err = err_buf()
    ret = ccall(("g_task_propagate_value", libgio), Cint, (Ptr{GObject}, Ptr{_GValue}, Ptr{Ptr{GError}}), instance, m_value, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    _value = m_value[]
    (ret2, _value)
end
function return_boolean(instance::GTask, _result::Bool)
    ret = ccall(("g_task_return_boolean", libgio), Nothing, (Ptr{GObject}, Cint), instance, _result)
    nothing
end
function return_error(instance::GTask, _error)
    ret = ccall(("g_task_return_error", libgio), Nothing, (Ptr{GObject}, Ptr{GError}), instance, _error)
    nothing
end
function return_error_if_cancelled(instance::GTask)
    ret = ccall(("g_task_return_error_if_cancelled", libgio), Cint, (Ptr{GObject},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function return_int(instance::GTask, _result::Integer)
    ret = ccall(("g_task_return_int", libgio), Nothing, (Ptr{GObject}, Int64), instance, _result)
    nothing
end
function return_new_error_literal(instance::GTask, _domain::Integer, _code::Integer, _message::Union{AbstractString, Symbol})
    ret = ccall(("g_task_return_new_error_literal", libgio), Nothing, (Ptr{GObject}, UInt32, Int32, Cstring), instance, _domain, _code, _message)
    nothing
end
function return_value(instance::GTask, _result::Maybe(GValueLike))
    _result_maybe = nothing_to_null(_result)
    ret = ccall(("g_task_return_value", libgio), Nothing, (Ptr{GObject}, Ptr{_GValue}), instance, _result_maybe)
    nothing
end
function set_check_cancellable(instance::GTask, _check_cancellable::Bool)
    ret = ccall(("g_task_set_check_cancellable", libgio), Nothing, (Ptr{GObject}, Cint), instance, _check_cancellable)
    nothing
end
function set_name(instance::GTask, _name::Maybe(Union{AbstractString, Symbol}))
    _name_maybe = nothing_to_null(_name)
    ret = ccall(("g_task_set_name", libgio), Nothing, (Ptr{GObject}, Cstring), instance, _name_maybe)
    nothing
end
function set_priority(instance::GTask, _priority::Integer)
    ret = ccall(("g_task_set_priority", libgio), Nothing, (Ptr{GObject}, Int32), instance, _priority)
    nothing
end
function set_return_on_cancel(instance::GTask, _return_on_cancel::Bool)
    ret = ccall(("g_task_set_return_on_cancel", libgio), Cint, (Ptr{GObject}, Cint), instance, _return_on_cancel)
    ret2 = convert(Bool, ret)
    ret2
end
function set_source_tag(instance::GTask, _source_tag::Maybe(Nothing))
    _source_tag_maybe = nothing_to_null(_source_tag)
    ret = ccall(("g_task_set_source_tag", libgio), Nothing, (Ptr{GObject}, Ptr{Nothing}), instance, _source_tag_maybe)
    nothing
end
function set_static_name(instance::GTask, _name::Maybe(Union{AbstractString, Symbol}))
    _name_maybe = nothing_to_null(_name)
    ret = ccall(("g_task_set_static_name", libgio), Nothing, (Ptr{GObject}, Cstring), instance, _name_maybe)
    nothing
end
function get_user_data(instance::GTask)
    get_user_data(GAsyncResult(instance))
end
function is_tagged(instance::GTask, _source_tag::Maybe(Nothing))
    is_tagged(GAsyncResult(instance), _source_tag)
end
function legacy_propagate_error(instance::GTask)
    legacy_propagate_error(GAsyncResult(instance))
end
function get_graceful_disconnect(instance::GTcpConnection)
    ret = ccall(("g_tcp_connection_get_graceful_disconnect", libgio), Cint, (Ptr{GObject},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function set_graceful_disconnect(instance::GTcpConnection, _graceful_disconnect::Bool)
    ret = ccall(("g_tcp_connection_set_graceful_disconnect", libgio), Nothing, (Ptr{GObject}, Cint), instance, _graceful_disconnect)
    nothing
end
function TcpWrapperConnection_new(_base_io_stream::GIOStream, _socket::GSocket)
    ret = ccall(("g_tcp_wrapper_connection_new", libgio), Ptr{GObject}, (Ptr{GObject}, Ptr{GObject}), _base_io_stream, _socket)
    ret2 = GTcpWrapperConnectionLeaf(ret, true)
    ret2
end
function get_base_io_stream(instance::GTcpWrapperConnection)
    ret = ccall(("g_tcp_wrapper_connection_get_base_io_stream", libgio), Ptr{GObject}, (Ptr{GObject},), instance)
    ret2 = convert(GIOStream, ret, false)
    ret2
end
function TestDBus_new(_flags)
    ret = ccall(("g_test_dbus_new", libgio), Ptr{GObject}, (UInt32,), _flags)
    ret2 = GTestDBusLeaf(ret, true)
    ret2
end
function unset()
    ret = ccall(("g_test_dbus_unset", libgio), Nothing, ())
    nothing
end
function add_service_dir(instance::GTestDBus, _path::Union{AbstractString, Symbol})
    ret = ccall(("g_test_dbus_add_service_dir", libgio), Nothing, (Ptr{GObject}, Cstring), instance, _path)
    nothing
end
function down(instance::GTestDBus)
    ret = ccall(("g_test_dbus_down", libgio), Nothing, (Ptr{GObject},), instance)
    nothing
end
function get_bus_address(instance::GTestDBus)
    ret = ccall(("g_test_dbus_get_bus_address", libgio), Cstring, (Ptr{GObject},), instance)
    ret2 = string_or_nothing(ret, false)
    ret2
end
function get_flags(instance::GTestDBus)
    ret = ccall(("g_test_dbus_get_flags", libgio), UInt32, (Ptr{GObject},), instance)
    ret2 = TestDBusFlags(ret)
    ret2
end
function stop(instance::GTestDBus)
    ret = ccall(("g_test_dbus_stop", libgio), Nothing, (Ptr{GObject},), instance)
    nothing
end
function up(instance::GTestDBus)
    ret = ccall(("g_test_dbus_up", libgio), Nothing, (Ptr{GObject},), instance)
    nothing
end
function ThemedIcon_new(_iconname::Union{AbstractString, Symbol})
    ret = ccall(("g_themed_icon_new", libgio), Ptr{GObject}, (Cstring,), _iconname)
    ret2 = GThemedIconLeaf(ret, true)
    ret2
end
function ThemedIcon_new_from_names(_iconnames)
    _len = length(_iconnames)
    ret = ccall(("g_themed_icon_new_from_names", libgio), Ptr{GObject}, (Ptr{Cstring}, Int32), _iconnames, _len)
    ret2 = GThemedIconLeaf(ret, true)
    ret2
end
function ThemedIcon_new_with_default_fallbacks(_iconname::Union{AbstractString, Symbol})
    ret = ccall(("g_themed_icon_new_with_default_fallbacks", libgio), Ptr{GObject}, (Cstring,), _iconname)
    ret2 = GThemedIconLeaf(ret, true)
    ret2
end
function append_name(instance::GThemedIcon, _iconname::Union{AbstractString, Symbol})
    ret = ccall(("g_themed_icon_append_name", libgio), Nothing, (Ptr{GObject}, Cstring), instance, _iconname)
    nothing
end
function get_names(instance::GThemedIcon)
    ret = ccall(("g_themed_icon_get_names", libgio), Ptr{Cstring}, (Ptr{GObject},), instance)
    ret2 = begin
            _len = length_zt(ret)
            arrtemp = bytestring.(unsafe_wrap(Vector{Cstring}, ret, _len))
            arrtemp
        end
    ret2
end
function prepend_name(instance::GThemedIcon, _iconname::Union{AbstractString, Symbol})
    ret = ccall(("g_themed_icon_prepend_name", libgio), Nothing, (Ptr{GObject}, Cstring), instance, _iconname)
    nothing
end
function equal(instance::GThemedIcon, _icon2::Maybe(GIcon))
    equal(GIcon(instance), _icon2)
end
function hash(instance::GThemedIcon)
    hash(GIcon(instance))
end
function serialize(instance::GThemedIcon)
    serialize(GIcon(instance))
end
function to_string(instance::GThemedIcon)
    to_string(GIcon(instance))
end
function ThreadedSocketService_new(_max_threads::Integer)
    ret = ccall(("g_threaded_socket_service_new", libgio), Ptr{GObject}, (Int32,), _max_threads)
    ret2 = GThreadedSocketServiceLeaf(ret, true)
    ret2
end
function TlsCertificate_new_from_file(_file::Union{AbstractString, Symbol})
    err = err_buf()
    ret = ccall(("g_tls_certificate_new_from_file", libgio), Ptr{GObject}, (Cstring, Ptr{Ptr{GError}}), _file, err)
    check_err(err)
    ret2 = convert(GTlsCertificate, ret, true)
    ret2
end
function TlsCertificate_new_from_file_with_password(_file::Union{AbstractString, Symbol}, _password::Union{AbstractString, Symbol})
    err = err_buf()
    ret = ccall(("g_tls_certificate_new_from_file_with_password", libgio), Ptr{GObject}, (Cstring, Cstring, Ptr{Ptr{GError}}), _file, _password, err)
    check_err(err)
    ret2 = convert(GTlsCertificate, ret, true)
    ret2
end
function TlsCertificate_new_from_files(_cert_file::Union{AbstractString, Symbol}, _key_file::Union{AbstractString, Symbol})
    err = err_buf()
    ret = ccall(("g_tls_certificate_new_from_files", libgio), Ptr{GObject}, (Cstring, Cstring, Ptr{Ptr{GError}}), _cert_file, _key_file, err)
    check_err(err)
    ret2 = convert(GTlsCertificate, ret, true)
    ret2
end
function TlsCertificate_new_from_pem(_data::Union{AbstractString, Symbol}, _length::Integer)
    err = err_buf()
    ret = ccall(("g_tls_certificate_new_from_pem", libgio), Ptr{GObject}, (Cstring, Int64, Ptr{Ptr{GError}}), _data, _length, err)
    check_err(err)
    ret2 = convert(GTlsCertificate, ret, true)
    ret2
end
function TlsCertificate_new_from_pkcs11_uris(_pkcs11_uri::Union{AbstractString, Symbol}, _private_key_pkcs11_uri::Maybe(Union{AbstractString, Symbol}))
    _private_key_pkcs11_uri_maybe = nothing_to_null(_private_key_pkcs11_uri)
    err = err_buf()
    ret = ccall(("g_tls_certificate_new_from_pkcs11_uris", libgio), Ptr{GObject}, (Cstring, Cstring, Ptr{Ptr{GError}}), _pkcs11_uri, _private_key_pkcs11_uri_maybe, err)
    check_err(err)
    ret2 = convert(GTlsCertificate, ret, true)
    ret2
end
function TlsCertificate_new_from_pkcs12(_data, _password::Maybe(Union{AbstractString, Symbol}))
    _data_arr = convert(Vector{UInt8}, _data)
    _password_maybe = nothing_to_null(_password)
    _length = length(_data)
    err = err_buf()
    ret = ccall(("g_tls_certificate_new_from_pkcs12", libgio), Ptr{GObject}, (Ptr{UInt8}, UInt64, Cstring, Ptr{Ptr{GError}}), _data_arr, _length, _password_maybe, err)
    check_err(err)
    ret2 = convert(GTlsCertificate, ret, true)
    ret2
end
function list_new_from_file(_file::Union{AbstractString, Symbol})
    err = err_buf()
    ret = ccall(("g_tls_certificate_list_new_from_file", libgio), Ptr{GLib._GList{Ptr{GObject}}}, (Cstring, Ptr{Ptr{GError}}), _file, err)
    check_err(err)
    ret2 = GLib.GList(ret, true)
    ret2
end
function get_dns_names(instance::GTlsCertificate)
    ret = ccall(("g_tls_certificate_get_dns_names", libgio), Ptr{GPtrArray}, (Ptr{GObject},), instance)
    ret
end
function get_ip_addresses(instance::GTlsCertificate)
    ret = ccall(("g_tls_certificate_get_ip_addresses", libgio), Ptr{GPtrArray}, (Ptr{GObject},), instance)
    ret
end
function get_issuer(instance::GTlsCertificate)
    ret = ccall(("g_tls_certificate_get_issuer", libgio), Ptr{GObject}, (Ptr{GObject},), instance)
    ret2 = convert_if_not_null(GTlsCertificate, ret, false)
    ret2
end
function get_issuer_name(instance::GTlsCertificate)
    ret = ccall(("g_tls_certificate_get_issuer_name", libgio), Cstring, (Ptr{GObject},), instance)
    ret2 = string_or_nothing(ret, true)
    ret2
end
function get_not_valid_after(instance::GTlsCertificate)
    ret = ccall(("g_tls_certificate_get_not_valid_after", libgio), Ptr{GDateTime}, (Ptr{GObject},), instance)
    ret2 = convert_if_not_null(GDateTime, ret, true)
    ret2
end
function get_not_valid_before(instance::GTlsCertificate)
    ret = ccall(("g_tls_certificate_get_not_valid_before", libgio), Ptr{GDateTime}, (Ptr{GObject},), instance)
    ret2 = convert_if_not_null(GDateTime, ret, true)
    ret2
end
function get_subject_name(instance::GTlsCertificate)
    ret = ccall(("g_tls_certificate_get_subject_name", libgio), Cstring, (Ptr{GObject},), instance)
    ret2 = string_or_nothing(ret, true)
    ret2
end
function is_same(instance::GTlsCertificate, _cert_two::GTlsCertificate)
    ret = ccall(("g_tls_certificate_is_same", libgio), Cint, (Ptr{GObject}, Ptr{GObject}), instance, _cert_two)
    ret2 = convert(Bool, ret)
    ret2
end
function verify(instance::GTlsCertificate, _identity::Maybe(GSocketConnectable), _trusted_ca::Maybe(GTlsCertificate))
    _identity_maybe = nothing_to_null(_identity)
    _trusted_ca_maybe = nothing_to_null(_trusted_ca)
    ret = ccall(("g_tls_certificate_verify", libgio), UInt32, (Ptr{GObject}, Ptr{GObject}, Ptr{GObject}), instance, _identity_maybe, _trusted_ca_maybe)
    ret2 = TlsCertificateFlags(ret)
    ret2
end
function emit_accept_certificate(instance::GTlsConnection, _peer_cert::GTlsCertificate, _errors)
    ret = ccall(("g_tls_connection_emit_accept_certificate", libgio), Cint, (Ptr{GObject}, Ptr{GObject}, UInt32), instance, _peer_cert, _errors)
    ret2 = convert(Bool, ret)
    ret2
end
function get_certificate(instance::GTlsConnection)
    ret = ccall(("g_tls_connection_get_certificate", libgio), Ptr{GObject}, (Ptr{GObject},), instance)
    ret2 = convert_if_not_null(GTlsCertificate, ret, false)
    ret2
end
function get_ciphersuite_name(instance::GTlsConnection)
    ret = ccall(("g_tls_connection_get_ciphersuite_name", libgio), Cstring, (Ptr{GObject},), instance)
    ret2 = string_or_nothing(ret, true)
    ret2
end
function get_database(instance::GTlsConnection)
    ret = ccall(("g_tls_connection_get_database", libgio), Ptr{GObject}, (Ptr{GObject},), instance)
    ret2 = convert_if_not_null(GTlsDatabase, ret, false)
    ret2
end
function get_interaction(instance::GTlsConnection)
    ret = ccall(("g_tls_connection_get_interaction", libgio), Ptr{GObject}, (Ptr{GObject},), instance)
    ret2 = convert_if_not_null(GTlsInteraction, ret, false)
    ret2
end
function get_negotiated_protocol(instance::GTlsConnection)
    ret = ccall(("g_tls_connection_get_negotiated_protocol", libgio), Cstring, (Ptr{GObject},), instance)
    ret2 = string_or_nothing(ret, false)
    ret2
end
function get_peer_certificate(instance::GTlsConnection)
    ret = ccall(("g_tls_connection_get_peer_certificate", libgio), Ptr{GObject}, (Ptr{GObject},), instance)
    ret2 = convert_if_not_null(GTlsCertificate, ret, false)
    ret2
end
function get_peer_certificate_errors(instance::GTlsConnection)
    ret = ccall(("g_tls_connection_get_peer_certificate_errors", libgio), UInt32, (Ptr{GObject},), instance)
    ret2 = TlsCertificateFlags(ret)
    ret2
end
function get_protocol_version(instance::GTlsConnection)
    ret = ccall(("g_tls_connection_get_protocol_version", libgio), UInt32, (Ptr{GObject},), instance)
    ret2 = TlsProtocolVersion(ret)
    ret2
end
function get_require_close_notify(instance::GTlsConnection)
    ret = ccall(("g_tls_connection_get_require_close_notify", libgio), Cint, (Ptr{GObject},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function handshake(instance::GTlsConnection, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_tls_connection_handshake", libgio), Cint, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _cancellable_maybe, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function handshake_async(instance::GTlsConnection, _io_priority::Integer, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    ret = ccall(("g_tls_connection_handshake_async", libgio), Nothing, (Ptr{GObject}, Int32, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _io_priority, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function handshake_finish(instance::GTlsConnection, _result::GAsyncResult)
    err = err_buf()
    ret = ccall(("g_tls_connection_handshake_finish", libgio), Cint, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _result, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function set_advertised_protocols(instance::GTlsConnection, _protocols)
    _protocols_maybe = nothing_to_null(_protocols)
    ret = ccall(("g_tls_connection_set_advertised_protocols", libgio), Nothing, (Ptr{GObject}, Ptr{Cstring}), instance, _protocols_maybe)
    nothing
end
function set_certificate(instance::GTlsConnection, _certificate::GTlsCertificate)
    ret = ccall(("g_tls_connection_set_certificate", libgio), Nothing, (Ptr{GObject}, Ptr{GObject}), instance, _certificate)
    nothing
end
function set_database(instance::GTlsConnection, _database::Maybe(GTlsDatabase))
    _database_maybe = nothing_to_null(_database)
    ret = ccall(("g_tls_connection_set_database", libgio), Nothing, (Ptr{GObject}, Ptr{GObject}), instance, _database_maybe)
    nothing
end
function set_interaction(instance::GTlsConnection, _interaction::Maybe(GTlsInteraction))
    _interaction_maybe = nothing_to_null(_interaction)
    ret = ccall(("g_tls_connection_set_interaction", libgio), Nothing, (Ptr{GObject}, Ptr{GObject}), instance, _interaction_maybe)
    nothing
end
function set_require_close_notify(instance::GTlsConnection, _require_close_notify::Bool)
    ret = ccall(("g_tls_connection_set_require_close_notify", libgio), Nothing, (Ptr{GObject}, Cint), instance, _require_close_notify)
    nothing
end
function create_certificate_handle(instance::GTlsDatabase, _certificate::GTlsCertificate)
    ret = ccall(("g_tls_database_create_certificate_handle", libgio), Cstring, (Ptr{GObject}, Ptr{GObject}), instance, _certificate)
    ret2 = string_or_nothing(ret, true)
    ret2
end
function lookup_certificate_for_handle(instance::GTlsDatabase, _handle::Union{AbstractString, Symbol}, _interaction::Maybe(GTlsInteraction), _flags, _cancellable::Maybe(GCancellable))
    _interaction_maybe = nothing_to_null(_interaction)
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_tls_database_lookup_certificate_for_handle", libgio), Ptr{GObject}, (Ptr{GObject}, Cstring, Ptr{GObject}, UInt32, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _handle, _interaction_maybe, _flags, _cancellable_maybe, err)
    check_err(err)
    ret2 = convert_if_not_null(GTlsCertificate, ret, true)
    ret2
end
function lookup_certificate_for_handle_async(instance::GTlsDatabase, _handle::Union{AbstractString, Symbol}, _interaction::Maybe(GTlsInteraction), _flags, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _interaction_maybe = nothing_to_null(_interaction)
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    ret = ccall(("g_tls_database_lookup_certificate_for_handle_async", libgio), Nothing, (Ptr{GObject}, Cstring, Ptr{GObject}, UInt32, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _handle, _interaction_maybe, _flags, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function lookup_certificate_for_handle_finish(instance::GTlsDatabase, _result::GAsyncResult)
    err = err_buf()
    ret = ccall(("g_tls_database_lookup_certificate_for_handle_finish", libgio), Ptr{GObject}, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _result, err)
    check_err(err)
    ret2 = convert(GTlsCertificate, ret, true)
    ret2
end
function lookup_certificate_issuer(instance::GTlsDatabase, _certificate::GTlsCertificate, _interaction::Maybe(GTlsInteraction), _flags, _cancellable::Maybe(GCancellable))
    _interaction_maybe = nothing_to_null(_interaction)
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_tls_database_lookup_certificate_issuer", libgio), Ptr{GObject}, (Ptr{GObject}, Ptr{GObject}, Ptr{GObject}, UInt32, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _certificate, _interaction_maybe, _flags, _cancellable_maybe, err)
    check_err(err)
    ret2 = convert(GTlsCertificate, ret, true)
    ret2
end
function lookup_certificate_issuer_async(instance::GTlsDatabase, _certificate::GTlsCertificate, _interaction::Maybe(GTlsInteraction), _flags, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _interaction_maybe = nothing_to_null(_interaction)
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    ret = ccall(("g_tls_database_lookup_certificate_issuer_async", libgio), Nothing, (Ptr{GObject}, Ptr{GObject}, Ptr{GObject}, UInt32, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _certificate, _interaction_maybe, _flags, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function lookup_certificate_issuer_finish(instance::GTlsDatabase, _result::GAsyncResult)
    err = err_buf()
    ret = ccall(("g_tls_database_lookup_certificate_issuer_finish", libgio), Ptr{GObject}, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _result, err)
    check_err(err)
    ret2 = convert(GTlsCertificate, ret, true)
    ret2
end
function lookup_certificates_issued_by_async(instance::GTlsDatabase, _issuer_raw_dn, _interaction::Maybe(GTlsInteraction), _flags, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _interaction_maybe = nothing_to_null(_interaction)
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    ret = ccall(("g_tls_database_lookup_certificates_issued_by_async", libgio), Nothing, (Ptr{GObject}, Ptr{GByteArray}, Ptr{GObject}, UInt32, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _issuer_raw_dn, _interaction_maybe, _flags, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function lookup_certificates_issued_by_finish(instance::GTlsDatabase, _result::GAsyncResult)
    err = err_buf()
    ret = ccall(("g_tls_database_lookup_certificates_issued_by_finish", libgio), Ptr{GLib._GList{Ptr{GObject}}}, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _result, err)
    check_err(err)
    ret2 = GLib.GList(ret, true)
    ret2
end
function verify_chain(instance::GTlsDatabase, _chain::GTlsCertificate, _purpose::Union{AbstractString, Symbol}, _identity::Maybe(GSocketConnectable), _interaction::Maybe(GTlsInteraction), _flags, _cancellable::Maybe(GCancellable))
    _identity_maybe = nothing_to_null(_identity)
    _interaction_maybe = nothing_to_null(_interaction)
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_tls_database_verify_chain", libgio), UInt32, (Ptr{GObject}, Ptr{GObject}, Cstring, Ptr{GObject}, Ptr{GObject}, UInt32, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _chain, _purpose, _identity_maybe, _interaction_maybe, _flags, _cancellable_maybe, err)
    check_err(err)
    ret2 = TlsCertificateFlags(ret)
    ret2
end
function verify_chain_async(instance::GTlsDatabase, _chain::GTlsCertificate, _purpose::Union{AbstractString, Symbol}, _identity::Maybe(GSocketConnectable), _interaction::Maybe(GTlsInteraction), _flags, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _identity_maybe = nothing_to_null(_identity)
    _interaction_maybe = nothing_to_null(_interaction)
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    ret = ccall(("g_tls_database_verify_chain_async", libgio), Nothing, (Ptr{GObject}, Ptr{GObject}, Cstring, Ptr{GObject}, Ptr{GObject}, UInt32, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _chain, _purpose, _identity_maybe, _interaction_maybe, _flags, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function verify_chain_finish(instance::GTlsDatabase, _result::GAsyncResult)
    err = err_buf()
    ret = ccall(("g_tls_database_verify_chain_finish", libgio), UInt32, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _result, err)
    check_err(err)
    ret2 = TlsCertificateFlags(ret)
    ret2
end
function ask_password(instance::GTlsInteraction, _password::GTlsPassword, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_tls_interaction_ask_password", libgio), UInt32, (Ptr{GObject}, Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _password, _cancellable_maybe, err)
    check_err(err)
    ret2 = TlsInteractionResult(ret)
    ret2
end
function ask_password_async(instance::GTlsInteraction, _password::GTlsPassword, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    ret = ccall(("g_tls_interaction_ask_password_async", libgio), Nothing, (Ptr{GObject}, Ptr{GObject}, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _password, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function ask_password_finish(instance::GTlsInteraction, _result::GAsyncResult)
    err = err_buf()
    ret = ccall(("g_tls_interaction_ask_password_finish", libgio), UInt32, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _result, err)
    check_err(err)
    ret2 = TlsInteractionResult(ret)
    ret2
end
function invoke_ask_password(instance::GTlsInteraction, _password::GTlsPassword, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_tls_interaction_invoke_ask_password", libgio), UInt32, (Ptr{GObject}, Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _password, _cancellable_maybe, err)
    check_err(err)
    ret2 = TlsInteractionResult(ret)
    ret2
end
function invoke_request_certificate(instance::GTlsInteraction, _connection::GTlsConnection, _flags, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_tls_interaction_invoke_request_certificate", libgio), UInt32, (Ptr{GObject}, Ptr{GObject}, UInt32, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _connection, _flags, _cancellable_maybe, err)
    check_err(err)
    ret2 = TlsInteractionResult(ret)
    ret2
end
function request_certificate(instance::GTlsInteraction, _connection::GTlsConnection, _flags, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_tls_interaction_request_certificate", libgio), UInt32, (Ptr{GObject}, Ptr{GObject}, UInt32, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _connection, _flags, _cancellable_maybe, err)
    check_err(err)
    ret2 = TlsInteractionResult(ret)
    ret2
end
function request_certificate_async(instance::GTlsInteraction, _connection::GTlsConnection, _flags, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    ret = ccall(("g_tls_interaction_request_certificate_async", libgio), Nothing, (Ptr{GObject}, Ptr{GObject}, UInt32, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _connection, _flags, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function request_certificate_finish(instance::GTlsInteraction, _result::GAsyncResult)
    err = err_buf()
    ret = ccall(("g_tls_interaction_request_certificate_finish", libgio), UInt32, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _result, err)
    check_err(err)
    ret2 = TlsInteractionResult(ret)
    ret2
end
function TlsPassword_new(_flags, _description::Union{AbstractString, Symbol})
    ret = ccall(("g_tls_password_new", libgio), Ptr{GObject}, (UInt32, Cstring), _flags, _description)
    ret2 = GTlsPasswordLeaf(ret, true)
    ret2
end
function get_description(instance::GTlsPassword)
    ret = ccall(("g_tls_password_get_description", libgio), Cstring, (Ptr{GObject},), instance)
    ret2 = string_or_nothing(ret, false)
    ret2
end
function get_flags(instance::GTlsPassword)
    ret = ccall(("g_tls_password_get_flags", libgio), UInt32, (Ptr{GObject},), instance)
    ret2 = TlsPasswordFlags(ret)
    ret2
end
function get_value(instance::GTlsPassword)
    m_length = Ref{UInt64}()
    ret = ccall(("g_tls_password_get_value", libgio), Ptr{UInt8}, (Ptr{GObject}, Ptr{UInt64}), instance, m_length)
    ret2 = collect(unsafe_wrap(Vector{UInt8}, ret, m_length[]))
    _length = m_length[]
    ret2
end
function get_warning(instance::GTlsPassword)
    ret = ccall(("g_tls_password_get_warning", libgio), Cstring, (Ptr{GObject},), instance)
    ret2 = string_or_nothing(ret, false)
    ret2
end
function set_description(instance::GTlsPassword, _description::Union{AbstractString, Symbol})
    ret = ccall(("g_tls_password_set_description", libgio), Nothing, (Ptr{GObject}, Cstring), instance, _description)
    nothing
end
function set_flags(instance::GTlsPassword, _flags)
    ret = ccall(("g_tls_password_set_flags", libgio), Nothing, (Ptr{GObject}, UInt32), instance, _flags)
    nothing
end
function set_value(instance::GTlsPassword, _value)
    _value_arr = convert(Vector{UInt8}, _value)
    _length = length(_value)
    ret = ccall(("g_tls_password_set_value", libgio), Nothing, (Ptr{GObject}, Ptr{UInt8}, Int64), instance, _value_arr, _length)
    nothing
end
function set_warning(instance::GTlsPassword, _warning::Union{AbstractString, Symbol})
    ret = ccall(("g_tls_password_set_warning", libgio), Nothing, (Ptr{GObject}, Cstring), instance, _warning)
    nothing
end
function receive_credentials(instance::GUnixConnection, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_unix_connection_receive_credentials", libgio), Ptr{GObject}, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _cancellable_maybe, err)
    check_err(err)
    ret2 = convert(GCredentials, ret, true)
    ret2
end
function receive_credentials_async(instance::GUnixConnection, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    ret = ccall(("g_unix_connection_receive_credentials_async", libgio), Nothing, (Ptr{GObject}, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function receive_credentials_finish(instance::GUnixConnection, _result::GAsyncResult)
    err = err_buf()
    ret = ccall(("g_unix_connection_receive_credentials_finish", libgio), Ptr{GObject}, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _result, err)
    check_err(err)
    ret2 = convert(GCredentials, ret, true)
    ret2
end
function receive_fd(instance::GUnixConnection, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_unix_connection_receive_fd", libgio), Int32, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _cancellable_maybe, err)
    check_err(err)
    ret
end
function send_credentials(instance::GUnixConnection, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_unix_connection_send_credentials", libgio), Cint, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _cancellable_maybe, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function send_credentials_async(instance::GUnixConnection, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    ret = ccall(("g_unix_connection_send_credentials_async", libgio), Nothing, (Ptr{GObject}, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function send_credentials_finish(instance::GUnixConnection, _result::GAsyncResult)
    err = err_buf()
    ret = ccall(("g_unix_connection_send_credentials_finish", libgio), Cint, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _result, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function send_fd(instance::GUnixConnection, _fd::Integer, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_unix_connection_send_fd", libgio), Cint, (Ptr{GObject}, Int32, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _fd, _cancellable_maybe, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function UnixCredentialsMessage_new()
    ret = ccall(("g_unix_credentials_message_new", libgio), Ptr{GObject}, ())
    ret2 = GUnixCredentialsMessageLeaf(ret, true)
    ret2
end
function UnixCredentialsMessage_new_with_credentials(_credentials::GCredentials)
    ret = ccall(("g_unix_credentials_message_new_with_credentials", libgio), Ptr{GObject}, (Ptr{GObject},), _credentials)
    ret2 = GUnixCredentialsMessageLeaf(ret, true)
    ret2
end
function is_supported()
    ret = ccall(("g_unix_credentials_message_is_supported", libgio), Cint, ())
    ret2 = convert(Bool, ret)
    ret2
end
function get_credentials(instance::GUnixCredentialsMessage)
    ret = ccall(("g_unix_credentials_message_get_credentials", libgio), Ptr{GObject}, (Ptr{GObject},), instance)
    ret2 = convert(GCredentials, ret, false)
    ret2
end
function get_local()
    ret = ccall(("g_vfs_get_local", libgio), Ptr{GObject}, ())
    ret2 = convert(GVfs, ret, false)
    ret2
end
function get_file_for_path(instance::GVfs, _path::Union{AbstractString, Symbol})
    ret = ccall(("g_vfs_get_file_for_path", libgio), Ptr{GObject}, (Ptr{GObject}, Cstring), instance, _path)
    ret2 = begin
            leaftype = GLib.find_leaf_type(ret)
            convert(leaftype, ret, true)
        end
    ret2
end
function get_file_for_uri(instance::GVfs, _uri::Union{AbstractString, Symbol})
    ret = ccall(("g_vfs_get_file_for_uri", libgio), Ptr{GObject}, (Ptr{GObject}, Cstring), instance, _uri)
    ret2 = begin
            leaftype = GLib.find_leaf_type(ret)
            convert(leaftype, ret, true)
        end
    ret2
end
function get_supported_uri_schemes(instance::GVfs)
    ret = ccall(("g_vfs_get_supported_uri_schemes", libgio), Ptr{Cstring}, (Ptr{GObject},), instance)
    ret2 = begin
            _len = length_zt(ret)
            arrtemp = bytestring.(unsafe_wrap(Vector{Cstring}, ret, _len))
            arrtemp
        end
    ret2
end
function is_active(instance::GVfs)
    ret = ccall(("g_vfs_is_active", libgio), Cint, (Ptr{GObject},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function parse_name(instance::GVfs, _parse_name::Union{AbstractString, Symbol})
    ret = ccall(("g_vfs_parse_name", libgio), Ptr{GObject}, (Ptr{GObject}, Cstring), instance, _parse_name)
    ret2 = begin
            leaftype = GLib.find_leaf_type(ret)
            convert(leaftype, ret, true)
        end
    ret2
end
function unregister_uri_scheme(instance::GVfs, _scheme::Union{AbstractString, Symbol})
    ret = ccall(("g_vfs_unregister_uri_scheme", libgio), Cint, (Ptr{GObject}, Cstring), instance, _scheme)
    ret2 = convert(Bool, ret)
    ret2
end
function get()
    ret = ccall(("g_volume_monitor_get", libgio), Ptr{GObject}, ())
    ret2 = convert(GVolumeMonitor, ret, true)
    ret2
end
function get_connected_drives(instance::GVolumeMonitor)
    ret = ccall(("g_volume_monitor_get_connected_drives", libgio), Ptr{GLib._GList{Ptr{GObject}}}, (Ptr{GObject},), instance)
    ret2 = GLib.GList(ret, true)
    ret2
end
function get_mount_for_uuid(instance::GVolumeMonitor, _uuid::Union{AbstractString, Symbol})
    ret = ccall(("g_volume_monitor_get_mount_for_uuid", libgio), Ptr{GObject}, (Ptr{GObject}, Cstring), instance, _uuid)
    ret2 = GLib.find_leaf_type_if_not_null(ret, true)
    ret2
end
function get_mounts(instance::GVolumeMonitor)
    ret = ccall(("g_volume_monitor_get_mounts", libgio), Ptr{GLib._GList{Ptr{GObject}}}, (Ptr{GObject},), instance)
    ret2 = GLib.GList(ret, true)
    ret2
end
function get_volume_for_uuid(instance::GVolumeMonitor, _uuid::Union{AbstractString, Symbol})
    ret = ccall(("g_volume_monitor_get_volume_for_uuid", libgio), Ptr{GObject}, (Ptr{GObject}, Cstring), instance, _uuid)
    ret2 = GLib.find_leaf_type_if_not_null(ret, true)
    ret2
end
function get_volumes(instance::GVolumeMonitor)
    ret = ccall(("g_volume_monitor_get_volumes", libgio), Ptr{GLib._GList{Ptr{GObject}}}, (Ptr{GObject},), instance)
    ret2 = GLib.GList(ret, true)
    ret2
end
function ZlibCompressor_new(_format, _level::Integer)
    ret = ccall(("g_zlib_compressor_new", libgio), Ptr{GObject}, (UInt32, Int32), _format, _level)
    ret2 = GZlibCompressorLeaf(ret, true)
    ret2
end
function get_file_info(instance::GZlibCompressor)
    ret = ccall(("g_zlib_compressor_get_file_info", libgio), Ptr{GObject}, (Ptr{GObject},), instance)
    ret2 = convert_if_not_null(GFileInfo, ret, false)
    ret2
end
function set_file_info(instance::GZlibCompressor, _file_info::Maybe(GFileInfo))
    _file_info_maybe = nothing_to_null(_file_info)
    ret = ccall(("g_zlib_compressor_set_file_info", libgio), Nothing, (Ptr{GObject}, Ptr{GObject}), instance, _file_info_maybe)
    nothing
end
function convert(instance::GZlibCompressor, _inbuf, _outbuf, _flags)
    convert(GConverter(instance), _inbuf, _outbuf, _flags)
end
function convert_bytes(instance::GZlibCompressor, _bytes::GBytes)
    convert_bytes(GConverter(instance), _bytes)
end
function reset(instance::GZlibCompressor)
    reset(GConverter(instance))
end
function ZlibDecompressor_new(_format)
    ret = ccall(("g_zlib_decompressor_new", libgio), Ptr{GObject}, (UInt32,), _format)
    ret2 = GZlibDecompressorLeaf(ret, true)
    ret2
end
function get_file_info(instance::GZlibDecompressor)
    ret = ccall(("g_zlib_decompressor_get_file_info", libgio), Ptr{GObject}, (Ptr{GObject},), instance)
    ret2 = convert_if_not_null(GFileInfo, ret, false)
    ret2
end
function convert(instance::GZlibDecompressor, _inbuf, _outbuf, _flags)
    convert(GConverter(instance), _inbuf, _outbuf, _flags)
end
function convert_bytes(instance::GZlibDecompressor, _bytes::GBytes)
    convert_bytes(GConverter(instance), _bytes)
end
function reset(instance::GZlibDecompressor)
    reset(GConverter(instance))
end
function name_is_valid(_action_name::Union{AbstractString, Symbol})
    ret = ccall(("g_action_name_is_valid", libgio), Cint, (Cstring,), _action_name)
    ret2 = convert(Bool, ret)
    ret2
end
function parse_detailed_name(_detailed_name::Union{AbstractString, Symbol})
    m_action_name = Ref{Cstring}()
    m_target_value = Ref{Ptr{GVariant}}()
    err = err_buf()
    ret = ccall(("g_action_parse_detailed_name", libgio), Cint, (Cstring, Ptr{Cstring}, Ptr{Ptr{GVariant}}, Ptr{Ptr{GError}}), _detailed_name, m_action_name, m_target_value, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    _action_name = m_action_name[]
    _action_name = string_or_nothing(_action_name, true)
    _target_value = m_target_value[]
    _target_value = convert(Maybe(GVariant), _target_value)
    (ret2, _action_name, _target_value)
end
function print_detailed_name(_action_name::Union{AbstractString, Symbol}, _target_value::Maybe(GVariant))
    _target_value_maybe = nothing_to_null(_target_value)
    ret = ccall(("g_action_print_detailed_name", libgio), Cstring, (Cstring, Ptr{GVariant}), _action_name, _target_value_maybe)
    ret2 = string_or_nothing(ret, true)
    ret2
end
function activate(instance::GAction, _parameter::Maybe(GVariant))
    _parameter_maybe = nothing_to_null(_parameter)
    ret = ccall(("g_action_activate", libgio), Nothing, (Ptr{GObject}, Ptr{GVariant}), instance, _parameter_maybe)
    nothing
end
function change_state(instance::GAction, _value::GVariant)
    ret = ccall(("g_action_change_state", libgio), Nothing, (Ptr{GObject}, Ptr{GVariant}), instance, _value)
    nothing
end
function get_enabled(instance::GAction)
    ret = ccall(("g_action_get_enabled", libgio), Cint, (Ptr{GObject},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function get_name(instance::GAction)
    ret = ccall(("g_action_get_name", libgio), Cstring, (Ptr{GObject},), instance)
    ret2 = string_or_nothing(ret, false)
    ret2
end
function get_parameter_type(instance::GAction)
    ret = ccall(("g_action_get_parameter_type", libgio), Ptr{GVariantType}, (Ptr{GObject},), instance)
    ret2 = convert_if_not_null(GVariantType, ret, false)
    ret2
end
function get_state(instance::GAction)
    ret = ccall(("g_action_get_state", libgio), Ptr{GVariant}, (Ptr{GObject},), instance)
    ret2 = convert(GVariant, ret)
    ret2
end
function get_state_hint(instance::GAction)
    ret = ccall(("g_action_get_state_hint", libgio), Ptr{GVariant}, (Ptr{GObject},), instance)
    ret2 = convert(GVariant, ret)
    ret2
end
function get_state_type(instance::GAction)
    ret = ccall(("g_action_get_state_type", libgio), Ptr{GVariantType}, (Ptr{GObject},), instance)
    ret2 = convert_if_not_null(GVariantType, ret, false)
    ret2
end
function action_added(instance::GActionGroup, _action_name::Union{AbstractString, Symbol})
    ret = ccall(("g_action_group_action_added", libgio), Nothing, (Ptr{GObject}, Cstring), instance, _action_name)
    nothing
end
function action_enabled_changed(instance::GActionGroup, _action_name::Union{AbstractString, Symbol}, _enabled::Bool)
    ret = ccall(("g_action_group_action_enabled_changed", libgio), Nothing, (Ptr{GObject}, Cstring, Cint), instance, _action_name, _enabled)
    nothing
end
function action_removed(instance::GActionGroup, _action_name::Union{AbstractString, Symbol})
    ret = ccall(("g_action_group_action_removed", libgio), Nothing, (Ptr{GObject}, Cstring), instance, _action_name)
    nothing
end
function action_state_changed(instance::GActionGroup, _action_name::Union{AbstractString, Symbol}, _state::GVariant)
    ret = ccall(("g_action_group_action_state_changed", libgio), Nothing, (Ptr{GObject}, Cstring, Ptr{GVariant}), instance, _action_name, _state)
    nothing
end
function activate_action(instance::GActionGroup, _action_name::Union{AbstractString, Symbol}, _parameter::Maybe(GVariant))
    _parameter_maybe = nothing_to_null(_parameter)
    ret = ccall(("g_action_group_activate_action", libgio), Nothing, (Ptr{GObject}, Cstring, Ptr{GVariant}), instance, _action_name, _parameter_maybe)
    nothing
end
function change_action_state(instance::GActionGroup, _action_name::Union{AbstractString, Symbol}, _value::GVariant)
    ret = ccall(("g_action_group_change_action_state", libgio), Nothing, (Ptr{GObject}, Cstring, Ptr{GVariant}), instance, _action_name, _value)
    nothing
end
function get_action_enabled(instance::GActionGroup, _action_name::Union{AbstractString, Symbol})
    ret = ccall(("g_action_group_get_action_enabled", libgio), Cint, (Ptr{GObject}, Cstring), instance, _action_name)
    ret2 = convert(Bool, ret)
    ret2
end
function get_action_parameter_type(instance::GActionGroup, _action_name::Union{AbstractString, Symbol})
    ret = ccall(("g_action_group_get_action_parameter_type", libgio), Ptr{GVariantType}, (Ptr{GObject}, Cstring), instance, _action_name)
    ret2 = convert_if_not_null(GVariantType, ret, false)
    ret2
end
function get_action_state(instance::GActionGroup, _action_name::Union{AbstractString, Symbol})
    ret = ccall(("g_action_group_get_action_state", libgio), Ptr{GVariant}, (Ptr{GObject}, Cstring), instance, _action_name)
    ret2 = convert(GVariant, ret)
    ret2
end
function get_action_state_hint(instance::GActionGroup, _action_name::Union{AbstractString, Symbol})
    ret = ccall(("g_action_group_get_action_state_hint", libgio), Ptr{GVariant}, (Ptr{GObject}, Cstring), instance, _action_name)
    ret2 = convert(GVariant, ret)
    ret2
end
function get_action_state_type(instance::GActionGroup, _action_name::Union{AbstractString, Symbol})
    ret = ccall(("g_action_group_get_action_state_type", libgio), Ptr{GVariantType}, (Ptr{GObject}, Cstring), instance, _action_name)
    ret2 = convert_if_not_null(GVariantType, ret, false)
    ret2
end
function has_action(instance::GActionGroup, _action_name::Union{AbstractString, Symbol})
    ret = ccall(("g_action_group_has_action", libgio), Cint, (Ptr{GObject}, Cstring), instance, _action_name)
    ret2 = convert(Bool, ret)
    ret2
end
function list_actions(instance::GActionGroup)
    ret = ccall(("g_action_group_list_actions", libgio), Ptr{Cstring}, (Ptr{GObject},), instance)
    ret2 = begin
            _len = length_zt(ret)
            arrtemp = bytestring.(unsafe_wrap(Vector{Cstring}, ret, _len))
            GLib.g_strfreev(ret)
            arrtemp
        end
    ret2
end
function query_action(instance::GActionGroup, _action_name::Union{AbstractString, Symbol})
    m_enabled = Ref{Cint}()
    m_parameter_type = Ref{Ptr{GVariantType}}()
    m_state_type = Ref{Ptr{GVariantType}}()
    m_state_hint = Ref{Ptr{GVariant}}()
    m_state = Ref{Ptr{GVariant}}()
    ret = ccall(("g_action_group_query_action", libgio), Cint, (Ptr{GObject}, Cstring, Ptr{Cint}, Ptr{Ptr{GVariantType}}, Ptr{Ptr{GVariantType}}, Ptr{Ptr{GVariant}}, Ptr{Ptr{GVariant}}), instance, _action_name, m_enabled, m_parameter_type, m_state_type, m_state_hint, m_state)
    ret2 = convert(Bool, ret)
    _enabled = m_enabled[]
    _enabled = convert(Bool, _enabled)
    _parameter_type = m_parameter_type[]
    _parameter_type = convert(GVariantType, _parameter_type, false)
    _state_type = m_state_type[]
    _state_type = convert(GVariantType, _state_type, false)
    _state_hint = m_state_hint[]
    _state_hint = convert(GVariant, _state_hint)
    _state = m_state[]
    _state = convert(GVariant, _state)
    (ret2, _enabled, _parameter_type, _state_type, _state_hint, _state)
end
function add_action(instance::GActionMap, _action::GAction)
    ret = ccall(("g_action_map_add_action", libgio), Nothing, (Ptr{GObject}, Ptr{GObject}), instance, _action)
    nothing
end
function lookup_action(instance::GActionMap, _action_name::Union{AbstractString, Symbol})
    ret = ccall(("g_action_map_lookup_action", libgio), Ptr{GObject}, (Ptr{GObject}, Cstring), instance, _action_name)
    ret2 = GLib.find_leaf_type_if_not_null(ret, false)
    ret2
end
function remove_action(instance::GActionMap, _action_name::Union{AbstractString, Symbol})
    ret = ccall(("g_action_map_remove_action", libgio), Nothing, (Ptr{GObject}, Cstring), instance, _action_name)
    nothing
end
function create_from_commandline(_commandline::Union{AbstractString, Symbol}, _application_name::Maybe(Union{AbstractString, Symbol}), _flags)
    _application_name_maybe = nothing_to_null(_application_name)
    err = err_buf()
    ret = ccall(("g_app_info_create_from_commandline", libgio), Ptr{GObject}, (Cstring, Cstring, UInt32, Ptr{Ptr{GError}}), _commandline, _application_name_maybe, _flags, err)
    check_err(err)
    ret2 = begin
            leaftype = GLib.find_leaf_type(ret)
            convert(leaftype, ret, true)
        end
    ret2
end
function get_all()
    ret = ccall(("g_app_info_get_all", libgio), Ptr{GLib._GList{Ptr{GObject}}}, ())
    ret2 = GLib.GList(ret, true)
    ret2
end
function get_all_for_type(_content_type::Union{AbstractString, Symbol})
    ret = ccall(("g_app_info_get_all_for_type", libgio), Ptr{GLib._GList{Ptr{GObject}}}, (Cstring,), _content_type)
    ret2 = GLib.GList(ret, true)
    ret2
end
function get_default_for_type(_content_type::Union{AbstractString, Symbol}, _must_support_uris::Bool)
    ret = ccall(("g_app_info_get_default_for_type", libgio), Ptr{GObject}, (Cstring, Cint), _content_type, _must_support_uris)
    ret2 = GLib.find_leaf_type_if_not_null(ret, true)
    ret2
end
function get_default_for_type_async(_content_type::Union{AbstractString, Symbol}, _must_support_uris::Bool, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    ret = ccall(("g_app_info_get_default_for_type_async", libgio), Nothing, (Cstring, Cint, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), _content_type, _must_support_uris, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function get_default_for_type_finish(_result::GAsyncResult)
    err = err_buf()
    ret = ccall(("g_app_info_get_default_for_type_finish", libgio), Ptr{GObject}, (Ptr{GObject}, Ptr{Ptr{GError}}), _result, err)
    check_err(err)
    ret2 = begin
            leaftype = GLib.find_leaf_type(ret)
            convert(leaftype, ret, true)
        end
    ret2
end
function get_default_for_uri_scheme(_uri_scheme::Union{AbstractString, Symbol})
    ret = ccall(("g_app_info_get_default_for_uri_scheme", libgio), Ptr{GObject}, (Cstring,), _uri_scheme)
    ret2 = GLib.find_leaf_type_if_not_null(ret, true)
    ret2
end
function get_default_for_uri_scheme_async(_uri_scheme::Union{AbstractString, Symbol}, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    ret = ccall(("g_app_info_get_default_for_uri_scheme_async", libgio), Nothing, (Cstring, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), _uri_scheme, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function get_default_for_uri_scheme_finish(_result::GAsyncResult)
    err = err_buf()
    ret = ccall(("g_app_info_get_default_for_uri_scheme_finish", libgio), Ptr{GObject}, (Ptr{GObject}, Ptr{Ptr{GError}}), _result, err)
    check_err(err)
    ret2 = begin
            leaftype = GLib.find_leaf_type(ret)
            convert(leaftype, ret, true)
        end
    ret2
end
function get_fallback_for_type(_content_type::Union{AbstractString, Symbol})
    ret = ccall(("g_app_info_get_fallback_for_type", libgio), Ptr{GLib._GList{Ptr{GObject}}}, (Cstring,), _content_type)
    ret2 = GLib.GList(ret, true)
    ret2
end
function get_recommended_for_type(_content_type::Union{AbstractString, Symbol})
    ret = ccall(("g_app_info_get_recommended_for_type", libgio), Ptr{GLib._GList{Ptr{GObject}}}, (Cstring,), _content_type)
    ret2 = GLib.GList(ret, true)
    ret2
end
function launch_default_for_uri(_uri::Union{AbstractString, Symbol}, _context::Maybe(GAppLaunchContext))
    _context_maybe = nothing_to_null(_context)
    err = err_buf()
    ret = ccall(("g_app_info_launch_default_for_uri", libgio), Cint, (Cstring, Ptr{GObject}, Ptr{Ptr{GError}}), _uri, _context_maybe, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function launch_default_for_uri_async(_uri::Union{AbstractString, Symbol}, _context::Maybe(GAppLaunchContext), _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _context_maybe = nothing_to_null(_context)
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    ret = ccall(("g_app_info_launch_default_for_uri_async", libgio), Nothing, (Cstring, Ptr{GObject}, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), _uri, _context_maybe, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function launch_default_for_uri_finish(_result::GAsyncResult)
    err = err_buf()
    ret = ccall(("g_app_info_launch_default_for_uri_finish", libgio), Cint, (Ptr{GObject}, Ptr{Ptr{GError}}), _result, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function reset_type_associations(_content_type::Union{AbstractString, Symbol})
    ret = ccall(("g_app_info_reset_type_associations", libgio), Nothing, (Cstring,), _content_type)
    nothing
end
function add_supports_type(instance::GAppInfo, _content_type::Union{AbstractString, Symbol})
    err = err_buf()
    ret = ccall(("g_app_info_add_supports_type", libgio), Cint, (Ptr{GObject}, Cstring, Ptr{Ptr{GError}}), instance, _content_type, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function can_delete(instance::GAppInfo)
    ret = ccall(("g_app_info_can_delete", libgio), Cint, (Ptr{GObject},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function can_remove_supports_type(instance::GAppInfo)
    ret = ccall(("g_app_info_can_remove_supports_type", libgio), Cint, (Ptr{GObject},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function delete(instance::GAppInfo)
    ret = ccall(("g_app_info_delete", libgio), Cint, (Ptr{GObject},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function dup(instance::GAppInfo)
    ret = ccall(("g_app_info_dup", libgio), Ptr{GObject}, (Ptr{GObject},), instance)
    ret2 = begin
            leaftype = GLib.find_leaf_type(ret)
            convert(leaftype, ret, true)
        end
    ret2
end
function equal(instance::GAppInfo, _appinfo2::GAppInfo)
    ret = ccall(("g_app_info_equal", libgio), Cint, (Ptr{GObject}, Ptr{GObject}), instance, _appinfo2)
    ret2 = convert(Bool, ret)
    ret2
end
function get_commandline(instance::GAppInfo)
    ret = ccall(("g_app_info_get_commandline", libgio), Cstring, (Ptr{GObject},), instance)
    ret2 = string_or_nothing(ret, false)
    ret2
end
function get_description(instance::GAppInfo)
    ret = ccall(("g_app_info_get_description", libgio), Cstring, (Ptr{GObject},), instance)
    ret2 = string_or_nothing(ret, false)
    ret2
end
function get_display_name(instance::GAppInfo)
    ret = ccall(("g_app_info_get_display_name", libgio), Cstring, (Ptr{GObject},), instance)
    ret2 = string_or_nothing(ret, false)
    ret2
end
function get_executable(instance::GAppInfo)
    ret = ccall(("g_app_info_get_executable", libgio), Cstring, (Ptr{GObject},), instance)
    ret2 = string_or_nothing(ret, false)
    ret2
end
function get_icon(instance::GAppInfo)
    ret = ccall(("g_app_info_get_icon", libgio), Ptr{GObject}, (Ptr{GObject},), instance)
    ret2 = GLib.find_leaf_type_if_not_null(ret, false)
    ret2
end
function get_id(instance::GAppInfo)
    ret = ccall(("g_app_info_get_id", libgio), Cstring, (Ptr{GObject},), instance)
    ret2 = string_or_nothing(ret, false)
    ret2
end
function get_name(instance::GAppInfo)
    ret = ccall(("g_app_info_get_name", libgio), Cstring, (Ptr{GObject},), instance)
    ret2 = string_or_nothing(ret, false)
    ret2
end
function get_supported_types(instance::GAppInfo)
    ret = ccall(("g_app_info_get_supported_types", libgio), Ptr{Cstring}, (Ptr{GObject},), instance)
    ret2 = begin
            _len = length_zt(ret)
            arrtemp = bytestring.(unsafe_wrap(Vector{Cstring}, ret, _len))
            arrtemp
        end
    ret2
end
function launch(instance::GAppInfo, _files::Maybe(GLib.LList{GLib._GList{Ptr{GObject}}}), _context::Maybe(GAppLaunchContext))
    _files_maybe = nothing_to_null(_files)
    _context_maybe = nothing_to_null(_context)
    err = err_buf()
    ret = ccall(("g_app_info_launch", libgio), Cint, (Ptr{GObject}, Ptr{GLib._GList{Ptr{GObject}}}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _files_maybe, _context_maybe, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function launch_uris(instance::GAppInfo, _uris::Maybe(GLib.LList{GLib._GList{String}}), _context::Maybe(GAppLaunchContext))
    _uris_maybe = nothing_to_null(_uris)
    _context_maybe = nothing_to_null(_context)
    err = err_buf()
    ret = ccall(("g_app_info_launch_uris", libgio), Cint, (Ptr{GObject}, Ptr{GLib._GList{String}}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _uris_maybe, _context_maybe, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function launch_uris_async(instance::GAppInfo, _uris::Maybe(GLib.LList{GLib._GList{String}}), _context::Maybe(GAppLaunchContext), _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _uris_maybe = nothing_to_null(_uris)
    _context_maybe = nothing_to_null(_context)
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    ret = ccall(("g_app_info_launch_uris_async", libgio), Nothing, (Ptr{GObject}, Ptr{GLib._GList{String}}, Ptr{GObject}, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _uris_maybe, _context_maybe, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function launch_uris_finish(instance::GAppInfo, _result::GAsyncResult)
    err = err_buf()
    ret = ccall(("g_app_info_launch_uris_finish", libgio), Cint, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _result, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function remove_supports_type(instance::GAppInfo, _content_type::Union{AbstractString, Symbol})
    err = err_buf()
    ret = ccall(("g_app_info_remove_supports_type", libgio), Cint, (Ptr{GObject}, Cstring, Ptr{Ptr{GError}}), instance, _content_type, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function set_as_default_for_extension(instance::GAppInfo, _extension::Union{AbstractString, Symbol})
    err = err_buf()
    ret = ccall(("g_app_info_set_as_default_for_extension", libgio), Cint, (Ptr{GObject}, Cstring, Ptr{Ptr{GError}}), instance, _extension, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function set_as_default_for_type(instance::GAppInfo, _content_type::Union{AbstractString, Symbol})
    err = err_buf()
    ret = ccall(("g_app_info_set_as_default_for_type", libgio), Cint, (Ptr{GObject}, Cstring, Ptr{Ptr{GError}}), instance, _content_type, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function set_as_last_used_for_type(instance::GAppInfo, _content_type::Union{AbstractString, Symbol})
    err = err_buf()
    ret = ccall(("g_app_info_set_as_last_used_for_type", libgio), Cint, (Ptr{GObject}, Cstring, Ptr{Ptr{GError}}), instance, _content_type, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function should_show(instance::GAppInfo)
    ret = ccall(("g_app_info_should_show", libgio), Cint, (Ptr{GObject},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function supports_files(instance::GAppInfo)
    ret = ccall(("g_app_info_supports_files", libgio), Cint, (Ptr{GObject},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function supports_uris(instance::GAppInfo)
    ret = ccall(("g_app_info_supports_uris", libgio), Cint, (Ptr{GObject},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function init_async(instance::GAsyncInitable, _io_priority::Integer, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    ret = ccall(("g_async_initable_init_async", libgio), Nothing, (Ptr{GObject}, Int32, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _io_priority, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function init_finish(instance::GAsyncInitable, _res::GAsyncResult)
    err = err_buf()
    ret = ccall(("g_async_initable_init_finish", libgio), Cint, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _res, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function new_finish(instance::GAsyncInitable, _res::GAsyncResult)
    err = err_buf()
    ret = ccall(("g_async_initable_new_finish", libgio), Ptr{GObject}, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _res, err)
    check_err(err)
    ret2 = convert(GObject, ret, true)
    ret2
end
function get_source_object(instance::GAsyncResult)
    ret = ccall(("g_async_result_get_source_object", libgio), Ptr{GObject}, (Ptr{GObject},), instance)
    ret2 = convert_if_not_null(GObject, ret, true)
    ret2
end
function get_user_data(instance::GAsyncResult)
    ret = ccall(("g_async_result_get_user_data", libgio), Ptr{Nothing}, (Ptr{GObject},), instance)
    ret2 = convert(Nothing, ret)
    ret2
end
function is_tagged(instance::GAsyncResult, _source_tag::Maybe(Nothing))
    _source_tag_maybe = nothing_to_null(_source_tag)
    ret = ccall(("g_async_result_is_tagged", libgio), Cint, (Ptr{GObject}, Ptr{Nothing}), instance, _source_tag_maybe)
    ret2 = convert(Bool, ret)
    ret2
end
function legacy_propagate_error(instance::GAsyncResult)
    err = err_buf()
    ret = ccall(("g_async_result_legacy_propagate_error", libgio), Cint, (Ptr{GObject}, Ptr{Ptr{GError}}), instance, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function convert(instance::GConverter, _inbuf, _outbuf, _flags)
    _inbuf_arr = convert(Vector{UInt8}, _inbuf)
    _outbuf_arr = convert(Vector{UInt8}, _outbuf)
    m_bytes_read = Ref{UInt64}()
    m_bytes_written = Ref{UInt64}()
    _inbuf_size = length(_inbuf)
    _outbuf_size = length(_outbuf)
    err = err_buf()
    ret = ccall(("g_converter_convert", libgio), UInt32, (Ptr{GObject}, Ptr{UInt8}, UInt64, Ptr{UInt8}, UInt64, UInt32, Ptr{UInt64}, Ptr{UInt64}, Ptr{Ptr{GError}}), instance, _inbuf_arr, _inbuf_size, _outbuf_arr, _outbuf_size, _flags, m_bytes_read, m_bytes_written, err)
    check_err(err)
    ret2 = ConverterResult(ret)
    _bytes_read = m_bytes_read[]
    _bytes_written = m_bytes_written[]
    (ret2, _bytes_read, _bytes_written)
end
function convert_bytes(instance::GConverter, _bytes::GBytes)
    err = err_buf()
    ret = ccall(("g_converter_convert_bytes", libgio), Ptr{GBytes}, (Ptr{GObject}, Ptr{GBytes}, Ptr{Ptr{GError}}), instance, _bytes, err)
    check_err(err)
    ret2 = convert(GBytes, ret, true)
    ret2
end
function reset(instance::GConverter)
    ret = ccall(("g_converter_reset", libgio), Nothing, (Ptr{GObject},), instance)
    nothing
end
function get_object(instance::GDBusInterface)
    ret = ccall(("g_dbus_interface_dup_object", libgio), Ptr{GObject}, (Ptr{GObject},), instance)
    ret2 = GLib.find_leaf_type_if_not_null(ret, true)
    ret2
end
function set_object(instance::GDBusInterface, _object::Maybe(GDBusObject))
    _object_maybe = nothing_to_null(_object)
    ret = ccall(("g_dbus_interface_set_object", libgio), Nothing, (Ptr{GObject}, Ptr{GObject}), instance, _object_maybe)
    nothing
end
function get_interface(instance::GDBusObject, _interface_name::Union{AbstractString, Symbol})
    ret = ccall(("g_dbus_object_get_interface", libgio), Ptr{GObject}, (Ptr{GObject}, Cstring), instance, _interface_name)
    ret2 = GLib.find_leaf_type_if_not_null(ret, true)
    ret2
end
function get_interfaces(instance::GDBusObject)
    ret = ccall(("g_dbus_object_get_interfaces", libgio), Ptr{GLib._GList{Ptr{GObject}}}, (Ptr{GObject},), instance)
    ret2 = GLib.GList(ret, true)
    ret2
end
function get_object_path(instance::GDBusObject)
    ret = ccall(("g_dbus_object_get_object_path", libgio), Cstring, (Ptr{GObject},), instance)
    ret2 = string_or_nothing(ret, false)
    ret2
end
function condition_check(instance::GDatagramBased, _condition)
    ret = ccall(("g_datagram_based_condition_check", libgio), UInt32, (Ptr{GObject}, UInt32), instance, _condition)
    ret2 = IOCondition(ret)
    ret2
end
function condition_wait(instance::GDatagramBased, _condition, _timeout::Integer, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_datagram_based_condition_wait", libgio), Cint, (Ptr{GObject}, UInt32, Int64, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _condition, _timeout, _cancellable_maybe, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function create_source(instance::GDatagramBased, _condition, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    ret = ccall(("g_datagram_based_create_source", libgio), Ptr{_GSource}, (Ptr{GObject}, UInt32, Ptr{GObject}), instance, _condition, _cancellable_maybe)
    ret2 = convert(GSourceLike, ret, true)
    ret2
end
function get_debug_enabled(instance::GDebugController)
    ret = ccall(("g_debug_controller_get_debug_enabled", libgio), Cint, (Ptr{GObject},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function set_debug_enabled(instance::GDebugController, _debug_enabled::Bool)
    ret = ccall(("g_debug_controller_set_debug_enabled", libgio), Nothing, (Ptr{GObject}, Cint), instance, _debug_enabled)
    nothing
end
function new(_base_socket::GDatagramBased, _server_identity::Maybe(GSocketConnectable))
    _server_identity_maybe = nothing_to_null(_server_identity)
    err = err_buf()
    ret = ccall(("g_dtls_client_connection_new", libgio), Ptr{GObject}, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), _base_socket, _server_identity_maybe, err)
    check_err(err)
    ret2 = begin
            leaftype = GLib.find_leaf_type(ret)
            convert(leaftype, ret, true)
        end
    ret2
end
function get_accepted_cas(instance::GDtlsClientConnection)
    ret = ccall(("g_dtls_client_connection_get_accepted_cas", libgio), Ptr{GLib._GList{Ptr{GByteArray}}}, (Ptr{GObject},), instance)
    ret2 = GLib.GList(ret, true)
    ret2
end
function get_server_identity(instance::GDtlsClientConnection)
    ret = ccall(("g_dtls_client_connection_get_server_identity", libgio), Ptr{GObject}, (Ptr{GObject},), instance)
    ret2 = begin
            leaftype = GLib.find_leaf_type(ret)
            convert(leaftype, ret, false)
        end
    ret2
end
function set_server_identity(instance::GDtlsClientConnection, _identity::GSocketConnectable)
    ret = ccall(("g_dtls_client_connection_set_server_identity", libgio), Nothing, (Ptr{GObject}, Ptr{GObject}), instance, _identity)
    nothing
end
function close(instance::GDtlsConnection, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_dtls_connection_close", libgio), Cint, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _cancellable_maybe, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function close_async(instance::GDtlsConnection, _io_priority::Integer, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    ret = ccall(("g_dtls_connection_close_async", libgio), Nothing, (Ptr{GObject}, Int32, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _io_priority, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function close_finish(instance::GDtlsConnection, _result::GAsyncResult)
    err = err_buf()
    ret = ccall(("g_dtls_connection_close_finish", libgio), Cint, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _result, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function emit_accept_certificate(instance::GDtlsConnection, _peer_cert::GTlsCertificate, _errors)
    ret = ccall(("g_dtls_connection_emit_accept_certificate", libgio), Cint, (Ptr{GObject}, Ptr{GObject}, UInt32), instance, _peer_cert, _errors)
    ret2 = convert(Bool, ret)
    ret2
end
function get_certificate(instance::GDtlsConnection)
    ret = ccall(("g_dtls_connection_get_certificate", libgio), Ptr{GObject}, (Ptr{GObject},), instance)
    ret2 = convert_if_not_null(GTlsCertificate, ret, false)
    ret2
end
function get_channel_binding_data(instance::GDtlsConnection, _type)
    m_data = Ref{Ptr{GByteArray}}()
    err = err_buf()
    ret = ccall(("g_dtls_connection_get_channel_binding_data", libgio), Cint, (Ptr{GObject}, UInt32, Ptr{Ptr{GByteArray}}, Ptr{Ptr{GError}}), instance, _type, m_data, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    _data = m_data[]
    _data = convert(GByteArray, _data, false)
    (ret2, _data)
end
function get_ciphersuite_name(instance::GDtlsConnection)
    ret = ccall(("g_dtls_connection_get_ciphersuite_name", libgio), Cstring, (Ptr{GObject},), instance)
    ret2 = string_or_nothing(ret, true)
    ret2
end
function get_database(instance::GDtlsConnection)
    ret = ccall(("g_dtls_connection_get_database", libgio), Ptr{GObject}, (Ptr{GObject},), instance)
    ret2 = convert_if_not_null(GTlsDatabase, ret, false)
    ret2
end
function get_interaction(instance::GDtlsConnection)
    ret = ccall(("g_dtls_connection_get_interaction", libgio), Ptr{GObject}, (Ptr{GObject},), instance)
    ret2 = convert_if_not_null(GTlsInteraction, ret, false)
    ret2
end
function get_negotiated_protocol(instance::GDtlsConnection)
    ret = ccall(("g_dtls_connection_get_negotiated_protocol", libgio), Cstring, (Ptr{GObject},), instance)
    ret2 = string_or_nothing(ret, false)
    ret2
end
function get_peer_certificate(instance::GDtlsConnection)
    ret = ccall(("g_dtls_connection_get_peer_certificate", libgio), Ptr{GObject}, (Ptr{GObject},), instance)
    ret2 = convert_if_not_null(GTlsCertificate, ret, false)
    ret2
end
function get_peer_certificate_errors(instance::GDtlsConnection)
    ret = ccall(("g_dtls_connection_get_peer_certificate_errors", libgio), UInt32, (Ptr{GObject},), instance)
    ret2 = TlsCertificateFlags(ret)
    ret2
end
function get_protocol_version(instance::GDtlsConnection)
    ret = ccall(("g_dtls_connection_get_protocol_version", libgio), UInt32, (Ptr{GObject},), instance)
    ret2 = TlsProtocolVersion(ret)
    ret2
end
function get_require_close_notify(instance::GDtlsConnection)
    ret = ccall(("g_dtls_connection_get_require_close_notify", libgio), Cint, (Ptr{GObject},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function handshake(instance::GDtlsConnection, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_dtls_connection_handshake", libgio), Cint, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _cancellable_maybe, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function handshake_async(instance::GDtlsConnection, _io_priority::Integer, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    ret = ccall(("g_dtls_connection_handshake_async", libgio), Nothing, (Ptr{GObject}, Int32, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _io_priority, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function handshake_finish(instance::GDtlsConnection, _result::GAsyncResult)
    err = err_buf()
    ret = ccall(("g_dtls_connection_handshake_finish", libgio), Cint, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _result, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function set_advertised_protocols(instance::GDtlsConnection, _protocols)
    _protocols_maybe = nothing_to_null(_protocols)
    ret = ccall(("g_dtls_connection_set_advertised_protocols", libgio), Nothing, (Ptr{GObject}, Ptr{Cstring}), instance, _protocols_maybe)
    nothing
end
function set_certificate(instance::GDtlsConnection, _certificate::GTlsCertificate)
    ret = ccall(("g_dtls_connection_set_certificate", libgio), Nothing, (Ptr{GObject}, Ptr{GObject}), instance, _certificate)
    nothing
end
function set_database(instance::GDtlsConnection, _database::Maybe(GTlsDatabase))
    _database_maybe = nothing_to_null(_database)
    ret = ccall(("g_dtls_connection_set_database", libgio), Nothing, (Ptr{GObject}, Ptr{GObject}), instance, _database_maybe)
    nothing
end
function set_interaction(instance::GDtlsConnection, _interaction::Maybe(GTlsInteraction))
    _interaction_maybe = nothing_to_null(_interaction)
    ret = ccall(("g_dtls_connection_set_interaction", libgio), Nothing, (Ptr{GObject}, Ptr{GObject}), instance, _interaction_maybe)
    nothing
end
function set_require_close_notify(instance::GDtlsConnection, _require_close_notify::Bool)
    ret = ccall(("g_dtls_connection_set_require_close_notify", libgio), Nothing, (Ptr{GObject}, Cint), instance, _require_close_notify)
    nothing
end
function shutdown(instance::GDtlsConnection, _shutdown_read::Bool, _shutdown_write::Bool, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_dtls_connection_shutdown", libgio), Cint, (Ptr{GObject}, Cint, Cint, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _shutdown_read, _shutdown_write, _cancellable_maybe, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function shutdown_async(instance::GDtlsConnection, _shutdown_read::Bool, _shutdown_write::Bool, _io_priority::Integer, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    ret = ccall(("g_dtls_connection_shutdown_async", libgio), Nothing, (Ptr{GObject}, Cint, Cint, Int32, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _shutdown_read, _shutdown_write, _io_priority, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function shutdown_finish(instance::GDtlsConnection, _result::GAsyncResult)
    err = err_buf()
    ret = ccall(("g_dtls_connection_shutdown_finish", libgio), Cint, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _result, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function new_for_commandline_arg(_arg::Union{AbstractString, Symbol})
    ret = ccall(("g_file_new_for_commandline_arg", libgio), Ptr{GObject}, (Cstring,), _arg)
    ret2 = begin
            leaftype = GLib.find_leaf_type(ret)
            convert(leaftype, ret, true)
        end
    ret2
end
function new_for_commandline_arg_and_cwd(_arg::Union{AbstractString, Symbol}, _cwd::Union{AbstractString, Symbol})
    ret = ccall(("g_file_new_for_commandline_arg_and_cwd", libgio), Ptr{GObject}, (Cstring, Cstring), _arg, _cwd)
    ret2 = begin
            leaftype = GLib.find_leaf_type(ret)
            convert(leaftype, ret, true)
        end
    ret2
end
function new_for_path(_path::Union{AbstractString, Symbol})
    ret = ccall(("g_file_new_for_path", libgio), Ptr{GObject}, (Cstring,), _path)
    ret2 = begin
            leaftype = GLib.find_leaf_type(ret)
            convert(leaftype, ret, true)
        end
    ret2
end
function new_for_uri(_uri::Union{AbstractString, Symbol})
    ret = ccall(("g_file_new_for_uri", libgio), Ptr{GObject}, (Cstring,), _uri)
    ret2 = begin
            leaftype = GLib.find_leaf_type(ret)
            convert(leaftype, ret, true)
        end
    ret2
end
function new_tmp(_tmpl::Maybe(Union{AbstractString, Symbol}))
    _tmpl_maybe = nothing_to_null(_tmpl)
    m_iostream = Ref{Ptr{GObject}}()
    err = err_buf()
    ret = ccall(("g_file_new_tmp", libgio), Ptr{GObject}, (Cstring, Ptr{Ptr{GObject}}, Ptr{Ptr{GError}}), _tmpl_maybe, m_iostream, err)
    check_err(err)
    ret2 = begin
            leaftype = GLib.find_leaf_type(ret)
            convert(leaftype, ret, true)
        end
    _iostream = m_iostream[]
    _iostream = convert(GFileIOStream, _iostream, true)
    (ret2, _iostream)
end
function new_tmp_async(_tmpl::Maybe(Union{AbstractString, Symbol}), _io_priority::Integer, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _tmpl_maybe = nothing_to_null(_tmpl)
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    ret = ccall(("g_file_new_tmp_async", libgio), Nothing, (Cstring, Int32, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), _tmpl_maybe, _io_priority, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function new_tmp_dir_async(_tmpl::Maybe(Union{AbstractString, Symbol}), _io_priority::Integer, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _tmpl_maybe = nothing_to_null(_tmpl)
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    ret = ccall(("g_file_new_tmp_dir_async", libgio), Nothing, (Cstring, Int32, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), _tmpl_maybe, _io_priority, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function new_tmp_dir_finish(_result::GAsyncResult)
    err = err_buf()
    ret = ccall(("g_file_new_tmp_dir_finish", libgio), Ptr{GObject}, (Ptr{GObject}, Ptr{Ptr{GError}}), _result, err)
    check_err(err)
    ret2 = begin
            leaftype = GLib.find_leaf_type(ret)
            convert(leaftype, ret, true)
        end
    ret2
end
function new_tmp_finish(_result::GAsyncResult)
    m_iostream = Ref{Ptr{GObject}}()
    err = err_buf()
    ret = ccall(("g_file_new_tmp_finish", libgio), Ptr{GObject}, (Ptr{GObject}, Ptr{Ptr{GObject}}, Ptr{Ptr{GError}}), _result, m_iostream, err)
    check_err(err)
    ret2 = begin
            leaftype = GLib.find_leaf_type(ret)
            convert(leaftype, ret, true)
        end
    _iostream = m_iostream[]
    _iostream = convert(GFileIOStream, _iostream, true)
    (ret2, _iostream)
end
function parse_name(_parse_name::Union{AbstractString, Symbol})
    ret = ccall(("g_file_parse_name", libgio), Ptr{GObject}, (Cstring,), _parse_name)
    ret2 = begin
            leaftype = GLib.find_leaf_type(ret)
            convert(leaftype, ret, true)
        end
    ret2
end
function append_to(instance::GFile, _flags, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_file_append_to", libgio), Ptr{GObject}, (Ptr{GObject}, UInt32, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _flags, _cancellable_maybe, err)
    check_err(err)
    ret2 = convert(GFileOutputStream, ret, true)
    ret2
end
function append_to_async(instance::GFile, _flags, _io_priority::Integer, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    ret = ccall(("g_file_append_to_async", libgio), Nothing, (Ptr{GObject}, UInt32, Int32, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _flags, _io_priority, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function append_to_finish(instance::GFile, _res::GAsyncResult)
    err = err_buf()
    ret = ccall(("g_file_append_to_finish", libgio), Ptr{GObject}, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _res, err)
    check_err(err)
    ret2 = convert(GFileOutputStream, ret, true)
    ret2
end
function build_attribute_list_for_copy(instance::GFile, _flags, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_file_build_attribute_list_for_copy", libgio), Cstring, (Ptr{GObject}, UInt32, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _flags, _cancellable_maybe, err)
    check_err(err)
    ret2 = string_or_nothing(ret, true)
    ret2
end
function copy(instance::GFile, _destination::GFile, _flags, _cancellable::Maybe(GCancellable), _progress_callback::Maybe(Function))
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _progress_callback === nothing
        _progress_callback_cfunc = C_NULL
        _progress_callback_closure = C_NULL
    else
        _progress_callback_cfunc = @cfunction(GFileProgressCallback, Nothing, (Int64, Int64, Ref{Function}))
        begin
            ref = Ref{Any}(_progress_callback)
            _progress_callback_closure = unsafe_load(convert(Ptr{Ptr{Nothing}}, Base.unsafe_convert(Ptr{Any}, ref)))
        end
    end
    err = err_buf()
    ret = ccall(("g_file_copy", libgio), Cint, (Ptr{GObject}, Ptr{GObject}, UInt32, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}, Ptr{Ptr{GError}}), instance, _destination, _flags, _cancellable_maybe, _progress_callback_cfunc, _progress_callback_closure, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function copy_attributes(instance::GFile, _destination::GFile, _flags, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_file_copy_attributes", libgio), Cint, (Ptr{GObject}, Ptr{GObject}, UInt32, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _destination, _flags, _cancellable_maybe, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function copy_finish(instance::GFile, _res::GAsyncResult)
    err = err_buf()
    ret = ccall(("g_file_copy_finish", libgio), Cint, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _res, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function create(instance::GFile, _flags, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_file_create", libgio), Ptr{GObject}, (Ptr{GObject}, UInt32, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _flags, _cancellable_maybe, err)
    check_err(err)
    ret2 = convert(GFileOutputStream, ret, true)
    ret2
end
function create_async(instance::GFile, _flags, _io_priority::Integer, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    ret = ccall(("g_file_create_async", libgio), Nothing, (Ptr{GObject}, UInt32, Int32, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _flags, _io_priority, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function create_finish(instance::GFile, _res::GAsyncResult)
    err = err_buf()
    ret = ccall(("g_file_create_finish", libgio), Ptr{GObject}, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _res, err)
    check_err(err)
    ret2 = convert(GFileOutputStream, ret, true)
    ret2
end
function create_readwrite(instance::GFile, _flags, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_file_create_readwrite", libgio), Ptr{GObject}, (Ptr{GObject}, UInt32, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _flags, _cancellable_maybe, err)
    check_err(err)
    ret2 = convert(GFileIOStream, ret, true)
    ret2
end
function create_readwrite_async(instance::GFile, _flags, _io_priority::Integer, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    ret = ccall(("g_file_create_readwrite_async", libgio), Nothing, (Ptr{GObject}, UInt32, Int32, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _flags, _io_priority, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function create_readwrite_finish(instance::GFile, _res::GAsyncResult)
    err = err_buf()
    ret = ccall(("g_file_create_readwrite_finish", libgio), Ptr{GObject}, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _res, err)
    check_err(err)
    ret2 = convert(GFileIOStream, ret, true)
    ret2
end
function delete(instance::GFile, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_file_delete", libgio), Cint, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _cancellable_maybe, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function delete_async(instance::GFile, _io_priority::Integer, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    ret = ccall(("g_file_delete_async", libgio), Nothing, (Ptr{GObject}, Int32, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _io_priority, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function delete_finish(instance::GFile, _result::GAsyncResult)
    err = err_buf()
    ret = ccall(("g_file_delete_finish", libgio), Cint, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _result, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function dup(instance::GFile)
    ret = ccall(("g_file_dup", libgio), Ptr{GObject}, (Ptr{GObject},), instance)
    ret2 = begin
            leaftype = GLib.find_leaf_type(ret)
            convert(leaftype, ret, true)
        end
    ret2
end
function eject_mountable_with_operation(instance::GFile, _flags, _mount_operation::Maybe(GMountOperation), _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _mount_operation_maybe = nothing_to_null(_mount_operation)
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    ret = ccall(("g_file_eject_mountable_with_operation", libgio), Nothing, (Ptr{GObject}, UInt32, Ptr{GObject}, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _flags, _mount_operation_maybe, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function eject_mountable_with_operation_finish(instance::GFile, _result::GAsyncResult)
    err = err_buf()
    ret = ccall(("g_file_eject_mountable_with_operation_finish", libgio), Cint, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _result, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function enumerate_children(instance::GFile, _attributes::Union{AbstractString, Symbol}, _flags, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_file_enumerate_children", libgio), Ptr{GObject}, (Ptr{GObject}, Cstring, UInt32, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _attributes, _flags, _cancellable_maybe, err)
    check_err(err)
    ret2 = convert(GFileEnumerator, ret, true)
    ret2
end
function enumerate_children_async(instance::GFile, _attributes::Union{AbstractString, Symbol}, _flags, _io_priority::Integer, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    ret = ccall(("g_file_enumerate_children_async", libgio), Nothing, (Ptr{GObject}, Cstring, UInt32, Int32, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _attributes, _flags, _io_priority, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function enumerate_children_finish(instance::GFile, _res::GAsyncResult)
    err = err_buf()
    ret = ccall(("g_file_enumerate_children_finish", libgio), Ptr{GObject}, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _res, err)
    check_err(err)
    ret2 = convert(GFileEnumerator, ret, true)
    ret2
end
function equal(instance::GFile, _file2::GFile)
    ret = ccall(("g_file_equal", libgio), Cint, (Ptr{GObject}, Ptr{GObject}), instance, _file2)
    ret2 = convert(Bool, ret)
    ret2
end
function find_enclosing_mount(instance::GFile, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_file_find_enclosing_mount", libgio), Ptr{GObject}, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _cancellable_maybe, err)
    check_err(err)
    ret2 = begin
            leaftype = GLib.find_leaf_type(ret)
            convert(leaftype, ret, true)
        end
    ret2
end
function find_enclosing_mount_async(instance::GFile, _io_priority::Integer, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    ret = ccall(("g_file_find_enclosing_mount_async", libgio), Nothing, (Ptr{GObject}, Int32, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _io_priority, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function find_enclosing_mount_finish(instance::GFile, _res::GAsyncResult)
    err = err_buf()
    ret = ccall(("g_file_find_enclosing_mount_finish", libgio), Ptr{GObject}, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _res, err)
    check_err(err)
    ret2 = begin
            leaftype = GLib.find_leaf_type(ret)
            convert(leaftype, ret, true)
        end
    ret2
end
function get_basename(instance::GFile)
    ret = ccall(("g_file_get_basename", libgio), Cstring, (Ptr{GObject},), instance)
    ret2 = string_or_nothing(ret, true)
    ret2
end
function get_child(instance::GFile, _name::Union{AbstractString, Symbol})
    ret = ccall(("g_file_get_child", libgio), Ptr{GObject}, (Ptr{GObject}, Cstring), instance, _name)
    ret2 = begin
            leaftype = GLib.find_leaf_type(ret)
            convert(leaftype, ret, true)
        end
    ret2
end
function get_child_for_display_name(instance::GFile, _display_name::Union{AbstractString, Symbol})
    err = err_buf()
    ret = ccall(("g_file_get_child_for_display_name", libgio), Ptr{GObject}, (Ptr{GObject}, Cstring, Ptr{Ptr{GError}}), instance, _display_name, err)
    check_err(err)
    ret2 = begin
            leaftype = GLib.find_leaf_type(ret)
            convert(leaftype, ret, true)
        end
    ret2
end
function get_parent(instance::GFile)
    ret = ccall(("g_file_get_parent", libgio), Ptr{GObject}, (Ptr{GObject},), instance)
    ret2 = GLib.find_leaf_type_if_not_null(ret, true)
    ret2
end
function get_parse_name(instance::GFile)
    ret = ccall(("g_file_get_parse_name", libgio), Cstring, (Ptr{GObject},), instance)
    ret2 = string_or_nothing(ret, true)
    ret2
end
function get_path(instance::GFile)
    ret = ccall(("g_file_get_path", libgio), Cstring, (Ptr{GObject},), instance)
    ret2 = string_or_nothing(ret, true)
    ret2
end
function get_relative_path(instance::GFile, _descendant::GFile)
    ret = ccall(("g_file_get_relative_path", libgio), Cstring, (Ptr{GObject}, Ptr{GObject}), instance, _descendant)
    ret2 = string_or_nothing(ret, true)
    ret2
end
function get_uri(instance::GFile)
    ret = ccall(("g_file_get_uri", libgio), Cstring, (Ptr{GObject},), instance)
    ret2 = string_or_nothing(ret, true)
    ret2
end
function get_uri_scheme(instance::GFile)
    ret = ccall(("g_file_get_uri_scheme", libgio), Cstring, (Ptr{GObject},), instance)
    ret2 = string_or_nothing(ret, true)
    ret2
end
function has_parent(instance::GFile, _parent::Maybe(GFile))
    _parent_maybe = nothing_to_null(_parent)
    ret = ccall(("g_file_has_parent", libgio), Cint, (Ptr{GObject}, Ptr{GObject}), instance, _parent_maybe)
    ret2 = convert(Bool, ret)
    ret2
end
function has_prefix(instance::GFile, _prefix::GFile)
    ret = ccall(("g_file_has_prefix", libgio), Cint, (Ptr{GObject}, Ptr{GObject}), instance, _prefix)
    ret2 = convert(Bool, ret)
    ret2
end
function has_uri_scheme(instance::GFile, _uri_scheme::Union{AbstractString, Symbol})
    ret = ccall(("g_file_has_uri_scheme", libgio), Cint, (Ptr{GObject}, Cstring), instance, _uri_scheme)
    ret2 = convert(Bool, ret)
    ret2
end
function hash(instance::GFile)
    ret = ccall(("g_file_hash", libgio), UInt32, (Ptr{GObject},), instance)
    ret
end
function is_native(instance::GFile)
    ret = ccall(("g_file_is_native", libgio), Cint, (Ptr{GObject},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function load_bytes(instance::GFile, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    m_etag_out = Ref{Cstring}()
    err = err_buf()
    ret = ccall(("g_file_load_bytes", libgio), Ptr{GBytes}, (Ptr{GObject}, Ptr{GObject}, Ptr{Cstring}, Ptr{Ptr{GError}}), instance, _cancellable_maybe, m_etag_out, err)
    check_err(err)
    ret2 = convert(GBytes, ret, true)
    _etag_out = m_etag_out[]
    _etag_out = string_or_nothing(_etag_out, true)
    (ret2, _etag_out)
end
function load_bytes_async(instance::GFile, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    ret = ccall(("g_file_load_bytes_async", libgio), Nothing, (Ptr{GObject}, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function load_bytes_finish(instance::GFile, _result::GAsyncResult)
    m_etag_out = Ref{Cstring}()
    err = err_buf()
    ret = ccall(("g_file_load_bytes_finish", libgio), Ptr{GBytes}, (Ptr{GObject}, Ptr{GObject}, Ptr{Cstring}, Ptr{Ptr{GError}}), instance, _result, m_etag_out, err)
    check_err(err)
    ret2 = convert(GBytes, ret, true)
    _etag_out = m_etag_out[]
    _etag_out = string_or_nothing(_etag_out, true)
    (ret2, _etag_out)
end
function load_contents(instance::GFile, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    m_contents = Ref{Ptr{UInt8}}()
    m_length = Ref{UInt64}()
    m_etag_out = Ref{Cstring}()
    err = err_buf()
    ret = ccall(("g_file_load_contents", libgio), Cint, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{UInt8}}, Ptr{UInt64}, Ptr{Cstring}, Ptr{Ptr{GError}}), instance, _cancellable_maybe, m_contents, m_length, m_etag_out, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    _contents = m_contents[]
    _contents = begin
            arrtemp = copy(unsafe_wrap(Vector{UInt8}, _contents, m_length[]))
            GLib.g_free(_contents)
            arrtemp
        end
    _length = m_length[]
    _etag_out = m_etag_out[]
    _etag_out = string_or_nothing(_etag_out, true)
    (ret2, _contents, _etag_out)
end
function load_contents_async(instance::GFile, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    ret = ccall(("g_file_load_contents_async", libgio), Nothing, (Ptr{GObject}, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function load_contents_finish(instance::GFile, _res::GAsyncResult)
    m_contents = Ref{Ptr{UInt8}}()
    m_length = Ref{UInt64}()
    m_etag_out = Ref{Cstring}()
    err = err_buf()
    ret = ccall(("g_file_load_contents_finish", libgio), Cint, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{UInt8}}, Ptr{UInt64}, Ptr{Cstring}, Ptr{Ptr{GError}}), instance, _res, m_contents, m_length, m_etag_out, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    _contents = m_contents[]
    _contents = begin
            arrtemp = copy(unsafe_wrap(Vector{UInt8}, _contents, m_length[]))
            GLib.g_free(_contents)
            arrtemp
        end
    _length = m_length[]
    _etag_out = m_etag_out[]
    _etag_out = string_or_nothing(_etag_out, true)
    (ret2, _contents, _etag_out)
end
function load_partial_contents_finish(instance::GFile, _res::GAsyncResult)
    m_contents = Ref{Ptr{UInt8}}()
    m_length = Ref{UInt64}()
    m_etag_out = Ref{Cstring}()
    err = err_buf()
    ret = ccall(("g_file_load_partial_contents_finish", libgio), Cint, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{UInt8}}, Ptr{UInt64}, Ptr{Cstring}, Ptr{Ptr{GError}}), instance, _res, m_contents, m_length, m_etag_out, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    _contents = m_contents[]
    _contents = begin
            arrtemp = copy(unsafe_wrap(Vector{UInt8}, _contents, m_length[]))
            GLib.g_free(_contents)
            arrtemp
        end
    _length = m_length[]
    _etag_out = m_etag_out[]
    _etag_out = string_or_nothing(_etag_out, true)
    (ret2, _contents, _etag_out)
end
function make_directory(instance::GFile, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_file_make_directory", libgio), Cint, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _cancellable_maybe, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function make_directory_async(instance::GFile, _io_priority::Integer, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    ret = ccall(("g_file_make_directory_async", libgio), Nothing, (Ptr{GObject}, Int32, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _io_priority, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function make_directory_finish(instance::GFile, _result::GAsyncResult)
    err = err_buf()
    ret = ccall(("g_file_make_directory_finish", libgio), Cint, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _result, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function make_directory_with_parents(instance::GFile, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_file_make_directory_with_parents", libgio), Cint, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _cancellable_maybe, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function make_symbolic_link(instance::GFile, _symlink_value::Union{AbstractString, Symbol}, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_file_make_symbolic_link", libgio), Cint, (Ptr{GObject}, Cstring, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _symlink_value, _cancellable_maybe, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function make_symbolic_link_async(instance::GFile, _symlink_value::Union{AbstractString, Symbol}, _io_priority::Integer, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    ret = ccall(("g_file_make_symbolic_link_async", libgio), Nothing, (Ptr{GObject}, Cstring, Int32, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _symlink_value, _io_priority, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function make_symbolic_link_finish(instance::GFile, _result::GAsyncResult)
    err = err_buf()
    ret = ccall(("g_file_make_symbolic_link_finish", libgio), Cint, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _result, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function measure_disk_usage(instance::GFile, _flags, _cancellable::Maybe(GCancellable), _progress_callback::Maybe(Function))
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _progress_callback === nothing
        _progress_callback_cfunc = C_NULL
        _progress_callback_closure = C_NULL
    else
        _progress_callback_cfunc = @cfunction(GFileMeasureProgressCallback, Nothing, (Cint, UInt64, UInt64, UInt64, Ref{Function}))
        begin
            ref = Ref{Any}(_progress_callback)
            _progress_callback_closure = unsafe_load(convert(Ptr{Ptr{Nothing}}, Base.unsafe_convert(Ptr{Any}, ref)))
        end
    end
    m_disk_usage = Ref{UInt64}()
    m_num_dirs = Ref{UInt64}()
    m_num_files = Ref{UInt64}()
    err = err_buf()
    ret = ccall(("g_file_measure_disk_usage", libgio), Cint, (Ptr{GObject}, UInt32, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}, Ptr{UInt64}, Ptr{UInt64}, Ptr{UInt64}, Ptr{Ptr{GError}}), instance, _flags, _cancellable_maybe, _progress_callback_cfunc, _progress_callback_closure, m_disk_usage, m_num_dirs, m_num_files, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    _disk_usage = m_disk_usage[]
    _num_dirs = m_num_dirs[]
    _num_files = m_num_files[]
    (ret2, _disk_usage, _num_dirs, _num_files)
end
function measure_disk_usage_finish(instance::GFile, _result::GAsyncResult)
    m_disk_usage = Ref{UInt64}()
    m_num_dirs = Ref{UInt64}()
    m_num_files = Ref{UInt64}()
    err = err_buf()
    ret = ccall(("g_file_measure_disk_usage_finish", libgio), Cint, (Ptr{GObject}, Ptr{GObject}, Ptr{UInt64}, Ptr{UInt64}, Ptr{UInt64}, Ptr{Ptr{GError}}), instance, _result, m_disk_usage, m_num_dirs, m_num_files, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    _disk_usage = m_disk_usage[]
    _num_dirs = m_num_dirs[]
    _num_files = m_num_files[]
    (ret2, _disk_usage, _num_dirs, _num_files)
end
function monitor(instance::GFile, _flags, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_file_monitor", libgio), Ptr{GObject}, (Ptr{GObject}, UInt32, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _flags, _cancellable_maybe, err)
    check_err(err)
    ret2 = convert(GFileMonitor, ret, true)
    ret2
end
function monitor_directory(instance::GFile, _flags, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_file_monitor_directory", libgio), Ptr{GObject}, (Ptr{GObject}, UInt32, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _flags, _cancellable_maybe, err)
    check_err(err)
    ret2 = convert(GFileMonitor, ret, true)
    ret2
end
function monitor_file(instance::GFile, _flags, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_file_monitor_file", libgio), Ptr{GObject}, (Ptr{GObject}, UInt32, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _flags, _cancellable_maybe, err)
    check_err(err)
    ret2 = convert(GFileMonitor, ret, true)
    ret2
end
function mount_enclosing_volume(instance::GFile, _flags, _mount_operation::Maybe(GMountOperation), _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _mount_operation_maybe = nothing_to_null(_mount_operation)
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    ret = ccall(("g_file_mount_enclosing_volume", libgio), Nothing, (Ptr{GObject}, UInt32, Ptr{GObject}, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _flags, _mount_operation_maybe, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function mount_enclosing_volume_finish(instance::GFile, _result::GAsyncResult)
    err = err_buf()
    ret = ccall(("g_file_mount_enclosing_volume_finish", libgio), Cint, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _result, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function mount_mountable(instance::GFile, _flags, _mount_operation::Maybe(GMountOperation), _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _mount_operation_maybe = nothing_to_null(_mount_operation)
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    ret = ccall(("g_file_mount_mountable", libgio), Nothing, (Ptr{GObject}, UInt32, Ptr{GObject}, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _flags, _mount_operation_maybe, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function mount_mountable_finish(instance::GFile, _result::GAsyncResult)
    err = err_buf()
    ret = ccall(("g_file_mount_mountable_finish", libgio), Ptr{GObject}, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _result, err)
    check_err(err)
    ret2 = begin
            leaftype = GLib.find_leaf_type(ret)
            convert(leaftype, ret, true)
        end
    ret2
end
function move(instance::GFile, _destination::GFile, _flags, _cancellable::Maybe(GCancellable), _progress_callback::Maybe(Function))
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _progress_callback === nothing
        _progress_callback_cfunc = C_NULL
        _progress_callback_closure = C_NULL
    else
        _progress_callback_cfunc = @cfunction(GFileProgressCallback, Nothing, (Int64, Int64, Ref{Function}))
        begin
            ref = Ref{Any}(_progress_callback)
            _progress_callback_closure = unsafe_load(convert(Ptr{Ptr{Nothing}}, Base.unsafe_convert(Ptr{Any}, ref)))
        end
    end
    err = err_buf()
    ret = ccall(("g_file_move", libgio), Cint, (Ptr{GObject}, Ptr{GObject}, UInt32, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}, Ptr{Ptr{GError}}), instance, _destination, _flags, _cancellable_maybe, _progress_callback_cfunc, _progress_callback_closure, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function move_finish(instance::GFile, _result::GAsyncResult)
    err = err_buf()
    ret = ccall(("g_file_move_finish", libgio), Cint, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _result, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function open_readwrite(instance::GFile, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_file_open_readwrite", libgio), Ptr{GObject}, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _cancellable_maybe, err)
    check_err(err)
    ret2 = convert(GFileIOStream, ret, true)
    ret2
end
function open_readwrite_async(instance::GFile, _io_priority::Integer, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    ret = ccall(("g_file_open_readwrite_async", libgio), Nothing, (Ptr{GObject}, Int32, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _io_priority, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function open_readwrite_finish(instance::GFile, _res::GAsyncResult)
    err = err_buf()
    ret = ccall(("g_file_open_readwrite_finish", libgio), Ptr{GObject}, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _res, err)
    check_err(err)
    ret2 = convert(GFileIOStream, ret, true)
    ret2
end
function peek_path(instance::GFile)
    ret = ccall(("g_file_peek_path", libgio), Cstring, (Ptr{GObject},), instance)
    ret2 = string_or_nothing(ret, false)
    ret2
end
function poll_mountable(instance::GFile, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    ret = ccall(("g_file_poll_mountable", libgio), Nothing, (Ptr{GObject}, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function poll_mountable_finish(instance::GFile, _result::GAsyncResult)
    err = err_buf()
    ret = ccall(("g_file_poll_mountable_finish", libgio), Cint, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _result, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function query_default_handler(instance::GFile, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_file_query_default_handler", libgio), Ptr{GObject}, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _cancellable_maybe, err)
    check_err(err)
    ret2 = begin
            leaftype = GLib.find_leaf_type(ret)
            convert(leaftype, ret, true)
        end
    ret2
end
function query_default_handler_async(instance::GFile, _io_priority::Integer, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    ret = ccall(("g_file_query_default_handler_async", libgio), Nothing, (Ptr{GObject}, Int32, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _io_priority, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function query_default_handler_finish(instance::GFile, _result::GAsyncResult)
    err = err_buf()
    ret = ccall(("g_file_query_default_handler_finish", libgio), Ptr{GObject}, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _result, err)
    check_err(err)
    ret2 = begin
            leaftype = GLib.find_leaf_type(ret)
            convert(leaftype, ret, true)
        end
    ret2
end
function query_exists(instance::GFile, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    ret = ccall(("g_file_query_exists", libgio), Cint, (Ptr{GObject}, Ptr{GObject}), instance, _cancellable_maybe)
    ret2 = convert(Bool, ret)
    ret2
end
function query_file_type(instance::GFile, _flags, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    ret = ccall(("g_file_query_file_type", libgio), UInt32, (Ptr{GObject}, UInt32, Ptr{GObject}), instance, _flags, _cancellable_maybe)
    ret2 = FileType(ret)
    ret2
end
function query_filesystem_info(instance::GFile, _attributes::Union{AbstractString, Symbol}, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_file_query_filesystem_info", libgio), Ptr{GObject}, (Ptr{GObject}, Cstring, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _attributes, _cancellable_maybe, err)
    check_err(err)
    ret2 = convert(GFileInfo, ret, true)
    ret2
end
function query_filesystem_info_async(instance::GFile, _attributes::Union{AbstractString, Symbol}, _io_priority::Integer, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    ret = ccall(("g_file_query_filesystem_info_async", libgio), Nothing, (Ptr{GObject}, Cstring, Int32, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _attributes, _io_priority, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function query_filesystem_info_finish(instance::GFile, _res::GAsyncResult)
    err = err_buf()
    ret = ccall(("g_file_query_filesystem_info_finish", libgio), Ptr{GObject}, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _res, err)
    check_err(err)
    ret2 = convert(GFileInfo, ret, true)
    ret2
end
function query_info(instance::GFile, _attributes::Union{AbstractString, Symbol}, _flags, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_file_query_info", libgio), Ptr{GObject}, (Ptr{GObject}, Cstring, UInt32, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _attributes, _flags, _cancellable_maybe, err)
    check_err(err)
    ret2 = convert(GFileInfo, ret, true)
    ret2
end
function query_info_async(instance::GFile, _attributes::Union{AbstractString, Symbol}, _flags, _io_priority::Integer, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    ret = ccall(("g_file_query_info_async", libgio), Nothing, (Ptr{GObject}, Cstring, UInt32, Int32, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _attributes, _flags, _io_priority, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function query_info_finish(instance::GFile, _res::GAsyncResult)
    err = err_buf()
    ret = ccall(("g_file_query_info_finish", libgio), Ptr{GObject}, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _res, err)
    check_err(err)
    ret2 = convert(GFileInfo, ret, true)
    ret2
end
function query_settable_attributes(instance::GFile, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_file_query_settable_attributes", libgio), Ptr{_GFileAttributeInfoList}, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _cancellable_maybe, err)
    check_err(err)
    ret2 = convert(GFileAttributeInfoListLike, ret, true)
    ret2
end
function query_writable_namespaces(instance::GFile, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_file_query_writable_namespaces", libgio), Ptr{_GFileAttributeInfoList}, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _cancellable_maybe, err)
    check_err(err)
    ret2 = convert(GFileAttributeInfoListLike, ret, true)
    ret2
end
function read(instance::GFile, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_file_read", libgio), Ptr{GObject}, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _cancellable_maybe, err)
    check_err(err)
    ret2 = convert(GFileInputStream, ret, true)
    ret2
end
function read_async(instance::GFile, _io_priority::Integer, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    ret = ccall(("g_file_read_async", libgio), Nothing, (Ptr{GObject}, Int32, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _io_priority, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function read_finish(instance::GFile, _res::GAsyncResult)
    err = err_buf()
    ret = ccall(("g_file_read_finish", libgio), Ptr{GObject}, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _res, err)
    check_err(err)
    ret2 = convert(GFileInputStream, ret, true)
    ret2
end
function replace(instance::GFile, _etag::Maybe(Union{AbstractString, Symbol}), _make_backup::Bool, _flags, _cancellable::Maybe(GCancellable))
    _etag_maybe = nothing_to_null(_etag)
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_file_replace", libgio), Ptr{GObject}, (Ptr{GObject}, Cstring, Cint, UInt32, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _etag_maybe, _make_backup, _flags, _cancellable_maybe, err)
    check_err(err)
    ret2 = convert(GFileOutputStream, ret, true)
    ret2
end
function replace_async(instance::GFile, _etag::Maybe(Union{AbstractString, Symbol}), _make_backup::Bool, _flags, _io_priority::Integer, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _etag_maybe = nothing_to_null(_etag)
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    ret = ccall(("g_file_replace_async", libgio), Nothing, (Ptr{GObject}, Cstring, Cint, UInt32, Int32, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _etag_maybe, _make_backup, _flags, _io_priority, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function replace_contents(instance::GFile, _contents, _etag::Maybe(Union{AbstractString, Symbol}), _make_backup::Bool, _flags, _cancellable::Maybe(GCancellable))
    _contents_arr = convert(Vector{UInt8}, _contents)
    _etag_maybe = nothing_to_null(_etag)
    m_new_etag = Ref{Cstring}()
    _cancellable_maybe = nothing_to_null(_cancellable)
    _length = length(_contents)
    err = err_buf()
    ret = ccall(("g_file_replace_contents", libgio), Cint, (Ptr{GObject}, Ptr{UInt8}, UInt64, Cstring, Cint, UInt32, Ptr{Cstring}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _contents_arr, _length, _etag_maybe, _make_backup, _flags, m_new_etag, _cancellable_maybe, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    _new_etag = m_new_etag[]
    _new_etag = string_or_nothing(_new_etag, true)
    (ret2, _new_etag)
end
function replace_contents_async(instance::GFile, _contents, _etag::Maybe(Union{AbstractString, Symbol}), _make_backup::Bool, _flags, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _contents_arr = convert(Vector{UInt8}, _contents)
    _etag_maybe = nothing_to_null(_etag)
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    _length = length(_contents)
    ret = ccall(("g_file_replace_contents_async", libgio), Nothing, (Ptr{GObject}, Ptr{UInt8}, UInt64, Cstring, Cint, UInt32, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _contents_arr, _length, _etag_maybe, _make_backup, _flags, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function replace_contents_bytes_async(instance::GFile, _contents::GBytes, _etag::Maybe(Union{AbstractString, Symbol}), _make_backup::Bool, _flags, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _etag_maybe = nothing_to_null(_etag)
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    ret = ccall(("g_file_replace_contents_bytes_async", libgio), Nothing, (Ptr{GObject}, Ptr{GBytes}, Cstring, Cint, UInt32, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _contents, _etag_maybe, _make_backup, _flags, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function replace_contents_finish(instance::GFile, _res::GAsyncResult)
    m_new_etag = Ref{Cstring}()
    err = err_buf()
    ret = ccall(("g_file_replace_contents_finish", libgio), Cint, (Ptr{GObject}, Ptr{GObject}, Ptr{Cstring}, Ptr{Ptr{GError}}), instance, _res, m_new_etag, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    _new_etag = m_new_etag[]
    _new_etag = string_or_nothing(_new_etag, true)
    (ret2, _new_etag)
end
function replace_finish(instance::GFile, _res::GAsyncResult)
    err = err_buf()
    ret = ccall(("g_file_replace_finish", libgio), Ptr{GObject}, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _res, err)
    check_err(err)
    ret2 = convert(GFileOutputStream, ret, true)
    ret2
end
function replace_readwrite(instance::GFile, _etag::Maybe(Union{AbstractString, Symbol}), _make_backup::Bool, _flags, _cancellable::Maybe(GCancellable))
    _etag_maybe = nothing_to_null(_etag)
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_file_replace_readwrite", libgio), Ptr{GObject}, (Ptr{GObject}, Cstring, Cint, UInt32, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _etag_maybe, _make_backup, _flags, _cancellable_maybe, err)
    check_err(err)
    ret2 = convert(GFileIOStream, ret, true)
    ret2
end
function replace_readwrite_async(instance::GFile, _etag::Maybe(Union{AbstractString, Symbol}), _make_backup::Bool, _flags, _io_priority::Integer, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _etag_maybe = nothing_to_null(_etag)
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    ret = ccall(("g_file_replace_readwrite_async", libgio), Nothing, (Ptr{GObject}, Cstring, Cint, UInt32, Int32, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _etag_maybe, _make_backup, _flags, _io_priority, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function replace_readwrite_finish(instance::GFile, _res::GAsyncResult)
    err = err_buf()
    ret = ccall(("g_file_replace_readwrite_finish", libgio), Ptr{GObject}, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _res, err)
    check_err(err)
    ret2 = convert(GFileIOStream, ret, true)
    ret2
end
function resolve_relative_path(instance::GFile, _relative_path::Union{AbstractString, Symbol})
    ret = ccall(("g_file_resolve_relative_path", libgio), Ptr{GObject}, (Ptr{GObject}, Cstring), instance, _relative_path)
    ret2 = begin
            leaftype = GLib.find_leaf_type(ret)
            convert(leaftype, ret, true)
        end
    ret2
end
function set_attribute(instance::GFile, _attribute::Union{AbstractString, Symbol}, _type, _value_p::Maybe(Nothing), _flags, _cancellable::Maybe(GCancellable))
    _value_p_maybe = nothing_to_null(_value_p)
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_file_set_attribute", libgio), Cint, (Ptr{GObject}, Cstring, UInt32, Ptr{Nothing}, UInt32, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _attribute, _type, _value_p_maybe, _flags, _cancellable_maybe, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function set_attribute_byte_string(instance::GFile, _attribute::Union{AbstractString, Symbol}, _value::Union{AbstractString, Symbol}, _flags, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_file_set_attribute_byte_string", libgio), Cint, (Ptr{GObject}, Cstring, Cstring, UInt32, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _attribute, _value, _flags, _cancellable_maybe, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function set_attribute_int32(instance::GFile, _attribute::Union{AbstractString, Symbol}, _value::Integer, _flags, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_file_set_attribute_int32", libgio), Cint, (Ptr{GObject}, Cstring, Int32, UInt32, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _attribute, _value, _flags, _cancellable_maybe, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function set_attribute_int64(instance::GFile, _attribute::Union{AbstractString, Symbol}, _value::Integer, _flags, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_file_set_attribute_int64", libgio), Cint, (Ptr{GObject}, Cstring, Int64, UInt32, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _attribute, _value, _flags, _cancellable_maybe, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function set_attribute_string(instance::GFile, _attribute::Union{AbstractString, Symbol}, _value::Union{AbstractString, Symbol}, _flags, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_file_set_attribute_string", libgio), Cint, (Ptr{GObject}, Cstring, Cstring, UInt32, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _attribute, _value, _flags, _cancellable_maybe, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function set_attribute_uint32(instance::GFile, _attribute::Union{AbstractString, Symbol}, _value::Integer, _flags, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_file_set_attribute_uint32", libgio), Cint, (Ptr{GObject}, Cstring, UInt32, UInt32, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _attribute, _value, _flags, _cancellable_maybe, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function set_attribute_uint64(instance::GFile, _attribute::Union{AbstractString, Symbol}, _value::Integer, _flags, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_file_set_attribute_uint64", libgio), Cint, (Ptr{GObject}, Cstring, UInt64, UInt32, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _attribute, _value, _flags, _cancellable_maybe, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function set_attributes_async(instance::GFile, _info::GFileInfo, _flags, _io_priority::Integer, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    ret = ccall(("g_file_set_attributes_async", libgio), Nothing, (Ptr{GObject}, Ptr{GObject}, UInt32, Int32, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _info, _flags, _io_priority, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function set_attributes_finish(instance::GFile, _result::GAsyncResult)
    m_info = Ref{Ptr{GObject}}()
    err = err_buf()
    ret = ccall(("g_file_set_attributes_finish", libgio), Cint, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GObject}}, Ptr{Ptr{GError}}), instance, _result, m_info, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    _info = m_info[]
    _info = convert(GFileInfo, _info, true)
    (ret2, _info)
end
function set_attributes_from_info(instance::GFile, _info::GFileInfo, _flags, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_file_set_attributes_from_info", libgio), Cint, (Ptr{GObject}, Ptr{GObject}, UInt32, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _info, _flags, _cancellable_maybe, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function set_display_name(instance::GFile, _display_name::Union{AbstractString, Symbol}, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_file_set_display_name", libgio), Ptr{GObject}, (Ptr{GObject}, Cstring, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _display_name, _cancellable_maybe, err)
    check_err(err)
    ret2 = begin
            leaftype = GLib.find_leaf_type(ret)
            convert(leaftype, ret, true)
        end
    ret2
end
function set_display_name_async(instance::GFile, _display_name::Union{AbstractString, Symbol}, _io_priority::Integer, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    ret = ccall(("g_file_set_display_name_async", libgio), Nothing, (Ptr{GObject}, Cstring, Int32, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _display_name, _io_priority, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function set_display_name_finish(instance::GFile, _res::GAsyncResult)
    err = err_buf()
    ret = ccall(("g_file_set_display_name_finish", libgio), Ptr{GObject}, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _res, err)
    check_err(err)
    ret2 = begin
            leaftype = GLib.find_leaf_type(ret)
            convert(leaftype, ret, true)
        end
    ret2
end
function start_mountable(instance::GFile, _flags, _start_operation::Maybe(GMountOperation), _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _start_operation_maybe = nothing_to_null(_start_operation)
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    ret = ccall(("g_file_start_mountable", libgio), Nothing, (Ptr{GObject}, UInt32, Ptr{GObject}, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _flags, _start_operation_maybe, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function start_mountable_finish(instance::GFile, _result::GAsyncResult)
    err = err_buf()
    ret = ccall(("g_file_start_mountable_finish", libgio), Cint, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _result, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function stop_mountable(instance::GFile, _flags, _mount_operation::Maybe(GMountOperation), _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _mount_operation_maybe = nothing_to_null(_mount_operation)
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    ret = ccall(("g_file_stop_mountable", libgio), Nothing, (Ptr{GObject}, UInt32, Ptr{GObject}, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _flags, _mount_operation_maybe, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function stop_mountable_finish(instance::GFile, _result::GAsyncResult)
    err = err_buf()
    ret = ccall(("g_file_stop_mountable_finish", libgio), Cint, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _result, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function supports_thread_contexts(instance::GFile)
    ret = ccall(("g_file_supports_thread_contexts", libgio), Cint, (Ptr{GObject},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function trash(instance::GFile, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_file_trash", libgio), Cint, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _cancellable_maybe, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function trash_async(instance::GFile, _io_priority::Integer, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    ret = ccall(("g_file_trash_async", libgio), Nothing, (Ptr{GObject}, Int32, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _io_priority, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function trash_finish(instance::GFile, _result::GAsyncResult)
    err = err_buf()
    ret = ccall(("g_file_trash_finish", libgio), Cint, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _result, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function unmount_mountable_with_operation(instance::GFile, _flags, _mount_operation::Maybe(GMountOperation), _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _mount_operation_maybe = nothing_to_null(_mount_operation)
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    ret = ccall(("g_file_unmount_mountable_with_operation", libgio), Nothing, (Ptr{GObject}, UInt32, Ptr{GObject}, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _flags, _mount_operation_maybe, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function unmount_mountable_with_operation_finish(instance::GFile, _result::GAsyncResult)
    err = err_buf()
    ret = ccall(("g_file_unmount_mountable_with_operation_finish", libgio), Cint, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _result, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function get_fd(instance::GFileDescriptorBased)
    ret = ccall(("g_file_descriptor_based_get_fd", libgio), Int32, (Ptr{GObject},), instance)
    ret
end
function init(instance::GInitable, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_initable_init", libgio), Cint, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _cancellable_maybe, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function get_item_type(instance::GListModel)
    ret = ccall(("g_list_model_get_item_type", libgio), UInt64, (Ptr{GObject},), instance)
    ret
end
function get_n_items(instance::GListModel)
    ret = ccall(("g_list_model_get_n_items", libgio), UInt32, (Ptr{GObject},), instance)
    ret
end
function get_item(instance::GListModel, _position::Integer)
    ret = ccall(("g_list_model_get_object", libgio), Ptr{GObject}, (Ptr{GObject}, UInt32), instance, _position)
    ret2 = convert_if_not_null(GObject, ret, true)
    ret2
end
function items_changed(instance::GListModel, _position::Integer, _removed::Integer, _added::Integer)
    ret = ccall(("g_list_model_items_changed", libgio), Nothing, (Ptr{GObject}, UInt32, UInt32, UInt32), instance, _position, _removed, _added)
    nothing
end
function load(instance::GLoadableIcon, _size::Integer, _cancellable::Maybe(GCancellable))
    m_type = Ref{Cstring}()
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_loadable_icon_load", libgio), Ptr{GObject}, (Ptr{GObject}, Int32, Ptr{Cstring}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _size, m_type, _cancellable_maybe, err)
    check_err(err)
    ret2 = convert(GInputStream, ret, true)
    _type = m_type[]
    _type = string_or_nothing(_type, true)
    (ret2, _type)
end
function load_async(instance::GLoadableIcon, _size::Integer, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    ret = ccall(("g_loadable_icon_load_async", libgio), Nothing, (Ptr{GObject}, Int32, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _size, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function load_finish(instance::GLoadableIcon, _res::GAsyncResult)
    m_type = Ref{Cstring}()
    err = err_buf()
    ret = ccall(("g_loadable_icon_load_finish", libgio), Ptr{GObject}, (Ptr{GObject}, Ptr{GObject}, Ptr{Cstring}, Ptr{Ptr{GError}}), instance, _res, m_type, err)
    check_err(err)
    ret2 = convert(GInputStream, ret, true)
    _type = m_type[]
    _type = string_or_nothing(_type, true)
    (ret2, _type)
end
function can_poll(instance::GPollableInputStream)
    ret = ccall(("g_pollable_input_stream_can_poll", libgio), Cint, (Ptr{GObject},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function create_source(instance::GPollableInputStream, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    ret = ccall(("g_pollable_input_stream_create_source", libgio), Ptr{_GSource}, (Ptr{GObject}, Ptr{GObject}), instance, _cancellable_maybe)
    ret2 = convert(GSourceLike, ret, true)
    ret2
end
function is_readable(instance::GPollableInputStream)
    ret = ccall(("g_pollable_input_stream_is_readable", libgio), Cint, (Ptr{GObject},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function read_nonblocking(instance::GPollableInputStream, _cancellable::Maybe(GCancellable))
    m_buffer = Ref{Ptr{UInt8}}()
    _cancellable_maybe = nothing_to_null(_cancellable)
    _count = length(_buffer)
    err = err_buf()
    ret = ccall(("g_pollable_input_stream_read_nonblocking", libgio), Int64, (Ptr{GObject}, Ptr{Ptr{UInt8}}, UInt64, Ptr{GObject}, Ptr{Ptr{GError}}), instance, m_buffer, _count, _cancellable_maybe, err)
    check_err(err)
    _buffer = m_buffer[]
    _buffer = collect(unsafe_wrap(Vector{UInt8}, _buffer, m_count[]))
    (ret, _buffer)
end
function get_power_saver_enabled(instance::GPowerProfileMonitor)
    ret = ccall(("g_power_profile_monitor_get_power_saver_enabled", libgio), Cint, (Ptr{GObject},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function get_default_for_protocol(_protocol::Union{AbstractString, Symbol})
    ret = ccall(("g_proxy_get_default_for_protocol", libgio), Ptr{GObject}, (Cstring,), _protocol)
    ret2 = GLib.find_leaf_type_if_not_null(ret, true)
    ret2
end
function connect(instance::GProxy, _connection::GIOStream, _proxy_address::GProxyAddress, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_proxy_connect", libgio), Ptr{GObject}, (Ptr{GObject}, Ptr{GObject}, Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _connection, _proxy_address, _cancellable_maybe, err)
    check_err(err)
    ret2 = convert(GIOStream, ret, true)
    ret2
end
function connect_async(instance::GProxy, _connection::GIOStream, _proxy_address::GProxyAddress, _cancellable::Maybe(GCancellable), _callback::Maybe(Function))
    _cancellable_maybe = nothing_to_null(_cancellable)
    if _callback === nothing
        _callback_cfunc = C_NULL
        _callback_closure = C_NULL
    else
        _callback_cfunc = @cfunction(GAsyncReadyCallback, Nothing, (Ptr{GObject}, Ptr{GObject}, Ref{Function}))
        _callback_closure = GLib.gc_ref(_callback)
    end
    ret = ccall(("g_proxy_connect_async", libgio), Nothing, (Ptr{GObject}, Ptr{GObject}, Ptr{GObject}, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}), instance, _connection, _proxy_address, _cancellable_maybe, _callback_cfunc, _callback_closure)
    nothing
end
function connect_finish(instance::GProxy, _result::GAsyncResult)
    err = err_buf()
    ret = ccall(("g_proxy_connect_finish", libgio), Ptr{GObject}, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _result, err)
    check_err(err)
    ret2 = convert(GIOStream, ret, true)
    ret2
end
function supports_hostname(instance::GProxy)
    ret = ccall(("g_proxy_supports_hostname", libgio), Cint, (Ptr{GObject},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function activate_action_full(instance::GRemoteActionGroup, _action_name::Union{AbstractString, Symbol}, _parameter::Maybe(GVariant), _platform_data::GVariant)
    _parameter_maybe = nothing_to_null(_parameter)
    ret = ccall(("g_remote_action_group_activate_action_full", libgio), Nothing, (Ptr{GObject}, Cstring, Ptr{GVariant}, Ptr{GVariant}), instance, _action_name, _parameter_maybe, _platform_data)
    nothing
end
function change_action_state_full(instance::GRemoteActionGroup, _action_name::Union{AbstractString, Symbol}, _value::GVariant, _platform_data::GVariant)
    ret = ccall(("g_remote_action_group_change_action_state_full", libgio), Nothing, (Ptr{GObject}, Cstring, Ptr{GVariant}, Ptr{GVariant}), instance, _action_name, _value, _platform_data)
    nothing
end
function can_seek(instance::GSeekable)
    ret = ccall(("g_seekable_can_seek", libgio), Cint, (Ptr{GObject},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function can_truncate(instance::GSeekable)
    ret = ccall(("g_seekable_can_truncate", libgio), Cint, (Ptr{GObject},), instance)
    ret2 = convert(Bool, ret)
    ret2
end
function seek(instance::GSeekable, _offset::Integer, _type, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_seekable_seek", libgio), Cint, (Ptr{GObject}, Int64, UInt32, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _offset, _type, _cancellable_maybe, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function tell(instance::GSeekable)
    ret = ccall(("g_seekable_tell", libgio), Int64, (Ptr{GObject},), instance)
    ret
end
function truncate(instance::GSeekable, _offset::Integer, _cancellable::Maybe(GCancellable))
    _cancellable_maybe = nothing_to_null(_cancellable)
    err = err_buf()
    ret = ccall(("g_seekable_truncate", libgio), Cint, (Ptr{GObject}, Int64, Ptr{GObject}, Ptr{Ptr{GError}}), instance, _offset, _cancellable_maybe, err)
    check_err(err)
    ret2 = convert(Bool, ret)
    ret2
end
function new(_anchors::Union{AbstractString, Symbol})
    err = err_buf()
    ret = ccall(("g_tls_file_database_new", libgio), Ptr{GTlsDatabase}, (Cstring, Ptr{Ptr{GError}}), _anchors, err)
    check_err(err)
    ret2 = begin
            leaftype = GLib.find_leaf_type(ret)
            convert(leaftype, ret, true)
        end
    ret2
end
function new(_base_io_stream::GIOStream, _certificate::Maybe(GTlsCertificate))
    _certificate_maybe = nothing_to_null(_certificate)
    err = err_buf()
    ret = ccall(("g_tls_server_connection_new", libgio), Ptr{GTlsConnection}, (Ptr{GObject}, Ptr{GObject}, Ptr{Ptr{GError}}), _base_io_stream, _certificate_maybe, err)
    check_err(err)
    ret2 = begin
            leaftype = GLib.find_leaf_type(ret)
            convert(leaftype, ret, true)
        end
    ret2
end
