quote
$(Expr(:toplevel, quote
    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::GAppInfo, _files::GLib.LList{GLib._GList{Ptr{GObject}}})
        ret = ccall(("g_app_launch_context_get_startup_notify_id", libgio), Cstring, (Ptr{GObject}, Ptr{GObject}, Ptr{GLib._GList{Ptr{GObject}}}), instance, _info, _files)
        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 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 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 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 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 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_async(instance::GFile, _destination::GFile, _flags, _io_priority::Integer, _cancellable::Maybe(GCancellable), _progress_callback::Maybe(Function), _callback::Maybe(Function))
        _cancellable_maybe = nothing_to_null(_cancellable)
        if _progress_callback === nothing
            _progress_callback_cfunc = C_NULL
            begin
                _progress_callback_closure = C_NULL
                _progress_callback_notify = C_NULL
            end
        else
            _progress_callback_cfunc = @cfunction(GFileProgressCallback, Nothing, (Int64, Int64, Ref{Function}))
            (_progress_callback_closure, _progress_callback_notify) = GLib.gc_ref_closure(_progress_callback)
        end
        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_copy_async", libgio), Nothing, (Ptr{GObject}, Ptr{GObject}, UInt32, Int32, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}, Ptr{Cvoid}, Ptr{Nothing}), instance, _destination, _flags, _io_priority, _cancellable_maybe, _progress_callback_cfunc, _progress_callback_closure, _callback_cfunc, _callback_closure)
        nothing
    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_async(instance::GFile, _destination::GFile, _flags, _io_priority::Integer, _cancellable::Maybe(GCancellable), _progress_callback::Maybe(Function), _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
        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_move_async", libgio), Nothing, (Ptr{GObject}, Ptr{GObject}, UInt32, Int32, Ptr{GObject}, Ptr{Cvoid}, Ptr{Nothing}, Ptr{Cvoid}, Ptr{Nothing}), instance, _destination, _flags, _io_priority, _cancellable_maybe, _progress_callback_cfunc, _progress_callback_closure, _callback_cfunc, _callback_closure)
        nothing
    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
end))
end
