import typing

from gi.repository import GioUnix
from gi.repository import GLib
from gi.repository import GObject
from typing_extensions import Self

T = typing.TypeVar("T")
ObjectItemType = typing.TypeVar("ObjectItemType", bound=GObject.Object)

DBUS_METHOD_INVOCATION_HANDLED: bool = True
DBUS_METHOD_INVOCATION_UNHANDLED: bool = False
DEBUG_CONTROLLER_EXTENSION_POINT_NAME: str = "gio-debug-controller"
DESKTOP_APP_INFO_LOOKUP_EXTENSION_POINT_NAME: str = "gio-desktop-app-info-lookup"
DRIVE_IDENTIFIER_KIND_UNIX_DEVICE: str = "unix-device"
FILE_ATTRIBUTE_ACCESS_CAN_DELETE: str = "access::can-delete"
FILE_ATTRIBUTE_ACCESS_CAN_EXECUTE: str = "access::can-execute"
FILE_ATTRIBUTE_ACCESS_CAN_READ: str = "access::can-read"
FILE_ATTRIBUTE_ACCESS_CAN_RENAME: str = "access::can-rename"
FILE_ATTRIBUTE_ACCESS_CAN_TRASH: str = "access::can-trash"
FILE_ATTRIBUTE_ACCESS_CAN_WRITE: str = "access::can-write"
FILE_ATTRIBUTE_DOS_IS_ARCHIVE: str = "dos::is-archive"
FILE_ATTRIBUTE_DOS_IS_MOUNTPOINT: str = "dos::is-mountpoint"
FILE_ATTRIBUTE_DOS_IS_SYSTEM: str = "dos::is-system"
FILE_ATTRIBUTE_DOS_REPARSE_POINT_TAG: str = "dos::reparse-point-tag"
FILE_ATTRIBUTE_ETAG_VALUE: str = "etag::value"
FILE_ATTRIBUTE_FILESYSTEM_FREE: str = "filesystem::free"
FILE_ATTRIBUTE_FILESYSTEM_READONLY: str = "filesystem::readonly"
FILE_ATTRIBUTE_FILESYSTEM_REMOTE: str = "filesystem::remote"
FILE_ATTRIBUTE_FILESYSTEM_SIZE: str = "filesystem::size"
FILE_ATTRIBUTE_FILESYSTEM_TYPE: str = "filesystem::type"
FILE_ATTRIBUTE_FILESYSTEM_USED: str = "filesystem::used"
FILE_ATTRIBUTE_FILESYSTEM_USE_PREVIEW: str = "filesystem::use-preview"
FILE_ATTRIBUTE_GVFS_BACKEND: str = "gvfs::backend"
FILE_ATTRIBUTE_ID_FILE: str = "id::file"
FILE_ATTRIBUTE_ID_FILESYSTEM: str = "id::filesystem"
FILE_ATTRIBUTE_MOUNTABLE_CAN_EJECT: str = "mountable::can-eject"
FILE_ATTRIBUTE_MOUNTABLE_CAN_MOUNT: str = "mountable::can-mount"
FILE_ATTRIBUTE_MOUNTABLE_CAN_POLL: str = "mountable::can-poll"
FILE_ATTRIBUTE_MOUNTABLE_CAN_START: str = "mountable::can-start"
FILE_ATTRIBUTE_MOUNTABLE_CAN_START_DEGRADED: str = "mountable::can-start-degraded"
FILE_ATTRIBUTE_MOUNTABLE_CAN_STOP: str = "mountable::can-stop"
FILE_ATTRIBUTE_MOUNTABLE_CAN_UNMOUNT: str = "mountable::can-unmount"
FILE_ATTRIBUTE_MOUNTABLE_HAL_UDI: str = "mountable::hal-udi"
FILE_ATTRIBUTE_MOUNTABLE_IS_MEDIA_CHECK_AUTOMATIC: str = (
    "mountable::is-media-check-automatic"
)
FILE_ATTRIBUTE_MOUNTABLE_START_STOP_TYPE: str = "mountable::start-stop-type"
FILE_ATTRIBUTE_MOUNTABLE_UNIX_DEVICE: str = "mountable::unix-device"
FILE_ATTRIBUTE_MOUNTABLE_UNIX_DEVICE_FILE: str = "mountable::unix-device-file"
FILE_ATTRIBUTE_OWNER_GROUP: str = "owner::group"
FILE_ATTRIBUTE_OWNER_USER: str = "owner::user"
FILE_ATTRIBUTE_OWNER_USER_REAL: str = "owner::user-real"
FILE_ATTRIBUTE_PREVIEW_ICON: str = "preview::icon"
FILE_ATTRIBUTE_RECENT_MODIFIED: str = "recent::modified"
FILE_ATTRIBUTE_SELINUX_CONTEXT: str = "selinux::context"
FILE_ATTRIBUTE_STANDARD_ALLOCATED_SIZE: str = "standard::allocated-size"
FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE: str = "standard::content-type"
FILE_ATTRIBUTE_STANDARD_COPY_NAME: str = "standard::copy-name"
FILE_ATTRIBUTE_STANDARD_DESCRIPTION: str = "standard::description"
FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME: str = "standard::display-name"
FILE_ATTRIBUTE_STANDARD_EDIT_NAME: str = "standard::edit-name"
FILE_ATTRIBUTE_STANDARD_FAST_CONTENT_TYPE: str = "standard::fast-content-type"
FILE_ATTRIBUTE_STANDARD_ICON: str = "standard::icon"
FILE_ATTRIBUTE_STANDARD_IS_BACKUP: str = "standard::is-backup"
FILE_ATTRIBUTE_STANDARD_IS_HIDDEN: str = "standard::is-hidden"
FILE_ATTRIBUTE_STANDARD_IS_SYMLINK: str = "standard::is-symlink"
FILE_ATTRIBUTE_STANDARD_IS_VIRTUAL: str = "standard::is-virtual"
FILE_ATTRIBUTE_STANDARD_IS_VOLATILE: str = "standard::is-volatile"
FILE_ATTRIBUTE_STANDARD_NAME: str = "standard::name"
FILE_ATTRIBUTE_STANDARD_SIZE: str = "standard::size"
FILE_ATTRIBUTE_STANDARD_SORT_ORDER: str = "standard::sort-order"
FILE_ATTRIBUTE_STANDARD_SYMBOLIC_ICON: str = "standard::symbolic-icon"
FILE_ATTRIBUTE_STANDARD_SYMLINK_TARGET: str = "standard::symlink-target"
FILE_ATTRIBUTE_STANDARD_TARGET_URI: str = "standard::target-uri"
FILE_ATTRIBUTE_STANDARD_TYPE: str = "standard::type"
FILE_ATTRIBUTE_THUMBNAILING_FAILED: str = "thumbnail::failed"
FILE_ATTRIBUTE_THUMBNAILING_FAILED_LARGE: str = "thumbnail::failed-large"
FILE_ATTRIBUTE_THUMBNAILING_FAILED_NORMAL: str = "thumbnail::failed-normal"
FILE_ATTRIBUTE_THUMBNAILING_FAILED_XLARGE: str = "thumbnail::failed-xlarge"
FILE_ATTRIBUTE_THUMBNAILING_FAILED_XXLARGE: str = "thumbnail::failed-xxlarge"
FILE_ATTRIBUTE_THUMBNAIL_IS_VALID: str = "thumbnail::is-valid"
FILE_ATTRIBUTE_THUMBNAIL_IS_VALID_LARGE: str = "thumbnail::is-valid-large"
FILE_ATTRIBUTE_THUMBNAIL_IS_VALID_NORMAL: str = "thumbnail::is-valid-normal"
FILE_ATTRIBUTE_THUMBNAIL_IS_VALID_XLARGE: str = "thumbnail::is-valid-xlarge"
FILE_ATTRIBUTE_THUMBNAIL_IS_VALID_XXLARGE: str = "thumbnail::is-valid-xxlarge"
FILE_ATTRIBUTE_THUMBNAIL_PATH: str = "thumbnail::path"
FILE_ATTRIBUTE_THUMBNAIL_PATH_LARGE: str = "thumbnail::path-large"
FILE_ATTRIBUTE_THUMBNAIL_PATH_NORMAL: str = "thumbnail::path-normal"
FILE_ATTRIBUTE_THUMBNAIL_PATH_XLARGE: str = "thumbnail::path-xlarge"
FILE_ATTRIBUTE_THUMBNAIL_PATH_XXLARGE: str = "thumbnail::path-xxlarge"
FILE_ATTRIBUTE_TIME_ACCESS: str = "time::access"
FILE_ATTRIBUTE_TIME_ACCESS_NSEC: str = "time::access-nsec"
FILE_ATTRIBUTE_TIME_ACCESS_USEC: str = "time::access-usec"
FILE_ATTRIBUTE_TIME_CHANGED: str = "time::changed"
FILE_ATTRIBUTE_TIME_CHANGED_NSEC: str = "time::changed-nsec"
FILE_ATTRIBUTE_TIME_CHANGED_USEC: str = "time::changed-usec"
FILE_ATTRIBUTE_TIME_CREATED: str = "time::created"
FILE_ATTRIBUTE_TIME_CREATED_NSEC: str = "time::created-nsec"
FILE_ATTRIBUTE_TIME_CREATED_USEC: str = "time::created-usec"
FILE_ATTRIBUTE_TIME_MODIFIED: str = "time::modified"
FILE_ATTRIBUTE_TIME_MODIFIED_NSEC: str = "time::modified-nsec"
FILE_ATTRIBUTE_TIME_MODIFIED_USEC: str = "time::modified-usec"
FILE_ATTRIBUTE_TRASH_DELETION_DATE: str = "trash::deletion-date"
FILE_ATTRIBUTE_TRASH_ITEM_COUNT: str = "trash::item-count"
FILE_ATTRIBUTE_TRASH_ORIG_PATH: str = "trash::orig-path"
FILE_ATTRIBUTE_UNIX_BLOCKS: str = "unix::blocks"
FILE_ATTRIBUTE_UNIX_BLOCK_SIZE: str = "unix::block-size"
FILE_ATTRIBUTE_UNIX_DEVICE: str = "unix::device"
FILE_ATTRIBUTE_UNIX_GID: str = "unix::gid"
FILE_ATTRIBUTE_UNIX_INODE: str = "unix::inode"
FILE_ATTRIBUTE_UNIX_IS_MOUNTPOINT: str = "unix::is-mountpoint"
FILE_ATTRIBUTE_UNIX_MODE: str = "unix::mode"
FILE_ATTRIBUTE_UNIX_NLINK: str = "unix::nlink"
FILE_ATTRIBUTE_UNIX_RDEV: str = "unix::rdev"
FILE_ATTRIBUTE_UNIX_UID: str = "unix::uid"
MEMORY_MONITOR_EXTENSION_POINT_NAME: str = "gio-memory-monitor"
MENU_ATTRIBUTE_ACTION: str = "action"
MENU_ATTRIBUTE_ACTION_NAMESPACE: str = "action-namespace"
MENU_ATTRIBUTE_ICON: str = "icon"
MENU_ATTRIBUTE_LABEL: str = "label"
MENU_ATTRIBUTE_TARGET: str = "target"
MENU_EXPORTER_MAX_SECTION_SIZE: int = 1000
MENU_LINK_SECTION: str = "section"
MENU_LINK_SUBMENU: str = "submenu"
NATIVE_VOLUME_MONITOR_EXTENSION_POINT_NAME: str = "gio-native-volume-monitor"
NETWORK_MONITOR_EXTENSION_POINT_NAME: str = "gio-network-monitor"
POWER_PROFILE_MONITOR_EXTENSION_POINT_NAME: str = "gio-power-profile-monitor"
PROXY_EXTENSION_POINT_NAME: str = "gio-proxy"
PROXY_RESOLVER_EXTENSION_POINT_NAME: str = "gio-proxy-resolver"
SETTINGS_BACKEND_EXTENSION_POINT_NAME: str = "gsettings-backend"
TLS_BACKEND_EXTENSION_POINT_NAME: str = "gio-tls-backend"
TLS_DATABASE_PURPOSE_AUTHENTICATE_CLIENT: str = "1.3.6.1.5.5.7.3.2"
TLS_DATABASE_PURPOSE_AUTHENTICATE_SERVER: str = "1.3.6.1.5.5.7.3.1"
VFS_EXTENSION_POINT_NAME: str = "gio-vfs"
VOLUME_IDENTIFIER_KIND_CLASS: str = "class"
VOLUME_IDENTIFIER_KIND_HAL_UDI: str = "hal-udi"
VOLUME_IDENTIFIER_KIND_LABEL: str = "label"
VOLUME_IDENTIFIER_KIND_NFS_MOUNT: str = "nfs-mount"
VOLUME_IDENTIFIER_KIND_UNIX_DEVICE: str = "unix-device"
VOLUME_IDENTIFIER_KIND_UUID: str = "uuid"
VOLUME_MONITOR_EXTENSION_POINT_NAME: str = "gio-volume-monitor"

def action_name_is_valid(action_name: str) -> bool: ...
def action_parse_detailed_name(
    detailed_name: str,
) -> typing.Tuple[bool, str, GLib.Variant]: ...
def action_print_detailed_name(
    action_name: str, target_value: typing.Optional[GLib.Variant] = None
) -> str: ...
def app_info_create_from_commandline(
    commandline: str, application_name: typing.Optional[str], flags: AppInfoCreateFlags
) -> AppInfo: ...
def app_info_get_all() -> list[AppInfo]: ...
def app_info_get_all_for_type(content_type: str) -> list[AppInfo]: ...
def app_info_get_default_for_type(
    content_type: str, must_support_uris: bool
) -> typing.Optional[AppInfo]: ...
def app_info_get_default_for_type_async(
    content_type: str,
    must_support_uris: bool,
    cancellable: typing.Optional[Cancellable] = None,
    callback: typing.Optional[typing.Callable[..., None]] = None,
    *user_data: typing.Any,
) -> None: ...
def app_info_get_default_for_type_finish(result: AsyncResult) -> AppInfo: ...
def app_info_get_default_for_uri_scheme(
    uri_scheme: str,
) -> typing.Optional[AppInfo]: ...
def app_info_get_default_for_uri_scheme_async(
    uri_scheme: str,
    cancellable: typing.Optional[Cancellable] = None,
    callback: typing.Optional[typing.Callable[..., None]] = None,
    *user_data: typing.Any,
) -> None: ...
def app_info_get_default_for_uri_scheme_finish(result: AsyncResult) -> AppInfo: ...
def app_info_get_fallback_for_type(content_type: str) -> list[AppInfo]: ...
def app_info_get_recommended_for_type(content_type: str) -> list[AppInfo]: ...
def app_info_launch_default_for_uri(
    uri: str, context: typing.Optional[AppLaunchContext] = None
) -> bool: ...
def app_info_launch_default_for_uri_async(
    uri: str,
    context: typing.Optional[AppLaunchContext] = None,
    cancellable: typing.Optional[Cancellable] = None,
    callback: typing.Optional[typing.Callable[..., None]] = None,
    *user_data: typing.Any,
) -> None: ...
def app_info_launch_default_for_uri_finish(result: AsyncResult) -> bool: ...
def app_info_reset_type_associations(content_type: str) -> None: ...
def async_initable_newv_async(
    object_type: typing.Type[typing.Any],
    n_parameters: int,
    parameters: GObject.Parameter,
    io_priority: int,
    cancellable: typing.Optional[Cancellable] = None,
    callback: typing.Optional[typing.Callable[..., None]] = None,
    *user_data: typing.Any,
) -> None: ...
def bus_get(
    bus_type: BusType,
    cancellable: typing.Optional[Cancellable] = None,
    callback: typing.Optional[typing.Callable[..., None]] = None,
    *user_data: typing.Any,
) -> None: ...
def bus_get_finish(res: AsyncResult) -> DBusConnection: ...
def bus_get_sync(
    bus_type: BusType, cancellable: typing.Optional[Cancellable] = None
) -> DBusConnection: ...
def bus_own_name(
    bus_type: BusType,
    name: str,
    flags: BusNameOwnerFlags,
    bus_acquired_closure: typing.Optional[typing.Callable[..., typing.Any]] = None,
    name_acquired_closure: typing.Optional[typing.Callable[..., typing.Any]] = None,
    name_lost_closure: typing.Optional[typing.Callable[..., typing.Any]] = None,
) -> int: ...
def bus_own_name_on_connection(
    connection: DBusConnection,
    name: str,
    flags: BusNameOwnerFlags,
    name_acquired_closure: typing.Optional[typing.Callable[..., typing.Any]] = None,
    name_lost_closure: typing.Optional[typing.Callable[..., typing.Any]] = None,
) -> int: ...
def bus_unown_name(owner_id: int) -> None: ...
def bus_unwatch_name(watcher_id: int) -> None: ...
def bus_watch_name(
    bus_type: BusType,
    name: str,
    flags: BusNameWatcherFlags,
    name_appeared_closure: typing.Optional[typing.Callable[..., typing.Any]] = None,
    name_vanished_closure: typing.Optional[typing.Callable[..., typing.Any]] = None,
) -> int: ...
def bus_watch_name_on_connection(
    connection: DBusConnection,
    name: str,
    flags: BusNameWatcherFlags,
    name_appeared_closure: typing.Optional[typing.Callable[..., typing.Any]] = None,
    name_vanished_closure: typing.Optional[typing.Callable[..., typing.Any]] = None,
) -> int: ...
def content_type_can_be_executable(type: str) -> bool: ...
def content_type_equals(type1: str, type2: str) -> bool: ...
def content_type_from_mime_type(mime_type: str) -> typing.Optional[str]: ...
def content_type_get_description(type: str) -> str: ...
def content_type_get_generic_icon_name(type: str) -> typing.Optional[str]: ...
def content_type_get_icon(type: str) -> Icon: ...
def content_type_get_mime_dirs() -> list[str]: ...
def content_type_get_mime_type(type: str) -> typing.Optional[str]: ...
def content_type_get_symbolic_icon(type: str) -> Icon: ...
def content_type_guess(
    filename: typing.Optional[str] = None,
    data: typing.Optional[typing.Sequence[int]] = None,
) -> typing.Tuple[str, bool]: ...
def content_type_guess_for_tree(root: File) -> list[str]: ...
def content_type_is_a(type: str, supertype: str) -> bool: ...
def content_type_is_mime_type(type: str, mime_type: str) -> bool: ...
def content_type_is_unknown(type: str) -> bool: ...
def content_type_set_mime_dirs(
    dirs: typing.Optional[typing.Sequence[str]] = None,
) -> None: ...
def content_types_get_registered() -> list[str]: ...
def dbus_address_escape_value(string: str) -> str: ...
def dbus_address_get_for_bus_sync(
    bus_type: BusType, cancellable: typing.Optional[Cancellable] = None
) -> str: ...
def dbus_address_get_stream(
    address: str,
    cancellable: typing.Optional[Cancellable] = None,
    callback: typing.Optional[typing.Callable[..., None]] = None,
    *user_data: typing.Any,
) -> None: ...
def dbus_address_get_stream_finish(res: AsyncResult) -> typing.Tuple[IOStream, str]: ...
def dbus_address_get_stream_sync(
    address: str, cancellable: typing.Optional[Cancellable] = None
) -> typing.Tuple[IOStream, str]: ...
def dbus_annotation_info_lookup(
    annotations: typing.Optional[typing.Sequence[DBusAnnotationInfo]], name: str
) -> typing.Optional[str]: ...
def dbus_error_encode_gerror(error: GLib.Error) -> str: ...
def dbus_error_get_remote_error(error: GLib.Error) -> typing.Optional[str]: ...
def dbus_error_is_remote_error(error: GLib.Error) -> bool: ...
def dbus_error_new_for_dbus_error(
    dbus_error_name: str, dbus_error_message: str
) -> GLib.Error: ...
def dbus_error_quark() -> int: ...
def dbus_error_register_error(
    error_domain: int, error_code: int, dbus_error_name: str
) -> bool: ...
def dbus_error_register_error_domain(
    error_domain_quark_name: str,
    quark_volatile: int,
    entries: typing.Sequence[DBusErrorEntry],
) -> None: ...
def dbus_error_strip_remote_error(error: GLib.Error) -> bool: ...
def dbus_error_unregister_error(
    error_domain: int, error_code: int, dbus_error_name: str
) -> bool: ...
def dbus_escape_object_path(s: str) -> str: ...
def dbus_escape_object_path_bytestring(bytes: typing.Sequence[int]) -> str: ...
def dbus_generate_guid() -> str: ...
def dbus_gvalue_to_gvariant(
    gvalue: typing.Any, type: GLib.VariantType
) -> GLib.Variant: ...
def dbus_gvariant_to_gvalue(value: GLib.Variant) -> typing.Any: ...
def dbus_is_address(string: str) -> bool: ...
def dbus_is_error_name(string: str) -> bool: ...
def dbus_is_guid(string: str) -> bool: ...
def dbus_is_interface_name(string: str) -> bool: ...
def dbus_is_member_name(string: str) -> bool: ...
def dbus_is_name(string: str) -> bool: ...
def dbus_is_supported_address(string: str) -> bool: ...
def dbus_is_unique_name(string: str) -> bool: ...
def dbus_unescape_object_path(s: str) -> typing.Optional[bytes]: ...
def dtls_client_connection_new(
    base_socket: DatagramBased,
    server_identity: typing.Optional[SocketConnectable] = None,
) -> DtlsClientConnection: ...
def dtls_server_connection_new(
    base_socket: DatagramBased, certificate: typing.Optional[TlsCertificate] = None
) -> DtlsServerConnection: ...
def file_new_build_filenamev(args: typing.Sequence[str]) -> File: ...
def file_new_for_commandline_arg(arg: str) -> File: ...
def file_new_for_commandline_arg_and_cwd(arg: str, cwd: str) -> File: ...
def file_new_for_path(path: str) -> File: ...
def file_new_for_uri(uri: str) -> File: ...
def file_new_tmp(
    tmpl: typing.Optional[str] = None,
) -> typing.Tuple[File, FileIOStream]: ...
def file_new_tmp_async(
    tmpl: typing.Optional[str],
    io_priority: int,
    cancellable: typing.Optional[Cancellable] = None,
    callback: typing.Optional[typing.Callable[..., None]] = None,
    *user_data: typing.Any,
) -> None: ...
def file_new_tmp_dir_async(
    tmpl: typing.Optional[str],
    io_priority: int,
    cancellable: typing.Optional[Cancellable] = None,
    callback: typing.Optional[typing.Callable[..., None]] = None,
    *user_data: typing.Any,
) -> None: ...
def file_new_tmp_dir_finish(result: AsyncResult) -> File: ...
def file_new_tmp_finish(result: AsyncResult) -> typing.Tuple[File, FileIOStream]: ...
def file_parse_name(parse_name: str) -> File: ...
def icon_deserialize(value: GLib.Variant) -> typing.Optional[Icon]: ...
def icon_new_for_string(str: str) -> Icon: ...
def initable_newv(
    object_type: typing.Type[typing.Any],
    parameters: typing.Sequence[GObject.Parameter],
    cancellable: typing.Optional[Cancellable] = None,
) -> GObject.Object: ...
def io_error_from_errno(err_no: int) -> IOErrorEnum: ...
def io_error_from_file_error(file_error: GLib.FileError) -> IOErrorEnum: ...
def io_error_quark() -> int: ...
def io_extension_point_implement(
    extension_point_name: str,
    type: typing.Type[typing.Any],
    extension_name: str,
    priority: int,
) -> IOExtension: ...
def io_extension_point_lookup(name: str) -> IOExtensionPoint: ...
def io_extension_point_register(name: str) -> IOExtensionPoint: ...
def io_modules_load_all_in_directory(dirname: str) -> list[IOModule]: ...
def io_modules_load_all_in_directory_with_scope(
    dirname: str, scope: IOModuleScope
) -> list[IOModule]: ...
def io_modules_scan_all_in_directory(dirname: str) -> None: ...
def io_modules_scan_all_in_directory_with_scope(
    dirname: str, scope: IOModuleScope
) -> None: ...
def io_scheduler_cancel_all_jobs() -> None: ...
def io_scheduler_push_job(
    job_func: typing.Callable[..., bool],
    io_priority: int,
    cancellable: typing.Optional[Cancellable] = None,
    *user_data: typing.Any,
) -> None: ...
def keyfile_settings_backend_new(
    filename: str, root_path: str, root_group: typing.Optional[str] = None
) -> SettingsBackend: ...
def memory_monitor_dup_default() -> MemoryMonitor: ...
def memory_settings_backend_new() -> SettingsBackend: ...
def network_monitor_get_default() -> NetworkMonitor: ...
def networking_init() -> None: ...
def null_settings_backend_new() -> SettingsBackend: ...
def pollable_source_new(pollable_stream: GObject.Object) -> GLib.Source: ...
def pollable_source_new_full(
    pollable_stream: GObject.Object,
    child_source: typing.Optional[GLib.Source] = None,
    cancellable: typing.Optional[Cancellable] = None,
) -> GLib.Source: ...
def pollable_stream_read(
    stream: InputStream,
    buffer: typing.Sequence[int],
    blocking: bool,
    cancellable: typing.Optional[Cancellable] = None,
) -> int: ...
def pollable_stream_write(
    stream: OutputStream,
    buffer: typing.Sequence[int],
    blocking: bool,
    cancellable: typing.Optional[Cancellable] = None,
) -> int: ...
def pollable_stream_write_all(
    stream: OutputStream,
    buffer: typing.Sequence[int],
    blocking: bool,
    cancellable: typing.Optional[Cancellable] = None,
) -> typing.Tuple[bool, int]: ...
def power_profile_monitor_dup_default() -> PowerProfileMonitor: ...
def proxy_get_default_for_protocol(protocol: str) -> typing.Optional[Proxy]: ...
def proxy_resolver_get_default() -> ProxyResolver: ...
def resolver_error_quark() -> int: ...
def resource_error_quark() -> int: ...
def resource_load(filename: str) -> Resource: ...
def resources_enumerate_children(
    path: str, lookup_flags: ResourceLookupFlags
) -> list[str]: ...
def resources_get_info(
    path: str, lookup_flags: ResourceLookupFlags
) -> typing.Tuple[bool, int, int]: ...
def resources_has_children(path: str) -> bool: ...
def resources_lookup_data(
    path: str, lookup_flags: ResourceLookupFlags
) -> GLib.Bytes: ...
def resources_open_stream(
    path: str, lookup_flags: ResourceLookupFlags
) -> InputStream: ...
def resources_register(resource: Resource) -> None: ...
def resources_unregister(resource: Resource) -> None: ...
def settings_schema_source_get_default() -> typing.Optional[SettingsSchemaSource]: ...
def simple_async_report_gerror_in_idle(
    object: typing.Optional[GObject.Object],
    callback: typing.Optional[typing.Callable[..., None]],
    error: GLib.Error,
    *user_data: typing.Any,
) -> None: ...
def tls_backend_get_default() -> TlsBackend: ...
def tls_channel_binding_error_quark() -> int: ...
def tls_client_connection_new(
    base_io_stream: IOStream, server_identity: typing.Optional[SocketConnectable] = None
) -> TlsClientConnection: ...
def tls_error_quark() -> int: ...
def tls_file_database_new(anchors: str) -> TlsFileDatabase: ...
def tls_server_connection_new(
    base_io_stream: IOStream, certificate: typing.Optional[TlsCertificate] = None
) -> TlsServerConnection: ...
def unix_is_mount_path_system_internal(mount_path: str) -> bool: ...
def unix_is_system_device_path(device_path: str) -> bool: ...
def unix_is_system_fs_type(fs_type: str) -> bool: ...
def unix_mount_at(
    mount_path: str,
) -> typing.Tuple[typing.Optional[GioUnix.MountEntry], int]: ...
def unix_mount_compare(
    mount1: GioUnix.MountEntry, mount2: GioUnix.MountEntry
) -> int: ...
def unix_mount_copy(mount_entry: GioUnix.MountEntry) -> GioUnix.MountEntry: ...
def unix_mount_entries_changed_since(time: int) -> bool: ...
def unix_mount_entries_get() -> typing.Tuple[list[GioUnix.MountEntry], int]: ...
def unix_mount_entries_get_from_file(
    table_path: str,
) -> typing.Tuple[typing.Optional[list[GioUnix.MountEntry]], int]: ...
def unix_mount_entry_at(
    mount_path: str,
) -> typing.Tuple[typing.Optional[GioUnix.MountEntry], int]: ...
def unix_mount_entry_for(
    file_path: str,
) -> typing.Tuple[typing.Optional[GioUnix.MountEntry], int]: ...
def unix_mount_for(
    file_path: str,
) -> typing.Tuple[typing.Optional[GioUnix.MountEntry], int]: ...
def unix_mount_free(mount_entry: GioUnix.MountEntry) -> None: ...
def unix_mount_get_device_path(mount_entry: GioUnix.MountEntry) -> str: ...
def unix_mount_get_fs_type(mount_entry: GioUnix.MountEntry) -> str: ...
def unix_mount_get_mount_path(mount_entry: GioUnix.MountEntry) -> str: ...
def unix_mount_get_options(mount_entry: GioUnix.MountEntry) -> typing.Optional[str]: ...
def unix_mount_get_root_path(
    mount_entry: GioUnix.MountEntry,
) -> typing.Optional[str]: ...
def unix_mount_guess_can_eject(mount_entry: GioUnix.MountEntry) -> bool: ...
def unix_mount_guess_icon(mount_entry: GioUnix.MountEntry) -> Icon: ...
def unix_mount_guess_name(mount_entry: GioUnix.MountEntry) -> str: ...
def unix_mount_guess_should_display(mount_entry: GioUnix.MountEntry) -> bool: ...
def unix_mount_guess_symbolic_icon(mount_entry: GioUnix.MountEntry) -> Icon: ...
def unix_mount_is_readonly(mount_entry: GioUnix.MountEntry) -> bool: ...
def unix_mount_is_system_internal(mount_entry: GioUnix.MountEntry) -> bool: ...
def unix_mount_point_at(
    mount_path: str,
) -> typing.Tuple[typing.Optional[GioUnix.MountPoint], int]: ...
def unix_mount_points_changed_since(time: int) -> bool: ...
def unix_mount_points_get() -> typing.Tuple[list[GioUnix.MountPoint], int]: ...
def unix_mount_points_get_from_file(
    table_path: str,
) -> typing.Tuple[typing.Optional[list[GioUnix.MountPoint]], int]: ...
def unix_mounts_changed_since(time: int) -> bool: ...
def unix_mounts_get() -> typing.Tuple[list[GioUnix.MountEntry], int]: ...
def unix_mounts_get_from_file(
    table_path: str,
) -> typing.Tuple[typing.Optional[list[GioUnix.MountEntry]], int]: ...

class Action(GObject.GInterface):
    """
    Interface GAction

    Signals from GObject:
      notify (GParam)
    """
    def activate(self, parameter: typing.Optional[GLib.Variant] = None) -> None: ...
    def change_state(self, value: GLib.Variant) -> None: ...
    def get_enabled(self) -> bool: ...
    def get_name(self) -> str: ...
    def get_parameter_type(self) -> typing.Optional[GLib.VariantType]: ...
    def get_state(self) -> typing.Optional[GLib.Variant]: ...
    def get_state_hint(self) -> typing.Optional[GLib.Variant]: ...
    def get_state_type(self) -> typing.Optional[GLib.VariantType]: ...
    @staticmethod
    def name_is_valid(action_name: str) -> bool: ...
    @staticmethod
    def parse_detailed_name(
        detailed_name: str,
    ) -> typing.Tuple[bool, str, GLib.Variant]: ...
    @staticmethod
    def print_detailed_name(
        action_name: str, target_value: typing.Optional[GLib.Variant] = None
    ) -> str: ...

class ActionEntry(GObject.GPointer):
    """
    :Constructors:

    ::

        ActionEntry()
    """

    name: str = ...
    activate: typing.Callable[..., None] = ...
    parameter_type: str = ...
    state: str = ...
    change_state: typing.Callable[..., None] = ...
    padding: list[int] = ...

class ActionGroup(GObject.GInterface):
    """
    Interface GActionGroup

    Signals from GObject:
      notify (GParam)
    """
    def action_added(self, action_name: str) -> None: ...
    def action_enabled_changed(self, action_name: str, enabled: bool) -> None: ...
    def action_removed(self, action_name: str) -> None: ...
    def action_state_changed(self, action_name: str, state: GLib.Variant) -> None: ...
    def activate_action(
        self, action_name: str, parameter: typing.Optional[GLib.Variant] = None
    ) -> None: ...
    def change_action_state(self, action_name: str, value: GLib.Variant) -> None: ...
    def get_action_enabled(self, action_name: str) -> bool: ...
    def get_action_parameter_type(
        self, action_name: str
    ) -> typing.Optional[GLib.VariantType]: ...
    def get_action_state(self, action_name: str) -> typing.Optional[GLib.Variant]: ...
    def get_action_state_hint(
        self, action_name: str
    ) -> typing.Optional[GLib.Variant]: ...
    def get_action_state_type(
        self, action_name: str
    ) -> typing.Optional[GLib.VariantType]: ...
    def has_action(self, action_name: str) -> bool: ...
    def list_actions(self) -> list[str]: ...
    def query_action(
        self, action_name: str
    ) -> typing.Tuple[
        bool, bool, GLib.VariantType, GLib.VariantType, GLib.Variant, GLib.Variant
    ]: ...

class ActionGroupInterface(GObject.GPointer):
    """
    :Constructors:

    ::

        ActionGroupInterface()
    """

    g_iface: GObject.TypeInterface = ...
    has_action: typing.Callable[[ActionGroup, str], bool] = ...
    list_actions: typing.Callable[[ActionGroup], list[str]] = ...
    get_action_enabled: typing.Callable[[ActionGroup, str], bool] = ...
    get_action_parameter_type: typing.Callable[
        [ActionGroup, str], typing.Optional[GLib.VariantType]
    ] = ...
    get_action_state_type: typing.Callable[
        [ActionGroup, str], typing.Optional[GLib.VariantType]
    ] = ...
    get_action_state_hint: typing.Callable[
        [ActionGroup, str], typing.Optional[GLib.Variant]
    ] = ...
    get_action_state: typing.Callable[
        [ActionGroup, str], typing.Optional[GLib.Variant]
    ] = ...
    change_action_state: typing.Callable[[ActionGroup, str, GLib.Variant], None] = ...
    activate_action: typing.Callable[
        [ActionGroup, str, typing.Optional[GLib.Variant]], None
    ] = ...
    action_added: typing.Callable[[ActionGroup, str], None] = ...
    action_removed: typing.Callable[[ActionGroup, str], None] = ...
    action_enabled_changed: typing.Callable[[ActionGroup, str, bool], None] = ...
    action_state_changed: typing.Callable[[ActionGroup, str, GLib.Variant], None] = ...
    query_action: typing.Callable[
        [ActionGroup, str],
        typing.Tuple[
            bool, bool, GLib.VariantType, GLib.VariantType, GLib.Variant, GLib.Variant
        ],
    ] = ...

class ActionInterface(GObject.GPointer):
    """
    :Constructors:

    ::

        ActionInterface()
    """

    g_iface: GObject.TypeInterface = ...
    get_name: typing.Callable[[Action], str] = ...
    get_parameter_type: typing.Callable[
        [Action], typing.Optional[GLib.VariantType]
    ] = ...
    get_state_type: typing.Callable[[Action], typing.Optional[GLib.VariantType]] = ...
    get_state_hint: typing.Callable[[Action], typing.Optional[GLib.Variant]] = ...
    get_enabled: typing.Callable[[Action], bool] = ...
    get_state: typing.Callable[[Action], typing.Optional[GLib.Variant]] = ...
    change_state: typing.Callable[[Action, GLib.Variant], None] = ...
    activate: typing.Callable[[Action, typing.Optional[GLib.Variant]], None] = ...

class ActionMap(GObject.GInterface):
    """
    Interface GActionMap

    Signals from GObject:
      notify (GParam)
    """
    def add_action(self, action: Action) -> None: ...
    def add_action_entries(self, entries, user_data=None):
        """
        The ``add_action_entries()`` method is a convenience function for creating
        multiple :class:`~gi.repository.Gio.SimpleAction` instances and adding them
        to a :class:`~gi.repository.Gio.ActionMap`.
        Each action is constructed as per one entry.

        :param list entries:
            List of entry tuples for :meth:`add_action` method. The entry tuple can
            vary in size with the following information:

            * The name of the action. Must be specified.
            * The callback to connect to the "activate" signal of the
              action. Since GLib 2.40, this can be ``None`` for stateful
              actions, in which case the default handler is used. For
              boolean-stated actions with no parameter, this is a toggle.
              For other state types (and parameter type equal to the state
              type) this will be a function that just calls change_state
              (which you should provide).
            * The type of the parameter that must be passed to the activate
              function for this action, given as a single :class:`~gi.repository.GLib.Variant` type
              string (or ``None`` for no parameter)
            * The initial state for this action, given in GLib.Variant text
              format. The state is parsed with no extra type information, so
              type tags must be added to the string if they are necessary.
              Stateless actions should give ``None`` here.
            * The callback to connect to the "change-state" signal of the
              action. All stateful actions should provide a handler here;
              stateless actions should not.

        :param user_data:
            The user data for signal connections, or ``None``
        """  # FIXME: Override is missing typing annotation
    def lookup_action(self, action_name: str) -> typing.Optional[Action]: ...
    def remove_action(self, action_name: str) -> None: ...
    def remove_action_entries(self, entries: typing.Sequence[ActionEntry]) -> None: ...

class ActionMapInterface(GObject.GPointer):
    """
    :Constructors:

    ::

        ActionMapInterface()
    """

    g_iface: GObject.TypeInterface = ...
    lookup_action: typing.Callable[[ActionMap, str], typing.Optional[Action]] = ...
    add_action: typing.Callable[[ActionMap, Action], None] = ...
    remove_action: typing.Callable[[ActionMap, str], None] = ...

class AppInfo(GObject.GInterface):
    """
    Interface GAppInfo

    Signals from GObject:
      notify (GParam)
    """
    def add_supports_type(self, content_type: str) -> bool: ...
    def can_delete(self) -> bool: ...
    def can_remove_supports_type(self) -> bool: ...
    @staticmethod
    def create_from_commandline(
        commandline: str,
        application_name: typing.Optional[str],
        flags: AppInfoCreateFlags,
    ) -> AppInfo: ...
    def delete(self) -> bool: ...
    def dup(self) -> AppInfo: ...
    def equal(self, appinfo2: AppInfo) -> bool: ...
    @staticmethod
    def get_all() -> list[AppInfo]: ...
    @staticmethod
    def get_all_for_type(content_type: str) -> list[AppInfo]: ...
    def get_commandline(self) -> typing.Optional[str]: ...
    @staticmethod
    def get_default_for_type(
        content_type: str, must_support_uris: bool
    ) -> typing.Optional[AppInfo]: ...
    @staticmethod
    def get_default_for_type_async(
        content_type: str,
        must_support_uris: bool,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    @staticmethod
    def get_default_for_type_finish(result: AsyncResult) -> AppInfo: ...
    @staticmethod
    def get_default_for_uri_scheme(uri_scheme: str) -> typing.Optional[AppInfo]: ...
    @staticmethod
    def get_default_for_uri_scheme_async(
        uri_scheme: str,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    @staticmethod
    def get_default_for_uri_scheme_finish(result: AsyncResult) -> AppInfo: ...
    def get_description(self) -> typing.Optional[str]: ...
    def get_display_name(self) -> str: ...
    def get_executable(self) -> str: ...
    @staticmethod
    def get_fallback_for_type(content_type: str) -> list[AppInfo]: ...
    def get_icon(self) -> typing.Optional[Icon]: ...
    def get_id(self) -> typing.Optional[str]: ...
    def get_name(self) -> str: ...
    @staticmethod
    def get_recommended_for_type(content_type: str) -> list[AppInfo]: ...
    def get_supported_types(self) -> list[str]: ...
    def launch(
        self,
        files: typing.Optional[list[File]] = None,
        context: typing.Optional[AppLaunchContext] = None,
    ) -> bool: ...
    @staticmethod
    def launch_default_for_uri(
        uri: str, context: typing.Optional[AppLaunchContext] = None
    ) -> bool: ...
    @staticmethod
    def launch_default_for_uri_async(
        uri: str,
        context: typing.Optional[AppLaunchContext] = None,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    @staticmethod
    def launch_default_for_uri_finish(result: AsyncResult) -> bool: ...
    def launch_uris(
        self,
        uris: typing.Optional[list[str]] = None,
        context: typing.Optional[AppLaunchContext] = None,
    ) -> bool: ...
    def launch_uris_async(
        self,
        uris: typing.Optional[list[str]] = None,
        context: typing.Optional[AppLaunchContext] = None,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def launch_uris_finish(self, result: AsyncResult) -> bool: ...
    def remove_supports_type(self, content_type: str) -> bool: ...
    @staticmethod
    def reset_type_associations(content_type: str) -> None: ...
    def set_as_default_for_extension(self, extension: str) -> bool: ...
    def set_as_default_for_type(self, content_type: str) -> bool: ...
    def set_as_last_used_for_type(self, content_type: str) -> bool: ...
    def should_show(self) -> bool: ...
    def supports_files(self) -> bool: ...
    def supports_uris(self) -> bool: ...

class AppInfoIface(GObject.GPointer):
    """
    :Constructors:

    ::

        AppInfoIface()
    """

    g_iface: GObject.TypeInterface = ...
    dup: typing.Callable[[AppInfo], AppInfo] = ...
    equal: typing.Callable[[AppInfo, AppInfo], bool] = ...
    get_id: typing.Callable[[AppInfo], typing.Optional[str]] = ...
    get_name: typing.Callable[[AppInfo], str] = ...
    get_description: typing.Callable[[AppInfo], typing.Optional[str]] = ...
    get_executable: typing.Callable[[AppInfo], str] = ...
    get_icon: typing.Callable[[AppInfo], typing.Optional[Icon]] = ...
    launch: typing.Callable[
        [AppInfo, typing.Optional[list[File]], typing.Optional[AppLaunchContext]], bool
    ] = ...
    supports_uris: typing.Callable[[AppInfo], bool] = ...
    supports_files: typing.Callable[[AppInfo], bool] = ...
    launch_uris: typing.Callable[
        [AppInfo, typing.Optional[list[str]], typing.Optional[AppLaunchContext]], bool
    ] = ...
    should_show: typing.Callable[[AppInfo], bool] = ...
    set_as_default_for_type: typing.Callable[[AppInfo, str], bool] = ...
    set_as_default_for_extension: typing.Callable[[AppInfo, str], bool] = ...
    add_supports_type: typing.Callable[[AppInfo, str], bool] = ...
    can_remove_supports_type: typing.Callable[[AppInfo], bool] = ...
    remove_supports_type: typing.Callable[[AppInfo, str], bool] = ...
    can_delete: typing.Callable[[AppInfo], bool] = ...
    do_delete: typing.Callable[[AppInfo], bool] = ...
    get_commandline: typing.Callable[[AppInfo], typing.Optional[str]] = ...
    get_display_name: typing.Callable[[AppInfo], str] = ...
    set_as_last_used_for_type: typing.Callable[[AppInfo, str], bool] = ...
    get_supported_types: typing.Callable[[AppInfo], list[str]] = ...
    launch_uris_async: typing.Callable[..., None] = ...
    launch_uris_finish: typing.Callable[[AppInfo, AsyncResult], bool] = ...

class AppInfoMonitor(GObject.Object):
    """
    :Constructors:

    ::

        AppInfoMonitor(**properties)

    Object GAppInfoMonitor

    Signals from GAppInfoMonitor:
      changed ()

    Signals from GObject:
      notify (GParam)
    """
    @staticmethod
    def get() -> AppInfoMonitor: ...

class AppLaunchContext(GObject.Object):
    """
    :Constructors:

    ::

        AppLaunchContext(**properties)
        new() -> Gio.AppLaunchContext

    Object GAppLaunchContext

    Signals from GAppLaunchContext:
      launch-failed (gchararray)
      launch-started (GAppInfo, GVariant)
      launched (GAppInfo, GVariant)

    Signals from GObject:
      notify (GParam)
    """

    parent_instance: GObject.Object = ...
    priv: AppLaunchContextPrivate = ...
    def do_get_display(
        self, info: AppInfo, files: list[File]
    ) -> typing.Optional[str]: ...
    def do_get_startup_notify_id(
        self,
        info: typing.Optional[AppInfo] = None,
        files: typing.Optional[list[File]] = None,
    ) -> typing.Optional[str]: ...
    def do_launch_failed(self, startup_notify_id: str) -> None: ...
    def do_launch_started(self, info: AppInfo, platform_data: GLib.Variant) -> None: ...
    def do_launched(self, info: AppInfo, platform_data: GLib.Variant) -> None: ...
    def get_display(self, info: AppInfo, files: list[File]) -> typing.Optional[str]: ...
    def get_environment(self) -> list[str]: ...
    def get_startup_notify_id(
        self,
        info: typing.Optional[AppInfo] = None,
        files: typing.Optional[list[File]] = None,
    ) -> typing.Optional[str]: ...
    def launch_failed(self, startup_notify_id: str) -> None: ...
    @classmethod
    def new(cls) -> AppLaunchContext: ...
    def setenv(self, variable: str, value: str) -> None: ...
    def unsetenv(self, variable: str) -> None: ...

class AppLaunchContextClass(GObject.GPointer):
    """
    :Constructors:

    ::

        AppLaunchContextClass()
    """

    parent_class: GObject.ObjectClass = ...
    get_display: typing.Callable[
        [AppLaunchContext, AppInfo, list[File]], typing.Optional[str]
    ] = ...
    get_startup_notify_id: typing.Callable[
        [AppLaunchContext, typing.Optional[AppInfo], typing.Optional[list[File]]],
        typing.Optional[str],
    ] = ...
    launch_failed: typing.Callable[[AppLaunchContext, str], None] = ...
    launched: typing.Callable[[AppLaunchContext, AppInfo, GLib.Variant], None] = ...
    launch_started: typing.Callable[
        [AppLaunchContext, AppInfo, GLib.Variant], None
    ] = ...

class AppLaunchContextPrivate(GObject.GPointer): ...

class Application(GObject.Object, ActionGroup, ActionMap):
    """
    :Constructors:

    ::

        Application(**properties)
        new(application_id:str=None, flags:Gio.ApplicationFlags) -> Gio.Application

    Object GApplication

    Signals from GApplication:
      startup ()
      shutdown ()
      activate ()
      open (gpointer, gint, gchararray)
      command-line (GApplicationCommandLine) -> gint
      handle-local-options (GVariantDict) -> gint
      name-lost () -> gboolean

    Properties from GApplication:
      application-id -> gchararray: application-id
      version -> gchararray: version
      flags -> GApplicationFlags: flags
      resource-base-path -> gchararray: resource-base-path
      is-registered -> gboolean: is-registered
      is-remote -> gboolean: is-remote
      inactivity-timeout -> guint: inactivity-timeout
      action-group -> GActionGroup: action-group
      is-busy -> gboolean: is-busy

    Signals from GActionGroup:
      action-added (gchararray)
      action-removed (gchararray)
      action-enabled-changed (gchararray, gboolean)
      action-state-changed (gchararray, GVariant)

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        application_id: typing.Optional[str]
        flags: ApplicationFlags
        inactivity_timeout: int
        is_busy: bool
        is_registered: bool
        is_remote: bool
        resource_base_path: typing.Optional[str]
        version: typing.Optional[str]
        action_group: typing.Optional[ActionGroup]

    props: Props = ...
    parent_instance: GObject.Object = ...
    priv: ApplicationPrivate = ...
    def __init__(
        self,
        *,
        action_group: typing.Optional[ActionGroup] = ...,
        application_id: typing.Optional[str] = ...,
        flags: ApplicationFlags = ...,
        inactivity_timeout: int = ...,
        resource_base_path: typing.Optional[str] = ...,
        version: str = ...,
    ) -> None: ...
    def activate(self) -> None: ...
    def add_main_option(
        self,
        long_name: str,
        short_name: int,
        flags: GLib.OptionFlags,
        arg: GLib.OptionArg,
        description: str,
        arg_description: typing.Optional[str] = None,
    ) -> None: ...
    def add_main_option_entries(
        self, entries: typing.Sequence[GLib.OptionEntry]
    ) -> None: ...
    def add_option_group(self, group: GLib.OptionGroup) -> None: ...
    def bind_busy_property(self, object: GObject.Object, property: str) -> None: ...
    def create_asyncio_task(self, coro):
        """
        Safely create an asyncio task. The application will not quit until the
        task completes. For potentially longer running tasks, you should add
        cancellation logic to abort a task when it is not needed anymore (e.g.
        cancelling it from the Gtk.Window.do_unmap event).

        Note that python will only log a raised exception if the Task is
        destroyed without the result having been collected. However, this does
        also not happen when the task is cancelled. As such, be careful to not
        cancel tasks that are already finished.

        You can deal with this by either only storing a weak reference to the
        Task, by explicitly collecting the result, or by only cancelling it if
        it is not done already.
        """  # FIXME: Override is missing typing annotation
    def do_activate(self) -> None: ...
    def do_add_platform_data(self, builder: GLib.VariantBuilder) -> None: ...
    def do_after_emit(self, platform_data: GLib.Variant) -> None: ...
    def do_before_emit(self, platform_data: GLib.Variant) -> None: ...
    def do_command_line(self, command_line: ApplicationCommandLine) -> int: ...
    def do_dbus_register(
        self, connection: DBusConnection, object_path: str
    ) -> bool: ...
    def do_dbus_unregister(
        self, connection: DBusConnection, object_path: str
    ) -> None: ...
    def do_handle_local_options(self, options: GLib.VariantDict) -> int: ...
    def do_local_command_line(self) -> typing.Tuple[bool, list[str], int]: ...
    def do_name_lost(self) -> bool: ...
    # override
    def do_open(
        self, files: typing.Sequence[File], n_files: int, hint: str
    ) -> None: ...
    def do_quit_mainloop(self) -> None: ...
    def do_run_mainloop(self) -> None: ...
    def do_shutdown(self) -> None: ...
    def do_startup(self) -> None: ...
    def get_application_id(self) -> typing.Optional[str]: ...
    def get_dbus_connection(self) -> typing.Optional[DBusConnection]: ...
    def get_dbus_object_path(self) -> typing.Optional[str]: ...
    @staticmethod
    def get_default() -> typing.Optional[Application]: ...
    def get_flags(self) -> ApplicationFlags: ...
    def get_inactivity_timeout(self) -> int: ...
    def get_is_busy(self) -> bool: ...
    def get_is_registered(self) -> bool: ...
    def get_is_remote(self) -> bool: ...
    def get_resource_base_path(self) -> typing.Optional[str]: ...
    def get_version(self) -> typing.Optional[str]: ...
    def hold(self) -> None: ...
    @staticmethod
    def id_is_valid(application_id: str) -> bool: ...
    def mark_busy(self) -> None: ...
    @classmethod
    def new(
        cls, application_id: typing.Optional[str], flags: ApplicationFlags
    ) -> Application: ...
    def open(self, files: typing.Sequence[File], hint: str) -> None: ...
    def quit(self) -> None: ...
    def register(self, cancellable: typing.Optional[Cancellable] = None) -> bool: ...
    def release(self) -> None: ...
    # override
    def run(self, argv: typing.Optional[list[str]]) -> int: ...
    def send_notification(
        self, id: typing.Optional[str], notification: Notification
    ) -> None: ...
    def set_action_group(
        self, action_group: typing.Optional[ActionGroup] = None
    ) -> None: ...
    def set_application_id(
        self, application_id: typing.Optional[str] = None
    ) -> None: ...
    def set_default(self) -> None: ...
    def set_flags(self, flags: ApplicationFlags) -> None: ...
    def set_inactivity_timeout(self, inactivity_timeout: int) -> None: ...
    def set_option_context_description(
        self, description: typing.Optional[str] = None
    ) -> None: ...
    def set_option_context_parameter_string(
        self, parameter_string: typing.Optional[str] = None
    ) -> None: ...
    def set_option_context_summary(
        self, summary: typing.Optional[str] = None
    ) -> None: ...
    def set_resource_base_path(
        self, resource_path: typing.Optional[str] = None
    ) -> None: ...
    def set_version(self, version: str) -> None: ...
    def unbind_busy_property(self, object: GObject.Object, property: str) -> None: ...
    def unmark_busy(self) -> None: ...
    def withdraw_notification(self, id: str) -> None: ...

class ApplicationClass(GObject.GPointer):
    """
    :Constructors:

    ::

        ApplicationClass()
    """

    parent_class: GObject.ObjectClass = ...
    startup: typing.Callable[[Application], None] = ...
    activate: typing.Callable[[Application], None] = ...
    open: typing.Callable[[Application, typing.Sequence[File], str], None] = ...
    command_line: typing.Callable[[Application, ApplicationCommandLine], int] = ...
    local_command_line: typing.Callable[
        [Application], typing.Tuple[bool, list[str], int]
    ] = ...
    before_emit: typing.Callable[[Application, GLib.Variant], None] = ...
    after_emit: typing.Callable[[Application, GLib.Variant], None] = ...
    add_platform_data: typing.Callable[[Application, GLib.VariantBuilder], None] = ...
    quit_mainloop: typing.Callable[[Application], None] = ...
    run_mainloop: typing.Callable[[Application], None] = ...
    shutdown: typing.Callable[[Application], None] = ...
    dbus_register: typing.Callable[[Application, DBusConnection, str], bool] = ...
    dbus_unregister: typing.Callable[[Application, DBusConnection, str], None] = ...
    handle_local_options: typing.Callable[[Application, GLib.VariantDict], int] = ...
    name_lost: typing.Callable[[Application], bool] = ...
    padding: list[None] = ...

class ApplicationCommandLine(GObject.Object):
    """
    :Constructors:

    ::

        ApplicationCommandLine(**properties)

    Object GApplicationCommandLine

    Properties from GApplicationCommandLine:
      arguments -> GVariant: arguments
      options -> GVariant: options
      platform-data -> GVariant: platform-data
      is-remote -> gboolean: is-remote

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        is_remote: bool
        arguments: GLib.Variant
        options: GLib.Variant
        platform_data: GLib.Variant

    props: Props = ...
    parent_instance: GObject.Object = ...
    priv: ApplicationCommandLinePrivate = ...
    def __init__(
        self,
        *,
        arguments: GLib.Variant = ...,
        options: GLib.Variant = ...,
        platform_data: GLib.Variant = ...,
    ) -> None: ...
    def create_file_for_arg(self, arg: str) -> File: ...
    def do_done(self) -> None: ...
    def do_get_stdin(self) -> typing.Optional[InputStream]: ...
    def do_print_literal(self, message: str) -> None: ...
    def do_printerr_literal(self, message: str) -> None: ...
    def done(self) -> None: ...
    def get_arguments(self) -> list[str]: ...
    def get_cwd(self) -> typing.Optional[str]: ...
    def get_environ(self) -> list[str]: ...
    def get_exit_status(self) -> int: ...
    def get_is_remote(self) -> bool: ...
    def get_options_dict(self) -> GLib.VariantDict: ...
    def get_platform_data(self) -> typing.Optional[GLib.Variant]: ...
    def get_stdin(self) -> typing.Optional[InputStream]: ...
    def getenv(self, name: str) -> typing.Optional[str]: ...
    def print_literal(self, message: str) -> None: ...
    def printerr_literal(self, message: str) -> None: ...
    def set_exit_status(self, exit_status: int) -> None: ...

class ApplicationCommandLineClass(GObject.GPointer):
    """
    :Constructors:

    ::

        ApplicationCommandLineClass()
    """

    parent_class: GObject.ObjectClass = ...
    print_literal: typing.Callable[[ApplicationCommandLine, str], None] = ...
    printerr_literal: typing.Callable[[ApplicationCommandLine, str], None] = ...
    get_stdin: typing.Callable[
        [ApplicationCommandLine], typing.Optional[InputStream]
    ] = ...
    done: typing.Callable[[ApplicationCommandLine], None] = ...
    padding: list[None] = ...

class ApplicationCommandLinePrivate(GObject.GPointer): ...
class ApplicationPrivate(GObject.GPointer): ...

class AsyncInitable(GObject.GInterface):
    """
    Interface GAsyncInitable

    Signals from GObject:
      notify (GParam)
    """
    def init_async(
        self,
        io_priority: int,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def init_finish(self, res: AsyncResult) -> bool: ...
    def new_finish(self, res: AsyncResult) -> GObject.Object: ...
    @staticmethod
    def newv_async(
        object_type: typing.Type[typing.Any],
        n_parameters: int,
        parameters: GObject.Parameter,
        io_priority: int,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...

class AsyncInitableIface(GObject.GPointer):
    """
    :Constructors:

    ::

        AsyncInitableIface()
    """

    g_iface: GObject.TypeInterface = ...
    init_async: typing.Callable[..., None] = ...
    init_finish: typing.Callable[[AsyncInitable, AsyncResult], bool] = ...

class AsyncResult(GObject.GInterface):
    """
    Interface GAsyncResult

    Signals from GObject:
      notify (GParam)
    """
    def get_source_object(self) -> typing.Optional[GObject.Object]: ...
    def get_user_data(self) -> None: ...
    def is_tagged(self, source_tag: None) -> bool: ...
    def legacy_propagate_error(self) -> bool: ...

class AsyncResultIface(GObject.GPointer):
    """
    :Constructors:

    ::

        AsyncResultIface()
    """

    g_iface: GObject.TypeInterface = ...
    get_user_data: typing.Callable[[AsyncResult], None] = ...
    get_source_object: typing.Callable[
        [AsyncResult], typing.Optional[GObject.Object]
    ] = ...
    is_tagged: typing.Callable[[AsyncResult, None], bool] = ...

class BufferedInputStream(FilterInputStream, Seekable):
    """
    :Constructors:

    ::

        BufferedInputStream(**properties)
        new(base_stream:Gio.InputStream) -> Gio.InputStream
        new_sized(base_stream:Gio.InputStream, size:int) -> Gio.InputStream

    Object GBufferedInputStream

    Properties from GBufferedInputStream:
      buffer-size -> guint: buffer-size

    Properties from GFilterInputStream:
      base-stream -> GInputStream: base-stream
      close-base-stream -> gboolean: close-base-stream

    Signals from GObject:
      notify (GParam)
    """
    class Props(FilterInputStream.Props):
        buffer_size: int
        base_stream: InputStream
        close_base_stream: bool

    props: Props = ...
    parent_instance: FilterInputStream = ...
    priv: BufferedInputStreamPrivate = ...
    def __init__(
        self,
        *,
        buffer_size: int = ...,
        base_stream: InputStream = ...,
        close_base_stream: bool = ...,
    ) -> None: ...
    def do_fill(
        self, count: int, cancellable: typing.Optional[Cancellable] = None
    ) -> int: ...
    def do_fill_async(
        self,
        count: int,
        io_priority: int,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def do_fill_finish(self, result: AsyncResult) -> int: ...
    def fill(
        self, count: int, cancellable: typing.Optional[Cancellable] = None
    ) -> int: ...
    def fill_async(
        self,
        count: int,
        io_priority: int,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def fill_finish(self, result: AsyncResult) -> int: ...
    def get_available(self) -> int: ...
    def get_buffer_size(self) -> int: ...
    @classmethod
    def new(cls, base_stream: InputStream) -> BufferedInputStream: ...
    @classmethod
    def new_sized(cls, base_stream: InputStream, size: int) -> BufferedInputStream: ...
    def peek(self, buffer: typing.Sequence[int], offset: int) -> int: ...
    def peek_buffer(self) -> bytes: ...
    def read_byte(self, cancellable: typing.Optional[Cancellable] = None) -> int: ...
    def set_buffer_size(self, size: int) -> None: ...

class BufferedInputStreamClass(GObject.GPointer):
    """
    :Constructors:

    ::

        BufferedInputStreamClass()
    """

    parent_class: FilterInputStreamClass = ...
    fill: typing.Callable[
        [BufferedInputStream, int, typing.Optional[Cancellable]], int
    ] = ...
    fill_async: typing.Callable[..., None] = ...
    fill_finish: typing.Callable[[BufferedInputStream, AsyncResult], int] = ...

class BufferedInputStreamPrivate(GObject.GPointer): ...

class BufferedOutputStream(FilterOutputStream, Seekable):
    """
    :Constructors:

    ::

        BufferedOutputStream(**properties)
        new(base_stream:Gio.OutputStream) -> Gio.OutputStream
        new_sized(base_stream:Gio.OutputStream, size:int) -> Gio.OutputStream

    Object GBufferedOutputStream

    Properties from GBufferedOutputStream:
      buffer-size -> guint: buffer-size
      auto-grow -> gboolean: auto-grow

    Properties from GFilterOutputStream:
      base-stream -> GOutputStream: base-stream
      close-base-stream -> gboolean: close-base-stream

    Signals from GObject:
      notify (GParam)
    """
    class Props(FilterOutputStream.Props):
        auto_grow: bool
        buffer_size: int
        base_stream: OutputStream
        close_base_stream: bool

    props: Props = ...
    parent_instance: FilterOutputStream = ...
    priv: BufferedOutputStreamPrivate = ...
    def __init__(
        self,
        *,
        auto_grow: bool = ...,
        buffer_size: int = ...,
        base_stream: OutputStream = ...,
        close_base_stream: bool = ...,
    ) -> None: ...
    def get_auto_grow(self) -> bool: ...
    def get_buffer_size(self) -> int: ...
    @classmethod
    def new(cls, base_stream: OutputStream) -> BufferedOutputStream: ...
    @classmethod
    def new_sized(
        cls, base_stream: OutputStream, size: int
    ) -> BufferedOutputStream: ...
    def set_auto_grow(self, auto_grow: bool) -> None: ...
    def set_buffer_size(self, size: int) -> None: ...

class BufferedOutputStreamClass(GObject.GPointer):
    """
    :Constructors:

    ::

        BufferedOutputStreamClass()
    """

    parent_class: FilterOutputStreamClass = ...

class BufferedOutputStreamPrivate(GObject.GPointer): ...

class BytesIcon(GObject.Object, Icon, LoadableIcon):
    """
    :Constructors:

    ::

        BytesIcon(**properties)
        new(bytes:GLib.Bytes) -> Gio.BytesIcon

    Object GBytesIcon

    Properties from GBytesIcon:
      bytes -> GBytes: bytes

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        bytes: GLib.Bytes

    props: Props = ...
    # override
    def __init__(self, *, bytes: GLib.Bytes = ...) -> None: ...
    def get_bytes(self) -> GLib.Bytes: ...
    @classmethod
    def new(cls, bytes: GLib.Bytes) -> BytesIcon: ...

class Cancellable(GObject.Object):
    """
    :Constructors:

    ::

        Cancellable(**properties)
        new() -> Gio.Cancellable

    Object GCancellable

    Signals from GCancellable:
      cancelled ()

    Signals from GObject:
      notify (GParam)
    """

    parent_instance: GObject.Object = ...
    priv: CancellablePrivate = ...
    def cancel(self) -> None: ...
    def connect(
        self, callback: typing.Callable[..., None], *data: typing.Any
    ) -> int: ...
    def disconnect(self, handler_id: int) -> None: ...
    def do_cancelled(self) -> None: ...
    @staticmethod
    def get_current() -> typing.Optional[Cancellable]: ...
    def get_fd(self) -> int: ...
    def is_cancelled(self) -> bool: ...
    def make_pollfd(self, pollfd: GLib.PollFD) -> bool: ...
    @classmethod
    def new(cls) -> Cancellable: ...
    def pop_current(self) -> None: ...
    def push_current(self) -> None: ...
    def release_fd(self) -> None: ...
    def reset(self) -> None: ...
    def set_error_if_cancelled(self) -> bool: ...
    def source_new(self) -> GLib.Source: ...

class CancellableClass(GObject.GPointer):
    """
    :Constructors:

    ::

        CancellableClass()
    """

    parent_class: GObject.ObjectClass = ...
    cancelled: typing.Callable[[typing.Optional[Cancellable]], None] = ...

class CancellablePrivate(GObject.GPointer): ...

class CharsetConverter(GObject.Object, Converter, Initable):
    """
    :Constructors:

    ::

        CharsetConverter(**properties)
        new(to_charset:str, from_charset:str) -> Gio.CharsetConverter

    Object GCharsetConverter

    Properties from GCharsetConverter:
      from-charset -> gchararray: from-charset
      to-charset -> gchararray: to-charset
      use-fallback -> gboolean: use-fallback

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        from_charset: str
        to_charset: str
        use_fallback: bool

    props: Props = ...
    def __init__(
        self,
        *,
        from_charset: str = ...,
        to_charset: str = ...,
        use_fallback: bool = ...,
    ) -> None: ...
    def get_num_fallbacks(self) -> int: ...
    def get_use_fallback(self) -> bool: ...
    @classmethod
    def new(cls, to_charset: str, from_charset: str) -> CharsetConverter: ...
    def set_use_fallback(self, use_fallback: bool) -> None: ...

class CharsetConverterClass(GObject.GPointer):
    """
    :Constructors:

    ::

        CharsetConverterClass()
    """

    parent_class: GObject.ObjectClass = ...

class Converter(GObject.GInterface):
    """
    Interface GConverter

    Signals from GObject:
      notify (GParam)
    """
    def convert(
        self,
        inbuf: typing.Sequence[int],
        outbuf: typing.Sequence[int],
        flags: ConverterFlags,
    ) -> typing.Tuple[ConverterResult, int, int]: ...
    def convert_bytes(self, bytes: GLib.Bytes) -> GLib.Bytes: ...
    def reset(self) -> None: ...

class ConverterIface(GObject.GPointer):
    """
    :Constructors:

    ::

        ConverterIface()
    """

    g_iface: GObject.TypeInterface = ...
    convert: typing.Callable[
        [
            Converter,
            typing.Optional[typing.Sequence[int]],
            typing.Sequence[int],
            ConverterFlags,
        ],
        typing.Tuple[ConverterResult, int, int],
    ] = ...
    reset: typing.Callable[[Converter], None] = ...

class ConverterInputStream(FilterInputStream, PollableInputStream):
    """
    :Constructors:

    ::

        ConverterInputStream(**properties)
        new(base_stream:Gio.InputStream, converter:Gio.Converter) -> Gio.InputStream

    Object GConverterInputStream

    Properties from GConverterInputStream:
      converter -> GConverter: converter

    Properties from GFilterInputStream:
      base-stream -> GInputStream: base-stream
      close-base-stream -> gboolean: close-base-stream

    Signals from GObject:
      notify (GParam)
    """
    class Props(FilterInputStream.Props):
        converter: Converter
        base_stream: InputStream
        close_base_stream: bool

    props: Props = ...
    parent_instance: FilterInputStream = ...
    priv: ConverterInputStreamPrivate = ...
    def __init__(
        self,
        *,
        converter: Converter = ...,
        base_stream: InputStream = ...,
        close_base_stream: bool = ...,
    ) -> None: ...
    def get_converter(self) -> Converter: ...
    @classmethod
    def new(
        cls, base_stream: InputStream, converter: Converter
    ) -> ConverterInputStream: ...

class ConverterInputStreamClass(GObject.GPointer):
    """
    :Constructors:

    ::

        ConverterInputStreamClass()
    """

    parent_class: FilterInputStreamClass = ...

class ConverterInputStreamPrivate(GObject.GPointer): ...

class ConverterOutputStream(FilterOutputStream, PollableOutputStream):
    """
    :Constructors:

    ::

        ConverterOutputStream(**properties)
        new(base_stream:Gio.OutputStream, converter:Gio.Converter) -> Gio.OutputStream

    Object GConverterOutputStream

    Properties from GConverterOutputStream:
      converter -> GConverter: converter

    Properties from GFilterOutputStream:
      base-stream -> GOutputStream: base-stream
      close-base-stream -> gboolean: close-base-stream

    Signals from GObject:
      notify (GParam)
    """
    class Props(FilterOutputStream.Props):
        converter: Converter
        base_stream: OutputStream
        close_base_stream: bool

    props: Props = ...
    parent_instance: FilterOutputStream = ...
    priv: ConverterOutputStreamPrivate = ...
    def __init__(
        self,
        *,
        converter: Converter = ...,
        base_stream: OutputStream = ...,
        close_base_stream: bool = ...,
    ) -> None: ...
    def get_converter(self) -> Converter: ...
    @classmethod
    def new(
        cls, base_stream: OutputStream, converter: Converter
    ) -> ConverterOutputStream: ...

class ConverterOutputStreamClass(GObject.GPointer):
    """
    :Constructors:

    ::

        ConverterOutputStreamClass()
    """

    parent_class: FilterOutputStreamClass = ...

class ConverterOutputStreamPrivate(GObject.GPointer): ...

class Credentials(GObject.Object):
    """
    :Constructors:

    ::

        Credentials(**properties)
        new() -> Gio.Credentials

    Object GCredentials

    Signals from GObject:
      notify (GParam)
    """
    def get_unix_pid(self) -> int: ...
    def get_unix_user(self) -> int: ...
    def is_same_user(self, other_credentials: Credentials) -> bool: ...
    @classmethod
    def new(cls) -> Credentials: ...
    def set_native(self, native_type: CredentialsType, native: None) -> None: ...
    def set_unix_user(self, uid: int) -> bool: ...
    def to_string(self) -> str: ...

class CredentialsClass(GObject.GPointer): ...

class DBusActionGroup(GObject.Object, ActionGroup, RemoteActionGroup):
    """
    :Constructors:

    ::

        DBusActionGroup(**properties)

    Object GDBusActionGroup

    Signals from GActionGroup:
      action-added (gchararray)
      action-removed (gchararray)
      action-enabled-changed (gchararray, gboolean)
      action-state-changed (gchararray, GVariant)

    Signals from GObject:
      notify (GParam)
    """
    @staticmethod
    def get(
        connection: DBusConnection, bus_name: typing.Optional[str], object_path: str
    ) -> DBusActionGroup: ...

class DBusAnnotationInfo(GObject.GBoxed):
    """
    :Constructors:

    ::

        DBusAnnotationInfo()
    """

    ref_count: int = ...
    key: str = ...
    value: str = ...
    annotations: list[DBusAnnotationInfo] = ...
    def __init__(
        self, *args, **kwargs
    ): ...  # FIXME: Override is missing typing annotation
    @staticmethod
    def lookup(
        annotations: typing.Optional[typing.Sequence[DBusAnnotationInfo]], name: str
    ) -> typing.Optional[str]: ...
    def ref(self) -> DBusAnnotationInfo: ...
    def unref(self) -> None: ...

class DBusArgInfo(GObject.GBoxed):
    """
    :Constructors:

    ::

        DBusArgInfo()
    """

    ref_count: int = ...
    name: str = ...
    signature: str = ...
    annotations: list[DBusAnnotationInfo] = ...
    def __init__(
        self, *args, **kwargs
    ): ...  # FIXME: Override is missing typing annotation
    def ref(self) -> DBusArgInfo: ...
    def unref(self) -> None: ...

class DBusAuthObserver(GObject.Object):
    """
    :Constructors:

    ::

        DBusAuthObserver(**properties)
        new() -> Gio.DBusAuthObserver

    Object GDBusAuthObserver

    Signals from GDBusAuthObserver:
      authorize-authenticated-peer (GIOStream, GCredentials) -> gboolean
      allow-mechanism (gchararray) -> gboolean

    Signals from GObject:
      notify (GParam)
    """
    def allow_mechanism(self, mechanism: str) -> bool: ...
    def authorize_authenticated_peer(
        self, stream: IOStream, credentials: typing.Optional[Credentials] = None
    ) -> bool: ...
    @classmethod
    def new(cls) -> DBusAuthObserver: ...

class DBusConnection(GObject.Object, AsyncInitable, Initable):
    """
    :Constructors:

    ::

        DBusConnection(**properties)
        new_finish(res:Gio.AsyncResult) -> Gio.DBusConnection
        new_for_address_finish(res:Gio.AsyncResult) -> Gio.DBusConnection
        new_for_address_sync(address:str, flags:Gio.DBusConnectionFlags, observer:Gio.DBusAuthObserver=None, cancellable:Gio.Cancellable=None) -> Gio.DBusConnection
        new_sync(stream:Gio.IOStream, guid:str=None, flags:Gio.DBusConnectionFlags, observer:Gio.DBusAuthObserver=None, cancellable:Gio.Cancellable=None) -> Gio.DBusConnection

    Object GDBusConnection

    Signals from GDBusConnection:
      closed (gboolean, GError)

    Properties from GDBusConnection:
      stream -> GIOStream: stream
      address -> gchararray: address
      flags -> GDBusConnectionFlags: flags
      guid -> gchararray: guid
      unique-name -> gchararray: unique-name
      closed -> gboolean: closed
      exit-on-close -> gboolean: exit-on-close
      capabilities -> GDBusCapabilityFlags: capabilities
      authentication-observer -> GDBusAuthObserver: authentication-observer

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        capabilities: DBusCapabilityFlags
        closed: bool
        exit_on_close: bool
        flags: DBusConnectionFlags
        guid: str
        stream: IOStream
        unique_name: typing.Optional[str]
        address: str
        authentication_observer: DBusAuthObserver

    props: Props = ...
    def __init__(
        self,
        *,
        address: str = ...,
        authentication_observer: DBusAuthObserver = ...,
        exit_on_close: bool = ...,
        flags: DBusConnectionFlags = ...,
        guid: str = ...,
        stream: IOStream = ...,
    ) -> None: ...
    def add_filter(
        self,
        filter_function: typing.Callable[..., typing.Optional[DBusMessage]],
        *user_data: typing.Any,
    ) -> int: ...
    def call(
        self,
        bus_name: typing.Optional[str],
        object_path: str,
        interface_name: str,
        method_name: str,
        parameters: typing.Optional[GLib.Variant],
        reply_type: typing.Optional[GLib.VariantType],
        flags: DBusCallFlags,
        timeout_msec: int,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def call_finish(self, res: AsyncResult) -> GLib.Variant: ...
    def call_sync(
        self,
        bus_name: typing.Optional[str],
        object_path: str,
        interface_name: str,
        method_name: str,
        parameters: typing.Optional[GLib.Variant],
        reply_type: typing.Optional[GLib.VariantType],
        flags: DBusCallFlags,
        timeout_msec: int,
        cancellable: typing.Optional[Cancellable] = None,
    ) -> GLib.Variant: ...
    def call_with_unix_fd_list(
        self,
        bus_name: typing.Optional[str],
        object_path: str,
        interface_name: str,
        method_name: str,
        parameters: typing.Optional[GLib.Variant],
        reply_type: typing.Optional[GLib.VariantType],
        flags: DBusCallFlags,
        timeout_msec: int,
        fd_list: typing.Optional[UnixFDList] = None,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def call_with_unix_fd_list_finish(
        self, res: AsyncResult
    ) -> typing.Tuple[GLib.Variant, UnixFDList]: ...
    def call_with_unix_fd_list_sync(
        self,
        bus_name: typing.Optional[str],
        object_path: str,
        interface_name: str,
        method_name: str,
        parameters: typing.Optional[GLib.Variant],
        reply_type: typing.Optional[GLib.VariantType],
        flags: DBusCallFlags,
        timeout_msec: int,
        fd_list: typing.Optional[UnixFDList] = None,
        cancellable: typing.Optional[Cancellable] = None,
    ) -> typing.Tuple[GLib.Variant, UnixFDList]: ...
    def close(
        self,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def close_finish(self, res: AsyncResult) -> bool: ...
    def close_sync(self, cancellable: typing.Optional[Cancellable] = None) -> bool: ...
    def emit_signal(
        self,
        destination_bus_name: typing.Optional[str],
        object_path: str,
        interface_name: str,
        signal_name: str,
        parameters: typing.Optional[GLib.Variant] = None,
    ) -> bool: ...
    def export_action_group(
        self, object_path: str, action_group: ActionGroup
    ) -> int: ...
    def export_menu_model(self, object_path: str, menu: MenuModel) -> int: ...
    def flush(
        self,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def flush_finish(self, res: AsyncResult) -> bool: ...
    def flush_sync(self, cancellable: typing.Optional[Cancellable] = None) -> bool: ...
    def get_capabilities(self) -> DBusCapabilityFlags: ...
    def get_exit_on_close(self) -> bool: ...
    def get_flags(self) -> DBusConnectionFlags: ...
    def get_guid(self) -> str: ...
    def get_last_serial(self) -> int: ...
    def get_peer_credentials(self) -> typing.Optional[Credentials]: ...
    def get_stream(self) -> IOStream: ...
    def get_unique_name(self) -> typing.Optional[str]: ...
    def is_closed(self) -> bool: ...
    @staticmethod
    def new(
        stream: IOStream,
        guid: typing.Optional[str],
        flags: DBusConnectionFlags,
        observer: typing.Optional[DBusAuthObserver] = None,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    @classmethod
    def new_finish(cls, res: AsyncResult) -> DBusConnection: ...
    @staticmethod
    def new_for_address(
        address: str,
        flags: DBusConnectionFlags,
        observer: typing.Optional[DBusAuthObserver] = None,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    @classmethod
    def new_for_address_finish(cls, res: AsyncResult) -> DBusConnection: ...
    @classmethod
    def new_for_address_sync(
        cls,
        address: str,
        flags: DBusConnectionFlags,
        observer: typing.Optional[DBusAuthObserver] = None,
        cancellable: typing.Optional[Cancellable] = None,
    ) -> DBusConnection: ...
    @classmethod
    def new_sync(
        cls,
        stream: IOStream,
        guid: typing.Optional[str],
        flags: DBusConnectionFlags,
        observer: typing.Optional[DBusAuthObserver] = None,
        cancellable: typing.Optional[Cancellable] = None,
    ) -> DBusConnection: ...
    # override
    def register_object(
        self,
        object_path: str,
        interface_info: DBusInterfaceInfo,
        method_call_closure: typing.Callable[
            [DBusConnection, str, str, str, str, GLib.Variant, DBusMethodInvocation],
            typing.Any,
        ]
        | None = None,
        get_property_closure: typing.Callable[
            [DBusConnection, str, str, str, str], typing.Any
        ]
        | None = None,
        set_property_closure: typing.Callable[..., typing.Any] | None = None,
    ) -> int: ...
    def register_object_with_closures2(
        self,
        object_path: str,
        interface_info: DBusInterfaceInfo,
        method_call_closure: typing.Optional[typing.Callable[..., typing.Any]] = None,
        get_property_closure: typing.Optional[typing.Callable[..., typing.Any]] = None,
        set_property_closure: typing.Optional[typing.Callable[..., typing.Any]] = None,
    ) -> int: ...
    def register_subtree(
        self,
        object_path: str,
        vtable: DBusSubtreeVTable,
        flags: DBusSubtreeFlags,
        user_data: None,
        user_data_free_func: typing.Callable[[None], None],
    ) -> int: ...
    def remove_filter(self, filter_id: int) -> None: ...
    def send_message(
        self, message: DBusMessage, flags: DBusSendMessageFlags
    ) -> typing.Tuple[bool, int]: ...
    def send_message_with_reply(
        self,
        message: DBusMessage,
        flags: DBusSendMessageFlags,
        timeout_msec: int,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> int: ...
    def send_message_with_reply_finish(self, res: AsyncResult) -> DBusMessage: ...
    def send_message_with_reply_sync(
        self,
        message: DBusMessage,
        flags: DBusSendMessageFlags,
        timeout_msec: int,
        cancellable: typing.Optional[Cancellable] = None,
    ) -> typing.Tuple[DBusMessage, int]: ...
    def set_exit_on_close(self, exit_on_close: bool) -> None: ...
    def signal_subscribe(
        self,
        sender: typing.Optional[str],
        interface_name: typing.Optional[str],
        member: typing.Optional[str],
        object_path: typing.Optional[str],
        arg0: typing.Optional[str],
        flags: DBusSignalFlags,
        callback: typing.Callable[..., None],
        *user_data: typing.Any,
    ) -> int: ...
    def signal_unsubscribe(self, subscription_id: int) -> None: ...
    def start_message_processing(self) -> None: ...
    def unexport_action_group(self, export_id: int) -> None: ...
    def unexport_menu_model(self, export_id: int) -> None: ...
    def unregister_object(self, registration_id: int) -> bool: ...
    def unregister_subtree(self, registration_id: int) -> bool: ...

class DBusErrorEntry(GObject.GPointer):
    """
    :Constructors:

    ::

        DBusErrorEntry()
    """

    error_code: int = ...
    dbus_error_name: str = ...

class DBusInterface(GObject.GInterface):
    """
    Interface GDBusInterface

    Signals from GObject:
      notify (GParam)
    """
    def get_info(self) -> DBusInterfaceInfo: ...
    def get_object(self) -> typing.Optional[DBusObject]: ...
    def set_object(self, object: typing.Optional[DBusObject] = None) -> None: ...

class DBusInterfaceIface(GObject.GPointer):
    """
    :Constructors:

    ::

        DBusInterfaceIface()
    """

    parent_iface: GObject.TypeInterface = ...
    get_info: typing.Callable[[DBusInterface], DBusInterfaceInfo] = ...
    get_object: typing.Callable[[DBusInterface], typing.Optional[DBusObject]] = ...
    set_object: typing.Callable[
        [DBusInterface, typing.Optional[DBusObject]], None
    ] = ...
    dup_object: typing.Callable[[DBusInterface], typing.Optional[DBusObject]] = ...

class DBusInterfaceInfo(GObject.GBoxed):
    """
    :Constructors:

    ::

        DBusInterfaceInfo()
    """

    ref_count: int = ...
    name: str = ...
    methods: list[DBusMethodInfo] = ...
    signals: list[DBusSignalInfo] = ...
    properties: list[DBusPropertyInfo] = ...
    annotations: list[DBusAnnotationInfo] = ...
    def __init__(
        self, *args, **kwargs
    ): ...  # FIXME: Override is missing typing annotation
    def cache_build(self) -> None: ...
    def cache_release(self) -> None: ...
    def generate_xml(self, indent: int, string_builder: GLib.String) -> None: ...
    def lookup_method(self, name: str) -> typing.Optional[DBusMethodInfo]: ...
    def lookup_property(self, name: str) -> typing.Optional[DBusPropertyInfo]: ...
    def lookup_signal(self, name: str) -> typing.Optional[DBusSignalInfo]: ...
    def ref(self) -> DBusInterfaceInfo: ...
    def unref(self) -> None: ...

class DBusInterfaceSkeleton(GObject.Object, DBusInterface):
    """
    :Constructors:

    ::

        DBusInterfaceSkeleton(**properties)

    Object GDBusInterfaceSkeleton

    Signals from GDBusInterfaceSkeleton:
      g-authorize-method (GDBusMethodInvocation) -> gboolean

    Properties from GDBusInterfaceSkeleton:
      g-flags -> GDBusInterfaceSkeletonFlags: g-flags

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        g_flags: DBusInterfaceSkeletonFlags

    props: Props = ...
    parent_instance: GObject.Object = ...
    priv: DBusInterfaceSkeletonPrivate = ...
    def __init__(self, *, g_flags: DBusInterfaceSkeletonFlags = ...) -> None: ...
    def do_flush(self) -> None: ...
    def do_g_authorize_method(self, invocation: DBusMethodInvocation) -> bool: ...
    def do_get_info(self) -> DBusInterfaceInfo: ...
    def do_get_properties(self) -> GLib.Variant: ...
    def do_get_vtable(self) -> DBusInterfaceVTable: ...
    def export(self, connection: DBusConnection, object_path: str) -> bool: ...
    def flush(self) -> None: ...
    def get_connection(self) -> typing.Optional[DBusConnection]: ...
    def get_connections(self) -> list[DBusConnection]: ...
    def get_flags(self) -> DBusInterfaceSkeletonFlags: ...
    def get_info(self) -> DBusInterfaceInfo: ...
    def get_object_path(self) -> typing.Optional[str]: ...
    def get_properties(self) -> GLib.Variant: ...
    def get_vtable(self) -> DBusInterfaceVTable: ...
    def has_connection(self, connection: DBusConnection) -> bool: ...
    def set_flags(self, flags: DBusInterfaceSkeletonFlags) -> None: ...
    def unexport(self) -> None: ...
    def unexport_from_connection(self, connection: DBusConnection) -> None: ...

class DBusInterfaceSkeletonClass(GObject.GPointer):
    """
    :Constructors:

    ::

        DBusInterfaceSkeletonClass()
    """

    parent_class: GObject.ObjectClass = ...
    get_info: typing.Callable[[DBusInterfaceSkeleton], DBusInterfaceInfo] = ...
    get_vtable: typing.Callable[[DBusInterfaceSkeleton], DBusInterfaceVTable] = ...
    get_properties: typing.Callable[[DBusInterfaceSkeleton], GLib.Variant] = ...
    flush: typing.Callable[[DBusInterfaceSkeleton], None] = ...
    vfunc_padding: list[None] = ...
    g_authorize_method: typing.Callable[
        [DBusInterfaceSkeleton, DBusMethodInvocation], bool
    ] = ...
    signal_padding: list[None] = ...

class DBusInterfaceSkeletonPrivate(GObject.GPointer): ...

class DBusInterfaceVTable(GObject.GPointer):
    """
    :Constructors:

    ::

        DBusInterfaceVTable()
    """

    method_call: typing.Callable[..., None] = ...
    get_property: typing.Callable[..., GLib.Variant] = ...
    set_property: typing.Callable[..., bool] = ...
    padding: list[None] = ...

class DBusMenuModel(MenuModel):
    """
    :Constructors:

    ::

        DBusMenuModel(**properties)

    Object GDBusMenuModel

    Signals from GMenuModel:
      items-changed (gint, gint, gint)

    Signals from GObject:
      notify (GParam)
    """
    @staticmethod
    def get(
        connection: DBusConnection, bus_name: typing.Optional[str], object_path: str
    ) -> DBusMenuModel: ...

class DBusMessage(GObject.Object):
    """
    :Constructors:

    ::

        DBusMessage(**properties)
        new() -> Gio.DBusMessage
        new_from_blob(blob:list, capabilities:Gio.DBusCapabilityFlags) -> Gio.DBusMessage
        new_method_call(name:str=None, path:str, interface_:str=None, method:str) -> Gio.DBusMessage
        new_signal(path:str, interface_:str, signal:str) -> Gio.DBusMessage

    Object GDBusMessage

    Properties from GDBusMessage:
      locked -> gboolean: locked

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        locked: bool

    props: Props = ...
    @staticmethod
    def bytes_needed(blob: typing.Sequence[int]) -> int: ...
    def copy(self) -> DBusMessage: ...
    def get_arg0(self) -> typing.Optional[str]: ...
    def get_arg0_path(self) -> typing.Optional[str]: ...
    def get_body(self) -> typing.Optional[GLib.Variant]: ...
    def get_byte_order(self) -> DBusMessageByteOrder: ...
    def get_destination(self) -> typing.Optional[str]: ...
    def get_error_name(self) -> typing.Optional[str]: ...
    def get_flags(self) -> DBusMessageFlags: ...
    def get_header(
        self, header_field: DBusMessageHeaderField
    ) -> typing.Optional[GLib.Variant]: ...
    def get_header_fields(self) -> bytes: ...
    def get_interface(self) -> typing.Optional[str]: ...
    def get_locked(self) -> bool: ...
    def get_member(self) -> typing.Optional[str]: ...
    def get_message_type(self) -> DBusMessageType: ...
    def get_num_unix_fds(self) -> int: ...
    def get_path(self) -> typing.Optional[str]: ...
    def get_reply_serial(self) -> int: ...
    def get_sender(self) -> typing.Optional[str]: ...
    def get_serial(self) -> int: ...
    def get_signature(self) -> str: ...
    def get_unix_fd_list(self) -> typing.Optional[UnixFDList]: ...
    def lock(self) -> None: ...
    @classmethod
    def new(cls) -> DBusMessage: ...
    @classmethod
    def new_from_blob(
        cls, blob: typing.Sequence[int], capabilities: DBusCapabilityFlags
    ) -> DBusMessage: ...
    @classmethod
    def new_method_call(
        cls,
        name: typing.Optional[str],
        path: str,
        interface_: typing.Optional[str],
        method: str,
    ) -> DBusMessage: ...
    def new_method_error_literal(
        self, error_name: str, error_message: str
    ) -> DBusMessage: ...
    def new_method_reply(self) -> DBusMessage: ...
    @classmethod
    def new_signal(cls, path: str, interface_: str, signal: str) -> DBusMessage: ...
    def print_(self, indent: int) -> str: ...
    def set_body(self, body: GLib.Variant) -> None: ...
    def set_byte_order(self, byte_order: DBusMessageByteOrder) -> None: ...
    def set_destination(self, value: typing.Optional[str] = None) -> None: ...
    def set_error_name(self, value: str) -> None: ...
    def set_flags(self, flags: DBusMessageFlags) -> None: ...
    def set_header(
        self,
        header_field: DBusMessageHeaderField,
        value: typing.Optional[GLib.Variant] = None,
    ) -> None: ...
    def set_interface(self, value: typing.Optional[str] = None) -> None: ...
    def set_member(self, value: typing.Optional[str] = None) -> None: ...
    def set_message_type(self, type: DBusMessageType) -> None: ...
    def set_num_unix_fds(self, value: int) -> None: ...
    def set_path(self, value: typing.Optional[str] = None) -> None: ...
    def set_reply_serial(self, value: int) -> None: ...
    def set_sender(self, value: typing.Optional[str] = None) -> None: ...
    def set_serial(self, serial: int) -> None: ...
    def set_signature(self, value: typing.Optional[str] = None) -> None: ...
    def set_unix_fd_list(self, fd_list: typing.Optional[UnixFDList] = None) -> None: ...
    def to_blob(self, capabilities: DBusCapabilityFlags) -> bytes: ...
    def to_gerror(self) -> bool: ...

class DBusMethodInfo(GObject.GBoxed):
    """
    :Constructors:

    ::

        DBusMethodInfo()
    """

    ref_count: int = ...
    name: str = ...
    in_args: list[DBusArgInfo] = ...
    out_args: list[DBusArgInfo] = ...
    annotations: list[DBusAnnotationInfo] = ...
    def __init__(
        self, *args, **kwargs
    ): ...  # FIXME: Override is missing typing annotation
    def ref(self) -> DBusMethodInfo: ...
    def unref(self) -> None: ...

class DBusMethodInvocation(GObject.Object):
    """
    :Constructors:

    ::

        DBusMethodInvocation(**properties)

    Object GDBusMethodInvocation

    Signals from GObject:
      notify (GParam)
    """
    def get_connection(self) -> DBusConnection: ...
    def get_interface_name(self) -> typing.Optional[str]: ...
    def get_message(self) -> DBusMessage: ...
    def get_method_info(self) -> typing.Optional[DBusMethodInfo]: ...
    def get_method_name(self) -> str: ...
    def get_object_path(self) -> str: ...
    def get_parameters(self) -> GLib.Variant: ...
    def get_property_info(self) -> typing.Optional[DBusPropertyInfo]: ...
    def get_sender(self) -> typing.Optional[str]: ...
    def return_dbus_error(self, error_name: str, error_message: str) -> None: ...
    def return_error_literal(self, domain: int, code: int, message: str) -> None: ...
    def return_gerror(self, error: GLib.Error) -> None: ...
    def return_value(
        self, parameters: typing.Optional[GLib.Variant] = None
    ) -> None: ...
    def return_value_with_unix_fd_list(
        self,
        parameters: typing.Optional[GLib.Variant] = None,
        fd_list: typing.Optional[UnixFDList] = None,
    ) -> None: ...

class DBusNodeInfo(GObject.GBoxed):
    """
    :Constructors:

    ::

        DBusNodeInfo()
        new_for_xml(xml_data:str) -> Gio.DBusNodeInfo
    """

    ref_count: int = ...
    path: str = ...
    interfaces: list[DBusInterfaceInfo] = ...
    nodes: list[DBusNodeInfo] = ...
    annotations: list[DBusAnnotationInfo] = ...
    def __init__(
        self, *args, **kwargs
    ): ...  # FIXME: Override is missing typing annotation
    def generate_xml(self, indent: int, string_builder: GLib.String) -> None: ...
    def lookup_interface(self, name: str) -> typing.Optional[DBusInterfaceInfo]: ...
    @classmethod
    def new_for_xml(cls, xml_data: str) -> DBusNodeInfo: ...
    def ref(self) -> DBusNodeInfo: ...
    def unref(self) -> None: ...

class DBusObject(GObject.GInterface):
    """
    Interface GDBusObject

    Signals from GObject:
      notify (GParam)
    """
    def get_interface(self, interface_name: str) -> typing.Optional[DBusInterface]: ...
    def get_interfaces(self) -> list[DBusInterface]: ...
    def get_object_path(self) -> str: ...

class DBusObjectIface(GObject.GPointer):
    """
    :Constructors:

    ::

        DBusObjectIface()
    """

    parent_iface: GObject.TypeInterface = ...
    get_object_path: typing.Callable[[DBusObject], str] = ...
    get_interfaces: typing.Callable[[DBusObject], list[DBusInterface]] = ...
    get_interface: typing.Callable[
        [DBusObject, str], typing.Optional[DBusInterface]
    ] = ...
    interface_added: typing.Callable[[DBusObject, DBusInterface], None] = ...
    interface_removed: typing.Callable[[DBusObject, DBusInterface], None] = ...

class DBusObjectManager(GObject.GInterface):
    """
    Interface GDBusObjectManager

    Signals from GObject:
      notify (GParam)
    """
    def get_interface(
        self, object_path: str, interface_name: str
    ) -> typing.Optional[DBusInterface]: ...
    def get_object(self, object_path: str) -> typing.Optional[DBusObject]: ...
    def get_object_path(self) -> str: ...
    def get_objects(self) -> list[DBusObject]: ...

class DBusObjectManagerClient(
    GObject.Object, AsyncInitable, DBusObjectManager, Initable
):
    """
    :Constructors:

    ::

        DBusObjectManagerClient(**properties)
        new_finish(res:Gio.AsyncResult) -> Gio.DBusObjectManagerClient
        new_for_bus_finish(res:Gio.AsyncResult) -> Gio.DBusObjectManagerClient
        new_for_bus_sync(bus_type:Gio.BusType, flags:Gio.DBusObjectManagerClientFlags, name:str, object_path:str, get_proxy_type_func:Gio.DBusProxyTypeFunc=None, get_proxy_type_user_data=None, cancellable:Gio.Cancellable=None) -> Gio.DBusObjectManagerClient
        new_sync(connection:Gio.DBusConnection, flags:Gio.DBusObjectManagerClientFlags, name:str=None, object_path:str, get_proxy_type_func:Gio.DBusProxyTypeFunc=None, get_proxy_type_user_data=None, cancellable:Gio.Cancellable=None) -> Gio.DBusObjectManagerClient

    Object GDBusObjectManagerClient

    Signals from GDBusObjectManagerClient:
      interface-proxy-signal (GDBusObjectProxy, GDBusProxy, gchararray, gchararray, GVariant)
      interface-proxy-properties-changed (GDBusObjectProxy, GDBusProxy, GVariant, GStrv)

    Properties from GDBusObjectManagerClient:
      bus-type -> GBusType: bus-type
      connection -> GDBusConnection: connection
      flags -> GDBusObjectManagerClientFlags: flags
      object-path -> gchararray: object-path
      name -> gchararray: name
      name-owner -> gchararray: name-owner
      get-proxy-type-func -> gpointer: get-proxy-type-func
      get-proxy-type-user-data -> gpointer: get-proxy-type-user-data
      get-proxy-type-destroy-notify -> gpointer: get-proxy-type-destroy-notify

    Signals from GDBusObjectManager:
      object-added (GDBusObject)
      object-removed (GDBusObject)
      interface-added (GDBusObject, GDBusInterface)
      interface-removed (GDBusObject, GDBusInterface)

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        connection: DBusConnection
        flags: DBusObjectManagerClientFlags
        get_proxy_type_destroy_notify: None
        get_proxy_type_func: None
        get_proxy_type_user_data: None
        name: str
        name_owner: typing.Optional[str]
        object_path: str
        bus_type: BusType

    props: Props = ...
    parent_instance: GObject.Object = ...
    priv: DBusObjectManagerClientPrivate = ...
    def __init__(
        self,
        *,
        bus_type: BusType = ...,
        connection: DBusConnection = ...,
        flags: DBusObjectManagerClientFlags = ...,
        get_proxy_type_destroy_notify: None = ...,
        get_proxy_type_func: None = ...,
        get_proxy_type_user_data: None = ...,
        name: str = ...,
        object_path: str = ...,
    ) -> None: ...
    def do_interface_proxy_properties_changed(
        self,
        object_proxy: DBusObjectProxy,
        interface_proxy: DBusProxy,
        changed_properties: GLib.Variant,
        invalidated_properties: str,
    ) -> None: ...
    def do_interface_proxy_signal(
        self,
        object_proxy: DBusObjectProxy,
        interface_proxy: DBusProxy,
        sender_name: str,
        signal_name: str,
        parameters: GLib.Variant,
    ) -> None: ...
    def get_connection(self) -> DBusConnection: ...
    def get_flags(self) -> DBusObjectManagerClientFlags: ...
    def get_name(self) -> str: ...
    def get_name_owner(self) -> typing.Optional[str]: ...
    @staticmethod
    def new(
        connection: DBusConnection,
        flags: DBusObjectManagerClientFlags,
        name: str,
        object_path: str,
        get_proxy_type_func: typing.Optional[
            typing.Callable[..., typing.Type[typing.Any]]
        ] = None,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    @classmethod
    def new_finish(cls, res: AsyncResult) -> DBusObjectManagerClient: ...
    @staticmethod
    def new_for_bus(
        bus_type: BusType,
        flags: DBusObjectManagerClientFlags,
        name: str,
        object_path: str,
        get_proxy_type_func: typing.Optional[
            typing.Callable[..., typing.Type[typing.Any]]
        ] = None,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    @classmethod
    def new_for_bus_finish(cls, res: AsyncResult) -> DBusObjectManagerClient: ...
    @classmethod
    def new_for_bus_sync(
        cls,
        bus_type: BusType,
        flags: DBusObjectManagerClientFlags,
        name: str,
        object_path: str,
        get_proxy_type_func: typing.Optional[
            typing.Callable[..., typing.Type[typing.Any]]
        ] = None,
        cancellable: typing.Optional[Cancellable] = None,
        *get_proxy_type_user_data: typing.Any,
    ) -> DBusObjectManagerClient: ...
    @classmethod
    def new_sync(
        cls,
        connection: DBusConnection,
        flags: DBusObjectManagerClientFlags,
        name: typing.Optional[str],
        object_path: str,
        get_proxy_type_func: typing.Optional[
            typing.Callable[..., typing.Type[typing.Any]]
        ] = None,
        cancellable: typing.Optional[Cancellable] = None,
        *get_proxy_type_user_data: typing.Any,
    ) -> DBusObjectManagerClient: ...

class DBusObjectManagerClientClass(GObject.GPointer):
    """
    :Constructors:

    ::

        DBusObjectManagerClientClass()
    """

    parent_class: GObject.ObjectClass = ...
    interface_proxy_signal: typing.Callable[
        [DBusObjectManagerClient, DBusObjectProxy, DBusProxy, str, str, GLib.Variant],
        None,
    ] = ...
    interface_proxy_properties_changed: typing.Callable[
        [DBusObjectManagerClient, DBusObjectProxy, DBusProxy, GLib.Variant, str], None
    ] = ...
    padding: list[None] = ...

class DBusObjectManagerClientPrivate(GObject.GPointer): ...

class DBusObjectManagerIface(GObject.GPointer):
    """
    :Constructors:

    ::

        DBusObjectManagerIface()
    """

    parent_iface: GObject.TypeInterface = ...
    get_object_path: typing.Callable[[DBusObjectManager], str] = ...
    get_objects: typing.Callable[[DBusObjectManager], list[DBusObject]] = ...
    get_object: typing.Callable[
        [DBusObjectManager, str], typing.Optional[DBusObject]
    ] = ...
    get_interface: typing.Callable[
        [DBusObjectManager, str, str], typing.Optional[DBusInterface]
    ] = ...
    object_added: typing.Callable[[DBusObjectManager, DBusObject], None] = ...
    object_removed: typing.Callable[[DBusObjectManager, DBusObject], None] = ...
    interface_added: typing.Callable[
        [DBusObjectManager, DBusObject, DBusInterface], None
    ] = ...
    interface_removed: typing.Callable[
        [DBusObjectManager, DBusObject, DBusInterface], None
    ] = ...

class DBusObjectManagerServer(GObject.Object, DBusObjectManager):
    """
    :Constructors:

    ::

        DBusObjectManagerServer(**properties)
        new(object_path:str) -> Gio.DBusObjectManagerServer

    Object GDBusObjectManagerServer

    Properties from GDBusObjectManagerServer:
      connection -> GDBusConnection: connection
      object-path -> gchararray: object-path

    Signals from GDBusObjectManager:
      object-added (GDBusObject)
      object-removed (GDBusObject)
      interface-added (GDBusObject, GDBusInterface)
      interface-removed (GDBusObject, GDBusInterface)

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        connection: typing.Optional[DBusConnection]
        object_path: str

    props: Props = ...
    parent_instance: GObject.Object = ...
    priv: DBusObjectManagerServerPrivate = ...
    def __init__(
        self,
        *,
        connection: typing.Optional[DBusConnection] = ...,
        object_path: str = ...,
    ) -> None: ...
    def export(self, object: DBusObjectSkeleton) -> None: ...
    def export_uniquely(self, object: DBusObjectSkeleton) -> None: ...
    def get_connection(self) -> typing.Optional[DBusConnection]: ...
    def is_exported(self, object: DBusObjectSkeleton) -> bool: ...
    @classmethod
    def new(cls, object_path: str) -> DBusObjectManagerServer: ...
    def set_connection(
        self, connection: typing.Optional[DBusConnection] = None
    ) -> None: ...
    def unexport(self, object_path: str) -> bool: ...

class DBusObjectManagerServerClass(GObject.GPointer):
    """
    :Constructors:

    ::

        DBusObjectManagerServerClass()
    """

    parent_class: GObject.ObjectClass = ...
    padding: list[None] = ...

class DBusObjectManagerServerPrivate(GObject.GPointer): ...

class DBusObjectProxy(GObject.Object, DBusObject):
    """
    :Constructors:

    ::

        DBusObjectProxy(**properties)
        new(connection:Gio.DBusConnection, object_path:str) -> Gio.DBusObjectProxy

    Object GDBusObjectProxy

    Properties from GDBusObjectProxy:
      g-object-path -> gchararray: g-object-path
      g-connection -> GDBusConnection: g-connection

    Signals from GDBusObject:
      interface-added (GDBusInterface)
      interface-removed (GDBusInterface)

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        g_connection: DBusConnection
        g_object_path: str

    props: Props = ...
    parent_instance: GObject.Object = ...
    priv: DBusObjectProxyPrivate = ...
    def __init__(
        self, *, g_connection: DBusConnection = ..., g_object_path: str = ...
    ) -> None: ...
    def get_connection(self) -> DBusConnection: ...
    @classmethod
    def new(cls, connection: DBusConnection, object_path: str) -> DBusObjectProxy: ...

class DBusObjectProxyClass(GObject.GPointer):
    """
    :Constructors:

    ::

        DBusObjectProxyClass()
    """

    parent_class: GObject.ObjectClass = ...
    padding: list[None] = ...

class DBusObjectProxyPrivate(GObject.GPointer): ...

class DBusObjectSkeleton(GObject.Object, DBusObject):
    """
    :Constructors:

    ::

        DBusObjectSkeleton(**properties)
        new(object_path:str) -> Gio.DBusObjectSkeleton

    Object GDBusObjectSkeleton

    Signals from GDBusObjectSkeleton:
      authorize-method (GDBusInterfaceSkeleton, GDBusMethodInvocation) -> gboolean

    Properties from GDBusObjectSkeleton:
      g-object-path -> gchararray: g-object-path

    Signals from GDBusObject:
      interface-added (GDBusInterface)
      interface-removed (GDBusInterface)

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        g_object_path: str

    props: Props = ...
    parent_instance: GObject.Object = ...
    priv: DBusObjectSkeletonPrivate = ...
    def __init__(self, *, g_object_path: str = ...) -> None: ...
    def add_interface(self, interface_: DBusInterfaceSkeleton) -> None: ...
    def do_authorize_method(
        self, interface_: DBusInterfaceSkeleton, invocation: DBusMethodInvocation
    ) -> bool: ...
    def flush(self) -> None: ...
    @classmethod
    def new(cls, object_path: str) -> DBusObjectSkeleton: ...
    def remove_interface(self, interface_: DBusInterfaceSkeleton) -> None: ...
    def remove_interface_by_name(self, interface_name: str) -> None: ...
    def set_object_path(self, object_path: str) -> None: ...

class DBusObjectSkeletonClass(GObject.GPointer):
    """
    :Constructors:

    ::

        DBusObjectSkeletonClass()
    """

    parent_class: GObject.ObjectClass = ...
    authorize_method: typing.Callable[
        [DBusObjectSkeleton, DBusInterfaceSkeleton, DBusMethodInvocation], bool
    ] = ...
    padding: list[None] = ...

class DBusObjectSkeletonPrivate(GObject.GPointer): ...

class DBusPropertyInfo(GObject.GBoxed):
    """
    :Constructors:

    ::

        DBusPropertyInfo()
    """

    ref_count: int = ...
    name: str = ...
    signature: str = ...
    flags: DBusPropertyInfoFlags = ...
    annotations: list[DBusAnnotationInfo] = ...
    def ref(self) -> DBusPropertyInfo: ...
    def unref(self) -> None: ...

class DBusProxy(GObject.Object, AsyncInitable, DBusInterface, Initable):
    """
    Provide comfortable and pythonic method calls.

    This marshalls the method arguments into a GVariant, invokes the
    call_sync() method on the DBusProxy object, and unmarshalls the result
    GVariant back into a Python tuple.

    The first argument always needs to be the D-Bus signature tuple of the
    method call. Example:

      proxy = Gio.DBusProxy.new_sync(...)
      result = proxy.MyMethod('(is)', 42, 'hello')

    The exception are methods which take no arguments, like
    proxy.MyMethod('()'). For these you can omit the signature and just write
    proxy.MyMethod().

    Optional keyword arguments:

    - timeout: timeout for the call in milliseconds (default to D-Bus timeout)

    - flags: Combination of Gio.DBusCallFlags.*

    - result_handler: Do an asynchronous method call and invoke
         result_handler(proxy_object, result, user_data) when it finishes.

    - error_handler: If the asynchronous call raises an exception,
      error_handler(proxy_object, exception, user_data) is called when it
      finishes. If error_handler is not given, result_handler is called with
      the exception object as result instead.

    - user_data: Optional user data to pass to result_handler for
      asynchronous calls.

    Example for asynchronous calls:

      def mymethod_done(proxy, result, user_data):
          if isinstance(result, Exception):
              # handle error
          else:
              # do something with result

      proxy.MyMethod('(is)', 42, 'hello',
          result_handler=mymethod_done, user_data='data')

    Object GDBusProxy

    Provide comfortable and pythonic method calls.

    This marshalls the method arguments into a GVariant, invokes the
    call_sync() method on the DBusProxy object, and unmarshalls the result
    GVariant back into a Python tuple.

    The first argument always needs to be the D-Bus signature tuple of the
    method call. Example:

      proxy = Gio.DBusProxy.new_sync(...)
      result = proxy.MyMethod('(is)', 42, 'hello')

    The exception are methods which take no arguments, like
    proxy.MyMethod('()'). For these you can omit the signature and just write
    proxy.MyMethod().

    Optional keyword arguments:

    - timeout: timeout for the call in milliseconds (default to D-Bus timeout)

    - flags: Combination of Gio.DBusCallFlags.*

    - result_handler: Do an asynchronous method call and invoke
         result_handler(proxy_object, result, user_data) when it finishes.

    - error_handler: If the asynchronous call raises an exception,
      error_handler(proxy_object, exception, user_data) is called when it
      finishes. If error_handler is not given, result_handler is called with
      the exception object as result instead.

    - user_data: Optional user data to pass to result_handler for
      asynchronous calls.

    Example for asynchronous calls:

      def mymethod_done(proxy, result, user_data):
          if isinstance(result, Exception):
              # handle error
          else:
              # do something with result

      proxy.MyMethod('(is)', 42, 'hello',
          result_handler=mymethod_done, user_data='data')


    Signals from GDBusProxy:
      g-properties-changed (GVariant, GStrv)
      g-signal (gchararray, gchararray, GVariant)

    Properties from GDBusProxy:
      g-connection -> GDBusConnection: g-connection
      g-bus-type -> GBusType: g-bus-type
      g-name -> gchararray: g-name
      g-name-owner -> gchararray: g-name-owner
      g-flags -> GDBusProxyFlags: g-flags
      g-object-path -> gchararray: g-object-path
      g-interface-name -> gchararray: g-interface-name
      g-default-timeout -> gint: g-default-timeout
      g-interface-info -> GDBusInterfaceInfo: g-interface-info

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        g_connection: DBusConnection
        g_default_timeout: int
        g_flags: DBusProxyFlags
        g_interface_info: DBusInterfaceInfo
        g_interface_name: str
        g_name: str
        g_name_owner: str
        g_object_path: str
        g_bus_type: BusType

    props: Props = ...
    parent_instance: GObject.Object = ...
    priv: DBusProxyPrivate = ...
    def __init__(
        self,
        *,
        g_bus_type: BusType = ...,
        g_connection: DBusConnection = ...,
        g_default_timeout: int = ...,
        g_flags: DBusProxyFlags = ...,
        g_interface_info: DBusInterfaceInfo = ...,
        g_interface_name: str = ...,
        g_name: str = ...,
        g_object_path: str = ...,
    ) -> None: ...
    def call(
        self,
        method_name: str,
        parameters: typing.Optional[GLib.Variant],
        flags: DBusCallFlags,
        timeout_msec: int,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def call_finish(self, res: AsyncResult) -> GLib.Variant: ...
    def call_sync(
        self,
        method_name: str,
        parameters: typing.Optional[GLib.Variant],
        flags: DBusCallFlags,
        timeout_msec: int,
        cancellable: typing.Optional[Cancellable] = None,
    ) -> GLib.Variant: ...
    def call_with_unix_fd_list(
        self,
        method_name: str,
        parameters: typing.Optional[GLib.Variant],
        flags: DBusCallFlags,
        timeout_msec: int,
        fd_list: typing.Optional[UnixFDList] = None,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def call_with_unix_fd_list_finish(
        self, res: AsyncResult
    ) -> typing.Tuple[GLib.Variant, UnixFDList]: ...
    def call_with_unix_fd_list_sync(
        self,
        method_name: str,
        parameters: typing.Optional[GLib.Variant],
        flags: DBusCallFlags,
        timeout_msec: int,
        fd_list: typing.Optional[UnixFDList] = None,
        cancellable: typing.Optional[Cancellable] = None,
    ) -> typing.Tuple[GLib.Variant, UnixFDList]: ...
    def do_g_properties_changed(
        self, changed_properties: GLib.Variant, invalidated_properties: str
    ) -> None: ...
    def do_g_signal(
        self, sender_name: str, signal_name: str, parameters: GLib.Variant
    ) -> None: ...
    def get_cached_property(
        self, property_name: str
    ) -> typing.Optional[GLib.Variant]: ...
    def get_cached_property_names(self) -> typing.Optional[list[str]]: ...
    def get_connection(self) -> DBusConnection: ...
    def get_default_timeout(self) -> int: ...
    def get_flags(self) -> DBusProxyFlags: ...
    def get_interface_info(self) -> typing.Optional[DBusInterfaceInfo]: ...
    def get_interface_name(self) -> str: ...
    def get_name(self) -> typing.Optional[str]: ...
    def get_name_owner(self) -> typing.Optional[str]: ...
    def get_object_path(self) -> str: ...
    @staticmethod
    def new(
        connection: DBusConnection,
        flags: DBusProxyFlags,
        info: typing.Optional[DBusInterfaceInfo],
        name: typing.Optional[str],
        object_path: str,
        interface_name: str,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    @classmethod
    def new_finish(cls, res: AsyncResult) -> DBusProxy: ...
    @staticmethod
    def new_for_bus(
        bus_type: BusType,
        flags: DBusProxyFlags,
        info: typing.Optional[DBusInterfaceInfo],
        name: str,
        object_path: str,
        interface_name: str,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    @classmethod
    def new_for_bus_finish(cls, res: AsyncResult) -> DBusProxy: ...
    @classmethod
    def new_for_bus_sync(
        cls,
        bus_type: BusType,
        flags: DBusProxyFlags,
        info: typing.Optional[DBusInterfaceInfo],
        name: str,
        object_path: str,
        interface_name: str,
        cancellable: typing.Optional[Cancellable] = None,
    ) -> DBusProxy: ...
    @classmethod
    def new_sync(
        cls,
        connection: DBusConnection,
        flags: DBusProxyFlags,
        info: typing.Optional[DBusInterfaceInfo],
        name: typing.Optional[str],
        object_path: str,
        interface_name: str,
        cancellable: typing.Optional[Cancellable] = None,
    ) -> DBusProxy: ...
    def set_cached_property(
        self, property_name: str, value: typing.Optional[GLib.Variant] = None
    ) -> None: ...
    def set_default_timeout(self, timeout_msec: int) -> None: ...
    def set_interface_info(
        self, info: typing.Optional[DBusInterfaceInfo] = None
    ) -> None: ...

class DBusProxyClass(GObject.GPointer):
    """
    :Constructors:

    ::

        DBusProxyClass()
    """

    parent_class: GObject.ObjectClass = ...
    g_properties_changed: typing.Callable[[DBusProxy, GLib.Variant, str], None] = ...
    g_signal: typing.Callable[[DBusProxy, str, str, GLib.Variant], None] = ...
    padding: list[None] = ...

class DBusProxyPrivate(GObject.GPointer): ...

class DBusServer(GObject.Object, Initable):
    """
    :Constructors:

    ::

        DBusServer(**properties)
        new_sync(address:str, flags:Gio.DBusServerFlags, guid:str, observer:Gio.DBusAuthObserver=None, cancellable:Gio.Cancellable=None) -> Gio.DBusServer

    Object GDBusServer

    Signals from GDBusServer:
      new-connection (GDBusConnection) -> gboolean

    Properties from GDBusServer:
      address -> gchararray: address
      client-address -> gchararray: client-address
      flags -> GDBusServerFlags: flags
      guid -> gchararray: guid
      active -> gboolean: active
      authentication-observer -> GDBusAuthObserver: authentication-observer

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        active: bool
        address: str
        authentication_observer: DBusAuthObserver
        client_address: str
        flags: DBusServerFlags
        guid: str

    props: Props = ...
    def __init__(
        self,
        *,
        address: str = ...,
        authentication_observer: DBusAuthObserver = ...,
        flags: DBusServerFlags = ...,
        guid: str = ...,
    ) -> None: ...
    def get_client_address(self) -> str: ...
    def get_flags(self) -> DBusServerFlags: ...
    def get_guid(self) -> str: ...
    def is_active(self) -> bool: ...
    @classmethod
    def new_sync(
        cls,
        address: str,
        flags: DBusServerFlags,
        guid: str,
        observer: typing.Optional[DBusAuthObserver] = None,
        cancellable: typing.Optional[Cancellable] = None,
    ) -> DBusServer: ...
    def start(self) -> None: ...
    def stop(self) -> None: ...

class DBusSignalInfo(GObject.GBoxed):
    """
    :Constructors:

    ::

        DBusSignalInfo()
    """

    ref_count: int = ...
    name: str = ...
    args: list[DBusArgInfo] = ...
    annotations: list[DBusAnnotationInfo] = ...
    def __init__(
        self, *args, **kwargs
    ): ...  # FIXME: Override is missing typing annotation
    def ref(self) -> DBusSignalInfo: ...
    def unref(self) -> None: ...

class DBusSubtreeVTable(GObject.GPointer):
    """
    :Constructors:

    ::

        DBusSubtreeVTable()
    """

    enumerate: typing.Callable[..., list[str]] = ...
    introspect: typing.Callable[..., typing.Optional[list[DBusInterfaceInfo]]] = ...
    dispatch: typing.Callable[..., typing.Optional[DBusInterfaceVTable]] = ...
    padding: list[None] = ...

class DataInputStream(BufferedInputStream, Seekable):
    """
    :Constructors:

    ::

        DataInputStream(**properties)
        new(base_stream:Gio.InputStream) -> Gio.DataInputStream

    Object GDataInputStream

    Properties from GDataInputStream:
      byte-order -> GDataStreamByteOrder: byte-order
      newline-type -> GDataStreamNewlineType: newline-type

    Properties from GBufferedInputStream:
      buffer-size -> guint: buffer-size

    Properties from GFilterInputStream:
      base-stream -> GInputStream: base-stream
      close-base-stream -> gboolean: close-base-stream

    Signals from GObject:
      notify (GParam)
    """
    class Props(BufferedInputStream.Props):
        byte_order: DataStreamByteOrder
        newline_type: DataStreamNewlineType
        buffer_size: int
        base_stream: InputStream
        close_base_stream: bool

    props: Props = ...
    parent_instance: BufferedInputStream = ...
    priv: DataInputStreamPrivate = ...
    def __init__(
        self,
        *,
        byte_order: DataStreamByteOrder = ...,
        newline_type: DataStreamNewlineType = ...,
        buffer_size: int = ...,
        base_stream: InputStream = ...,
        close_base_stream: bool = ...,
    ) -> None: ...
    def __iter__(self): ...  # FIXME: Override is missing typing annotation
    def get_byte_order(self) -> DataStreamByteOrder: ...
    def get_newline_type(self) -> DataStreamNewlineType: ...
    @classmethod
    def new(cls, base_stream: InputStream) -> DataInputStream: ...
    def read_byte(self, cancellable: typing.Optional[Cancellable] = None) -> int: ...
    def read_int16(self, cancellable: typing.Optional[Cancellable] = None) -> int: ...
    def read_int32(self, cancellable: typing.Optional[Cancellable] = None) -> int: ...
    def read_int64(self, cancellable: typing.Optional[Cancellable] = None) -> int: ...
    def read_line(
        self, cancellable: typing.Optional[Cancellable] = None
    ) -> typing.Tuple[typing.Optional[bytes], int]: ...
    def read_line_async(
        self,
        io_priority: int,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def read_line_finish(
        self, result: AsyncResult
    ) -> typing.Tuple[typing.Optional[bytes], int]: ...
    def read_line_finish_utf8(
        self, result: AsyncResult
    ) -> typing.Tuple[typing.Optional[str], int]: ...
    def read_line_utf8(
        self, cancellable: typing.Optional[Cancellable] = None
    ) -> typing.Tuple[typing.Optional[str], int]: ...
    def read_uint16(self, cancellable: typing.Optional[Cancellable] = None) -> int: ...
    def read_uint32(self, cancellable: typing.Optional[Cancellable] = None) -> int: ...
    def read_uint64(self, cancellable: typing.Optional[Cancellable] = None) -> int: ...
    def read_until(
        self, stop_chars: str, cancellable: typing.Optional[Cancellable] = None
    ) -> typing.Tuple[str, int]: ...
    def read_until_async(
        self,
        stop_chars: str,
        io_priority: int,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def read_until_finish(self, result: AsyncResult) -> typing.Tuple[str, int]: ...
    def read_upto(
        self,
        stop_chars: str,
        stop_chars_len: int,
        cancellable: typing.Optional[Cancellable] = None,
    ) -> typing.Tuple[str, int]: ...
    def read_upto_async(
        self,
        stop_chars: str,
        stop_chars_len: int,
        io_priority: int,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def read_upto_finish(self, result: AsyncResult) -> typing.Tuple[str, int]: ...
    def set_byte_order(self, order: DataStreamByteOrder) -> None: ...
    def set_newline_type(self, type: DataStreamNewlineType) -> None: ...

class DataInputStreamClass(GObject.GPointer):
    """
    :Constructors:

    ::

        DataInputStreamClass()
    """

    parent_class: BufferedInputStreamClass = ...

class DataInputStreamPrivate(GObject.GPointer): ...

class DataOutputStream(FilterOutputStream, Seekable):
    """
    :Constructors:

    ::

        DataOutputStream(**properties)
        new(base_stream:Gio.OutputStream) -> Gio.DataOutputStream

    Object GDataOutputStream

    Properties from GDataOutputStream:
      byte-order -> GDataStreamByteOrder: byte-order

    Properties from GFilterOutputStream:
      base-stream -> GOutputStream: base-stream
      close-base-stream -> gboolean: close-base-stream

    Signals from GObject:
      notify (GParam)
    """
    class Props(FilterOutputStream.Props):
        byte_order: DataStreamByteOrder
        base_stream: OutputStream
        close_base_stream: bool

    props: Props = ...
    parent_instance: FilterOutputStream = ...
    priv: DataOutputStreamPrivate = ...
    def __init__(
        self,
        *,
        byte_order: DataStreamByteOrder = ...,
        base_stream: OutputStream = ...,
        close_base_stream: bool = ...,
    ) -> None: ...
    def get_byte_order(self) -> DataStreamByteOrder: ...
    @classmethod
    def new(cls, base_stream: OutputStream) -> DataOutputStream: ...
    def put_byte(
        self, data: int, cancellable: typing.Optional[Cancellable] = None
    ) -> bool: ...
    def put_int16(
        self, data: int, cancellable: typing.Optional[Cancellable] = None
    ) -> bool: ...
    def put_int32(
        self, data: int, cancellable: typing.Optional[Cancellable] = None
    ) -> bool: ...
    def put_int64(
        self, data: int, cancellable: typing.Optional[Cancellable] = None
    ) -> bool: ...
    def put_string(
        self, str: str, cancellable: typing.Optional[Cancellable] = None
    ) -> bool: ...
    def put_uint16(
        self, data: int, cancellable: typing.Optional[Cancellable] = None
    ) -> bool: ...
    def put_uint32(
        self, data: int, cancellable: typing.Optional[Cancellable] = None
    ) -> bool: ...
    def put_uint64(
        self, data: int, cancellable: typing.Optional[Cancellable] = None
    ) -> bool: ...
    def set_byte_order(self, order: DataStreamByteOrder) -> None: ...

class DataOutputStreamClass(GObject.GPointer):
    """
    :Constructors:

    ::

        DataOutputStreamClass()
    """

    parent_class: FilterOutputStreamClass = ...

class DataOutputStreamPrivate(GObject.GPointer): ...

class DatagramBased(GObject.GInterface):
    """
    Interface GDatagramBased

    Signals from GObject:
      notify (GParam)
    """
    def condition_check(self, condition: GLib.IOCondition) -> GLib.IOCondition: ...
    def condition_wait(
        self,
        condition: GLib.IOCondition,
        timeout: int,
        cancellable: typing.Optional[Cancellable] = None,
    ) -> bool: ...
    def create_source(
        self,
        condition: GLib.IOCondition,
        cancellable: typing.Optional[Cancellable] = None,
    ) -> GLib.Source: ...
    def receive_messages(
        self,
        messages: typing.Sequence[InputMessage],
        flags: int,
        timeout: int,
        cancellable: typing.Optional[Cancellable] = None,
    ) -> int: ...
    def send_messages(
        self,
        messages: typing.Sequence[OutputMessage],
        flags: int,
        timeout: int,
        cancellable: typing.Optional[Cancellable] = None,
    ) -> int: ...

class DatagramBasedInterface(GObject.GPointer):
    """
    :Constructors:

    ::

        DatagramBasedInterface()
    """

    g_iface: GObject.TypeInterface = ...
    receive_messages: typing.Callable[
        [
            DatagramBased,
            typing.Sequence[InputMessage],
            int,
            int,
            typing.Optional[Cancellable],
        ],
        int,
    ] = ...
    send_messages: typing.Callable[
        [
            DatagramBased,
            typing.Sequence[OutputMessage],
            int,
            int,
            typing.Optional[Cancellable],
        ],
        int,
    ] = ...
    create_source: typing.Callable[
        [DatagramBased, GLib.IOCondition, typing.Optional[Cancellable]], GLib.Source
    ] = ...
    condition_check: typing.Callable[
        [DatagramBased, GLib.IOCondition], GLib.IOCondition
    ] = ...
    condition_wait: typing.Callable[
        [DatagramBased, GLib.IOCondition, int, typing.Optional[Cancellable]], bool
    ] = ...

class DebugController(GObject.GInterface):
    """
    Interface GDebugController

    Signals from GObject:
      notify (GParam)
    """
    def get_debug_enabled(self) -> bool: ...
    def set_debug_enabled(self, debug_enabled: bool) -> None: ...

class DebugControllerDBus(GObject.Object, DebugController, Initable):
    """
    :Constructors:

    ::

        DebugControllerDBus(**properties)
        new(connection:Gio.DBusConnection, cancellable:Gio.Cancellable=None) -> Gio.DebugControllerDBus or None

    Object GDebugControllerDBus

    Signals from GDebugControllerDBus:
      authorize (GDBusMethodInvocation) -> gboolean

    Properties from GDebugControllerDBus:
      connection -> GDBusConnection: connection

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        connection: DBusConnection
        debug_enabled: bool

    props: Props = ...
    parent_instance: GObject.Object = ...
    def __init__(
        self, *, connection: DBusConnection = ..., debug_enabled: bool = ...
    ) -> None: ...
    def do_authorize(self, invocation: DBusMethodInvocation) -> bool: ...
    @classmethod
    def new(
        cls,
        connection: DBusConnection,
        cancellable: typing.Optional[Cancellable] = None,
    ) -> typing.Optional[DebugControllerDBus]: ...
    def stop(self) -> None: ...

class DebugControllerDBusClass(GObject.GPointer):
    """
    :Constructors:

    ::

        DebugControllerDBusClass()
    """

    parent_class: GObject.ObjectClass = ...
    authorize: typing.Callable[[DebugControllerDBus, DBusMethodInvocation], bool] = ...
    padding: list[None] = ...

class DebugControllerInterface(GObject.GPointer):
    """
    :Constructors:

    ::

        DebugControllerInterface()
    """

    g_iface: GObject.TypeInterface = ...

class DesktopAppInfo(GObject.Object, AppInfo):
    """
    :Constructors:

    ::

        DesktopAppInfo(**properties)
        new(desktop_id:str) -> GioUnix.DesktopAppInfo or None
        new_from_filename(filename:str) -> GioUnix.DesktopAppInfo or None
        new_from_keyfile(key_file:GLib.KeyFile) -> GioUnix.DesktopAppInfo or None

    Object GDesktopAppInfo

    Properties from GDesktopAppInfo:
      filename -> gchararray: filename

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        filename: typing.Optional[str]

    props: Props = ...
    def __init__(self, *, filename: str = ...) -> None: ...
    def get_action_name(self, action_name: str) -> str: ...
    def get_boolean(self, key: str) -> bool: ...
    def get_categories(self) -> typing.Optional[str]: ...
    def get_filename(self) -> typing.Optional[str]: ...
    def get_generic_name(self) -> typing.Optional[str]: ...
    @staticmethod
    def get_implementations(interface: str) -> list[GioUnix.DesktopAppInfo]: ...
    def get_is_hidden(self) -> bool: ...
    def get_keywords(self) -> list[str]: ...
    def get_locale_string(self, key: str) -> typing.Optional[str]: ...
    def get_nodisplay(self) -> bool: ...
    def get_show_in(self, desktop_env: typing.Optional[str] = None) -> bool: ...
    def get_startup_wm_class(self) -> typing.Optional[str]: ...
    def get_string(self, key: str) -> typing.Optional[str]: ...
    def get_string_list(self, key: str) -> list[str]: ...
    def has_key(self, key: str) -> bool: ...
    def launch_action(
        self, action_name: str, launch_context: typing.Optional[AppLaunchContext] = None
    ) -> None: ...
    def launch_uris_as_manager(
        self,
        uris: list[str],
        launch_context: typing.Optional[AppLaunchContext],
        spawn_flags: GLib.SpawnFlags,
        user_setup: typing.Optional[typing.Callable[..., None]] = None,
        pid_callback: typing.Optional[typing.Callable[..., None]] = None,
        *pid_callback_data: typing.Any,
    ) -> bool: ...
    def launch_uris_as_manager_with_fds(
        self,
        uris: list[str],
        launch_context: typing.Optional[AppLaunchContext],
        spawn_flags: GLib.SpawnFlags,
        user_setup: typing.Optional[typing.Callable[..., None]],
        pid_callback: typing.Optional[typing.Callable[..., None]],
        stdin_fd: int,
        stdout_fd: int,
        stderr_fd: int,
        *pid_callback_data: typing.Any,
    ) -> bool: ...
    def list_actions(self) -> list[str]: ...
    @classmethod
    def new(cls, desktop_id: str) -> DesktopAppInfo: ...
    @classmethod
    def new_from_filename(cls, filename: str) -> DesktopAppInfo: ...
    @classmethod
    def new_from_keyfile(cls, key_file: GLib.KeyFile) -> DesktopAppInfo: ...
    @staticmethod
    def search(search_string: str) -> list[typing.Sequence[str]]: ...
    @staticmethod
    def set_desktop_env(desktop_env: str) -> None: ...

class DesktopAppInfoLookup(GObject.GInterface):
    """
    Interface GDesktopAppInfoLookup

    Signals from GObject:
      notify (GParam)
    """
    def get_default_for_uri_scheme(
        self, uri_scheme: str
    ) -> typing.Optional[AppInfo]: ...

class Drive(GObject.GInterface):
    """
    Interface GDrive

    Signals from GObject:
      notify (GParam)
    """
    def can_eject(self) -> bool: ...
    def can_poll_for_media(self) -> bool: ...
    def can_start(self) -> bool: ...
    def can_start_degraded(self) -> bool: ...
    def can_stop(self) -> bool: ...
    def eject(
        self,
        flags: MountUnmountFlags,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def eject_finish(self, result: AsyncResult) -> bool: ...
    def eject_with_operation(
        self,
        flags: MountUnmountFlags,
        mount_operation: typing.Optional[MountOperation] = None,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def eject_with_operation_finish(self, result: AsyncResult) -> bool: ...
    def enumerate_identifiers(self) -> list[str]: ...
    def get_icon(self) -> Icon: ...
    def get_identifier(self, kind: str) -> typing.Optional[str]: ...
    def get_name(self) -> str: ...
    def get_sort_key(self) -> typing.Optional[str]: ...
    def get_start_stop_type(self) -> DriveStartStopType: ...
    def get_symbolic_icon(self) -> Icon: ...
    def get_volumes(self) -> list[Volume]: ...
    def has_media(self) -> bool: ...
    def has_volumes(self) -> bool: ...
    def is_media_check_automatic(self) -> bool: ...
    def is_media_removable(self) -> bool: ...
    def is_removable(self) -> bool: ...
    def poll_for_media(
        self,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def poll_for_media_finish(self, result: AsyncResult) -> bool: ...
    def start(
        self,
        flags: DriveStartFlags,
        mount_operation: typing.Optional[MountOperation] = None,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def start_finish(self, result: AsyncResult) -> bool: ...
    def stop(
        self,
        flags: MountUnmountFlags,
        mount_operation: typing.Optional[MountOperation] = None,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def stop_finish(self, result: AsyncResult) -> bool: ...

class DriveIface(GObject.GPointer):
    """
    :Constructors:

    ::

        DriveIface()
    """

    g_iface: GObject.TypeInterface = ...
    changed: typing.Callable[[Drive], None] = ...
    disconnected: typing.Callable[[Drive], None] = ...
    eject_button: typing.Callable[[Drive], None] = ...
    get_name: typing.Callable[[Drive], str] = ...
    get_icon: typing.Callable[[Drive], Icon] = ...
    has_volumes: typing.Callable[[Drive], bool] = ...
    get_volumes: typing.Callable[[Drive], list[Volume]] = ...
    is_media_removable: typing.Callable[[Drive], bool] = ...
    has_media: typing.Callable[[Drive], bool] = ...
    is_media_check_automatic: typing.Callable[[Drive], bool] = ...
    can_eject: typing.Callable[[Drive], bool] = ...
    can_poll_for_media: typing.Callable[[Drive], bool] = ...
    eject: typing.Callable[..., None] = ...
    eject_finish: typing.Callable[[Drive, AsyncResult], bool] = ...
    poll_for_media: typing.Callable[..., None] = ...
    poll_for_media_finish: typing.Callable[[Drive, AsyncResult], bool] = ...
    get_identifier: typing.Callable[[Drive, str], typing.Optional[str]] = ...
    enumerate_identifiers: typing.Callable[[Drive], list[str]] = ...
    get_start_stop_type: typing.Callable[[Drive], DriveStartStopType] = ...
    can_start: typing.Callable[[Drive], bool] = ...
    can_start_degraded: typing.Callable[[Drive], bool] = ...
    start: typing.Callable[..., None] = ...
    start_finish: typing.Callable[[Drive, AsyncResult], bool] = ...
    can_stop: typing.Callable[[Drive], bool] = ...
    stop: typing.Callable[..., None] = ...
    stop_finish: typing.Callable[[Drive, AsyncResult], bool] = ...
    stop_button: typing.Callable[[Drive], None] = ...
    eject_with_operation: typing.Callable[..., None] = ...
    eject_with_operation_finish: typing.Callable[[Drive, AsyncResult], bool] = ...
    get_sort_key: typing.Callable[[Drive], typing.Optional[str]] = ...
    get_symbolic_icon: typing.Callable[[Drive], Icon] = ...
    is_removable: typing.Callable[[Drive], bool] = ...

class DtlsClientConnection(GObject.GInterface):
    """
    Interface GDtlsClientConnection

    Signals from GObject:
      notify (GParam)
    """
    def get_accepted_cas(self) -> list[typing.Sequence[int]]: ...
    def get_server_identity(self) -> SocketConnectable: ...
    def get_validation_flags(self) -> TlsCertificateFlags: ...
    @staticmethod
    def new(
        base_socket: DatagramBased,
        server_identity: typing.Optional[SocketConnectable] = None,
    ) -> DtlsClientConnection: ...
    def set_server_identity(self, identity: SocketConnectable) -> None: ...
    def set_validation_flags(self, flags: TlsCertificateFlags) -> None: ...

class DtlsClientConnectionInterface(GObject.GPointer):
    """
    :Constructors:

    ::

        DtlsClientConnectionInterface()
    """

    g_iface: GObject.TypeInterface = ...

class DtlsConnection(GObject.GInterface):
    """
    Interface GDtlsConnection

    Signals from GObject:
      notify (GParam)
    """
    def close(self, cancellable: typing.Optional[Cancellable] = None) -> bool: ...
    def close_async(
        self,
        io_priority: int,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def close_finish(self, result: AsyncResult) -> bool: ...
    def emit_accept_certificate(
        self, peer_cert: TlsCertificate, errors: TlsCertificateFlags
    ) -> bool: ...
    def get_certificate(self) -> typing.Optional[TlsCertificate]: ...
    def get_channel_binding_data(
        self, type: TlsChannelBindingType
    ) -> typing.Tuple[bool, bytes]: ...
    def get_ciphersuite_name(self) -> typing.Optional[str]: ...
    def get_database(self) -> typing.Optional[TlsDatabase]: ...
    def get_interaction(self) -> typing.Optional[TlsInteraction]: ...
    def get_negotiated_protocol(self) -> typing.Optional[str]: ...
    def get_peer_certificate(self) -> typing.Optional[TlsCertificate]: ...
    def get_peer_certificate_errors(self) -> TlsCertificateFlags: ...
    def get_protocol_version(self) -> TlsProtocolVersion: ...
    def get_rehandshake_mode(self) -> TlsRehandshakeMode: ...
    def get_require_close_notify(self) -> bool: ...
    def handshake(self, cancellable: typing.Optional[Cancellable] = None) -> bool: ...
    def handshake_async(
        self,
        io_priority: int,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def handshake_finish(self, result: AsyncResult) -> bool: ...
    def set_advertised_protocols(
        self, protocols: typing.Optional[typing.Sequence[str]] = None
    ) -> None: ...
    def set_certificate(self, certificate: TlsCertificate) -> None: ...
    def set_database(self, database: typing.Optional[TlsDatabase] = None) -> None: ...
    def set_interaction(
        self, interaction: typing.Optional[TlsInteraction] = None
    ) -> None: ...
    def set_rehandshake_mode(self, mode: TlsRehandshakeMode) -> None: ...
    def set_require_close_notify(self, require_close_notify: bool) -> None: ...
    def shutdown(
        self,
        shutdown_read: bool,
        shutdown_write: bool,
        cancellable: typing.Optional[Cancellable] = None,
    ) -> bool: ...
    def shutdown_async(
        self,
        shutdown_read: bool,
        shutdown_write: bool,
        io_priority: int,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def shutdown_finish(self, result: AsyncResult) -> bool: ...

class DtlsConnectionInterface(GObject.GPointer):
    """
    :Constructors:

    ::

        DtlsConnectionInterface()
    """

    g_iface: GObject.TypeInterface = ...
    accept_certificate: typing.Callable[
        [DtlsConnection, TlsCertificate, TlsCertificateFlags], bool
    ] = ...
    handshake: typing.Callable[
        [DtlsConnection, typing.Optional[Cancellable]], bool
    ] = ...
    handshake_async: typing.Callable[..., None] = ...
    handshake_finish: typing.Callable[[DtlsConnection, AsyncResult], bool] = ...
    shutdown: typing.Callable[
        [DtlsConnection, bool, bool, typing.Optional[Cancellable]], bool
    ] = ...
    shutdown_async: typing.Callable[..., None] = ...
    shutdown_finish: typing.Callable[[DtlsConnection, AsyncResult], bool] = ...
    set_advertised_protocols: typing.Callable[
        [DtlsConnection, typing.Optional[typing.Sequence[str]]], None
    ] = ...
    get_negotiated_protocol: typing.Callable[
        [DtlsConnection], typing.Optional[str]
    ] = ...
    get_binding_data: typing.Callable[
        [DtlsConnection, TlsChannelBindingType, typing.Sequence[int]], bool
    ] = ...

class DtlsServerConnection(GObject.GInterface):
    """
    Interface GDtlsServerConnection

    Signals from GObject:
      notify (GParam)
    """
    @staticmethod
    def new(
        base_socket: DatagramBased, certificate: typing.Optional[TlsCertificate] = None
    ) -> DtlsServerConnection: ...

class DtlsServerConnectionInterface(GObject.GPointer):
    """
    :Constructors:

    ::

        DtlsServerConnectionInterface()
    """

    g_iface: GObject.TypeInterface = ...

class Emblem(GObject.Object, Icon):
    """
    :Constructors:

    ::

        Emblem(**properties)
        new(icon:Gio.Icon) -> Gio.Emblem
        new_with_origin(icon:Gio.Icon, origin:Gio.EmblemOrigin) -> Gio.Emblem

    Object GEmblem

    Properties from GEmblem:
      icon -> GObject: icon
      origin -> GEmblemOrigin: origin

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        icon: GObject.Object
        origin: EmblemOrigin

    props: Props = ...
    # override
    def __init__(
        self, *, icon: GObject.Object = ..., origin: EmblemOrigin = ...
    ) -> None: ...
    def get_icon(self) -> Icon: ...
    def get_origin(self) -> EmblemOrigin: ...
    @classmethod
    def new(cls, icon: Icon) -> Emblem: ...
    @classmethod
    def new_with_origin(cls, icon: Icon, origin: EmblemOrigin) -> Emblem: ...

class EmblemClass(GObject.GPointer): ...

class EmblemedIcon(GObject.Object, Icon):
    """
    :Constructors:

    ::

        EmblemedIcon(**properties)
        new(icon:Gio.Icon, emblem:Gio.Emblem=None) -> Gio.EmblemedIcon

    Object GEmblemedIcon

    Properties from GEmblemedIcon:
      gicon -> GIcon: gicon

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        gicon: Icon

    props: Props = ...
    parent_instance: GObject.Object = ...
    priv: EmblemedIconPrivate = ...
    # override
    def __init__(self, *, gicon: Icon = ...) -> None: ...
    def add_emblem(self, emblem: Emblem) -> None: ...
    def clear_emblems(self) -> None: ...
    def get_emblems(self) -> list[Emblem]: ...
    def get_icon(self) -> Icon: ...
    @classmethod
    def new(
        cls, icon: Icon, emblem: typing.Optional[Emblem] = None
    ) -> EmblemedIcon: ...

class EmblemedIconClass(GObject.GPointer):
    """
    :Constructors:

    ::

        EmblemedIconClass()
    """

    parent_class: GObject.ObjectClass = ...

class EmblemedIconPrivate(GObject.GPointer): ...

class File(GObject.GInterface):
    """
    Interface GFile

    Signals from GObject:
      notify (GParam)
    """
    def append_to(
        self, flags: FileCreateFlags, cancellable: typing.Optional[Cancellable] = None
    ) -> FileOutputStream: ...
    def append_to_async(
        self,
        flags: FileCreateFlags,
        io_priority: int,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def append_to_finish(self, res: AsyncResult) -> FileOutputStream: ...
    def build_attribute_list_for_copy(
        self, flags: FileCopyFlags, cancellable: typing.Optional[Cancellable] = None
    ) -> str: ...
    def copy(
        self,
        destination: File,
        flags: FileCopyFlags,
        cancellable: typing.Optional[Cancellable] = None,
        progress_callback: typing.Optional[typing.Callable[..., None]] = None,
        *progress_callback_data: typing.Any,
    ) -> bool: ...
    def copy_async(
        self,
        destination: File,
        flags: FileCopyFlags,
        io_priority: int,
        cancellable: typing.Optional[Cancellable],
        progress_callback_closure: typing.Optional[typing.Callable[..., typing.Any]],
        ready_callback_closure: typing.Callable[..., typing.Any],
    ) -> None: ...
    def copy_attributes(
        self,
        destination: File,
        flags: FileCopyFlags,
        cancellable: typing.Optional[Cancellable] = None,
    ) -> bool: ...
    def copy_finish(self, res: AsyncResult) -> bool: ...
    def create(
        self, flags: FileCreateFlags, cancellable: typing.Optional[Cancellable] = None
    ) -> FileOutputStream: ...
    def create_async(
        self,
        flags: FileCreateFlags,
        io_priority: int,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def create_finish(self, res: AsyncResult) -> FileOutputStream: ...
    def create_readwrite(
        self, flags: FileCreateFlags, cancellable: typing.Optional[Cancellable] = None
    ) -> FileIOStream: ...
    def create_readwrite_async(
        self,
        flags: FileCreateFlags,
        io_priority: int,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def create_readwrite_finish(self, res: AsyncResult) -> FileIOStream: ...
    def delete(self, cancellable: typing.Optional[Cancellable] = None) -> bool: ...
    def delete_async(
        self,
        io_priority: int,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def delete_finish(self, result: AsyncResult) -> bool: ...
    def dup(self) -> File: ...
    def eject_mountable(
        self,
        flags: MountUnmountFlags,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def eject_mountable_finish(self, result: AsyncResult) -> bool: ...
    def eject_mountable_with_operation(
        self,
        flags: MountUnmountFlags,
        mount_operation: typing.Optional[MountOperation] = None,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def eject_mountable_with_operation_finish(self, result: AsyncResult) -> bool: ...
    def enumerate_children(
        self,
        attributes: str,
        flags: FileQueryInfoFlags,
        cancellable: typing.Optional[Cancellable] = None,
    ) -> FileEnumerator: ...
    def enumerate_children_async(
        self,
        attributes: str,
        flags: FileQueryInfoFlags,
        io_priority: int,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def enumerate_children_finish(self, res: AsyncResult) -> FileEnumerator: ...
    def equal(self, file2: File) -> bool: ...
    def find_enclosing_mount(
        self, cancellable: typing.Optional[Cancellable] = None
    ) -> Mount: ...
    def find_enclosing_mount_async(
        self,
        io_priority: int,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def find_enclosing_mount_finish(self, res: AsyncResult) -> Mount: ...
    def get_basename(self) -> typing.Optional[str]: ...
    def get_child(self, name: str) -> File: ...
    def get_child_for_display_name(self, display_name: str) -> File: ...
    def get_parent(self) -> typing.Optional[File]: ...
    def get_parse_name(self) -> str: ...
    def get_path(self) -> typing.Optional[str]: ...
    def get_relative_path(self, descendant: File) -> typing.Optional[str]: ...
    def get_uri(self) -> str: ...
    def get_uri_scheme(self) -> typing.Optional[str]: ...
    def has_parent(self, parent: typing.Optional[File] = None) -> bool: ...
    def has_prefix(self, prefix: File) -> bool: ...
    def has_uri_scheme(self, uri_scheme: str) -> bool: ...
    def hash(self) -> int: ...
    def is_native(self) -> bool: ...
    def load_bytes(
        self, cancellable: typing.Optional[Cancellable] = None
    ) -> typing.Tuple[GLib.Bytes, str]: ...
    def load_bytes_async(
        self,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def load_bytes_finish(
        self, result: AsyncResult
    ) -> typing.Tuple[GLib.Bytes, str]: ...
    def load_contents(
        self, cancellable: typing.Optional[Cancellable] = None
    ) -> typing.Tuple[bool, bytes, str]: ...
    def load_contents_async(
        self,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def load_contents_finish(
        self, res: AsyncResult
    ) -> typing.Tuple[bool, bytes, str]: ...
    def load_partial_contents_finish(
        self, res: AsyncResult
    ) -> typing.Tuple[bool, bytes, str]: ...
    def make_directory(
        self, cancellable: typing.Optional[Cancellable] = None
    ) -> bool: ...
    def make_directory_async(
        self,
        io_priority: int,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def make_directory_finish(self, result: AsyncResult) -> bool: ...
    def make_directory_with_parents(
        self, cancellable: typing.Optional[Cancellable] = None
    ) -> bool: ...
    def make_symbolic_link(
        self, symlink_value: str, cancellable: typing.Optional[Cancellable] = None
    ) -> bool: ...
    def make_symbolic_link_async(
        self,
        symlink_value: str,
        io_priority: int,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def make_symbolic_link_finish(self, result: AsyncResult) -> bool: ...
    def measure_disk_usage(
        self,
        flags: FileMeasureFlags,
        cancellable: typing.Optional[Cancellable] = None,
        progress_callback: typing.Optional[typing.Callable[..., None]] = None,
        *progress_data: typing.Any,
    ) -> typing.Tuple[bool, int, int, int]: ...
    def measure_disk_usage_finish(
        self, result: AsyncResult
    ) -> typing.Tuple[bool, int, int, int]: ...
    def monitor(
        self, flags: FileMonitorFlags, cancellable: typing.Optional[Cancellable] = None
    ) -> FileMonitor: ...
    def monitor_directory(
        self, flags: FileMonitorFlags, cancellable: typing.Optional[Cancellable] = None
    ) -> FileMonitor: ...
    def monitor_file(
        self, flags: FileMonitorFlags, cancellable: typing.Optional[Cancellable] = None
    ) -> FileMonitor: ...
    def mount_enclosing_volume(
        self,
        flags: MountMountFlags,
        mount_operation: typing.Optional[MountOperation] = None,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def mount_enclosing_volume_finish(self, result: AsyncResult) -> bool: ...
    def mount_mountable(
        self,
        flags: MountMountFlags,
        mount_operation: typing.Optional[MountOperation] = None,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def mount_mountable_finish(self, result: AsyncResult) -> File: ...
    def move(
        self,
        destination: File,
        flags: FileCopyFlags,
        cancellable: typing.Optional[Cancellable] = None,
        progress_callback: typing.Optional[typing.Callable[..., None]] = None,
        *progress_callback_data: typing.Any,
    ) -> bool: ...
    def move_async(
        self,
        destination: File,
        flags: FileCopyFlags,
        io_priority: int,
        cancellable: typing.Optional[Cancellable],
        progress_callback_closure: typing.Optional[typing.Callable[..., typing.Any]],
        ready_callback_closure: typing.Callable[..., typing.Any],
    ) -> None: ...
    def move_finish(self, result: AsyncResult) -> bool: ...
    @staticmethod
    def new_build_filenamev(args: typing.Sequence[str]) -> File: ...
    @staticmethod
    def new_for_commandline_arg(arg: str) -> File: ...
    @staticmethod
    def new_for_commandline_arg_and_cwd(arg: str, cwd: str) -> File: ...
    @staticmethod
    def new_for_path(path: str) -> File: ...
    @staticmethod
    def new_for_uri(uri: str) -> File: ...
    @staticmethod
    def new_tmp(
        tmpl: typing.Optional[str] = None,
    ) -> typing.Tuple[File, FileIOStream]: ...
    @staticmethod
    def new_tmp_async(
        tmpl: typing.Optional[str],
        io_priority: int,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    @staticmethod
    def new_tmp_dir_async(
        tmpl: typing.Optional[str],
        io_priority: int,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    @staticmethod
    def new_tmp_dir_finish(result: AsyncResult) -> File: ...
    @staticmethod
    def new_tmp_finish(result: AsyncResult) -> typing.Tuple[File, FileIOStream]: ...
    def open_readwrite(
        self, cancellable: typing.Optional[Cancellable] = None
    ) -> FileIOStream: ...
    def open_readwrite_async(
        self,
        io_priority: int,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def open_readwrite_finish(self, res: AsyncResult) -> FileIOStream: ...
    @staticmethod
    def parse_name(parse_name: str) -> File: ...
    def peek_path(self) -> typing.Optional[str]: ...
    def poll_mountable(
        self,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def poll_mountable_finish(self, result: AsyncResult) -> bool: ...
    def query_default_handler(
        self, cancellable: typing.Optional[Cancellable] = None
    ) -> AppInfo: ...
    def query_default_handler_async(
        self,
        io_priority: int,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def query_default_handler_finish(self, result: AsyncResult) -> AppInfo: ...
    def query_exists(
        self, cancellable: typing.Optional[Cancellable] = None
    ) -> bool: ...
    def query_file_type(
        self,
        flags: FileQueryInfoFlags,
        cancellable: typing.Optional[Cancellable] = None,
    ) -> FileType: ...
    def query_filesystem_info(
        self, attributes: str, cancellable: typing.Optional[Cancellable] = None
    ) -> FileInfo: ...
    def query_filesystem_info_async(
        self,
        attributes: str,
        io_priority: int,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def query_filesystem_info_finish(self, res: AsyncResult) -> FileInfo: ...
    def query_info(
        self,
        attributes: str,
        flags: FileQueryInfoFlags,
        cancellable: typing.Optional[Cancellable] = None,
    ) -> FileInfo: ...
    def query_info_async(
        self,
        attributes: str,
        flags: FileQueryInfoFlags,
        io_priority: int,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def query_info_finish(self, res: AsyncResult) -> FileInfo: ...
    def query_settable_attributes(
        self, cancellable: typing.Optional[Cancellable] = None
    ) -> FileAttributeInfoList: ...
    def query_writable_namespaces(
        self, cancellable: typing.Optional[Cancellable] = None
    ) -> FileAttributeInfoList: ...
    def read(
        self, cancellable: typing.Optional[Cancellable] = None
    ) -> FileInputStream: ...
    def read_async(
        self,
        io_priority: int,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def read_finish(self, res: AsyncResult) -> FileInputStream: ...
    def replace(
        self,
        etag: typing.Optional[str],
        make_backup: bool,
        flags: FileCreateFlags,
        cancellable: typing.Optional[Cancellable] = None,
    ) -> FileOutputStream: ...
    def replace_async(
        self,
        etag: typing.Optional[str],
        make_backup: bool,
        flags: FileCreateFlags,
        io_priority: int,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def replace_contents(
        self,
        contents: typing.Sequence[int],
        etag: typing.Optional[str],
        make_backup: bool,
        flags: FileCreateFlags,
        cancellable: typing.Optional[Cancellable] = None,
    ) -> typing.Tuple[bool, str]: ...
    def replace_contents_async(
        self,
        contents: typing.Sequence[int],
        etag: typing.Optional[str],
        make_backup: bool,
        flags: FileCreateFlags,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def replace_contents_bytes_async(
        self,
        contents: GLib.Bytes,
        etag: typing.Optional[str],
        make_backup: bool,
        flags: FileCreateFlags,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def replace_contents_finish(self, res: AsyncResult) -> typing.Tuple[bool, str]: ...
    def replace_finish(self, res: AsyncResult) -> FileOutputStream: ...
    def replace_readwrite(
        self,
        etag: typing.Optional[str],
        make_backup: bool,
        flags: FileCreateFlags,
        cancellable: typing.Optional[Cancellable] = None,
    ) -> FileIOStream: ...
    def replace_readwrite_async(
        self,
        etag: typing.Optional[str],
        make_backup: bool,
        flags: FileCreateFlags,
        io_priority: int,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def replace_readwrite_finish(self, res: AsyncResult) -> FileIOStream: ...
    def resolve_relative_path(self, relative_path: str) -> File: ...
    def set_attribute(
        self,
        attribute: str,
        type: FileAttributeType,
        value_p: None,
        flags: FileQueryInfoFlags,
        cancellable: typing.Optional[Cancellable] = None,
    ) -> bool: ...
    def set_attribute_byte_string(
        self,
        attribute: str,
        value: str,
        flags: FileQueryInfoFlags,
        cancellable: typing.Optional[Cancellable] = None,
    ) -> bool: ...
    def set_attribute_int32(
        self,
        attribute: str,
        value: int,
        flags: FileQueryInfoFlags,
        cancellable: typing.Optional[Cancellable] = None,
    ) -> bool: ...
    def set_attribute_int64(
        self,
        attribute: str,
        value: int,
        flags: FileQueryInfoFlags,
        cancellable: typing.Optional[Cancellable] = None,
    ) -> bool: ...
    def set_attribute_string(
        self,
        attribute: str,
        value: str,
        flags: FileQueryInfoFlags,
        cancellable: typing.Optional[Cancellable] = None,
    ) -> bool: ...
    def set_attribute_uint32(
        self,
        attribute: str,
        value: int,
        flags: FileQueryInfoFlags,
        cancellable: typing.Optional[Cancellable] = None,
    ) -> bool: ...
    def set_attribute_uint64(
        self,
        attribute: str,
        value: int,
        flags: FileQueryInfoFlags,
        cancellable: typing.Optional[Cancellable] = None,
    ) -> bool: ...
    def set_attributes_async(
        self,
        info: FileInfo,
        flags: FileQueryInfoFlags,
        io_priority: int,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def set_attributes_finish(
        self, result: AsyncResult
    ) -> typing.Tuple[bool, FileInfo]: ...
    def set_attributes_from_info(
        self,
        info: FileInfo,
        flags: FileQueryInfoFlags,
        cancellable: typing.Optional[Cancellable] = None,
    ) -> bool: ...
    def set_display_name(
        self, display_name: str, cancellable: typing.Optional[Cancellable] = None
    ) -> File: ...
    def set_display_name_async(
        self,
        display_name: str,
        io_priority: int,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def set_display_name_finish(self, res: AsyncResult) -> File: ...
    def start_mountable(
        self,
        flags: DriveStartFlags,
        start_operation: typing.Optional[MountOperation] = None,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def start_mountable_finish(self, result: AsyncResult) -> bool: ...
    def stop_mountable(
        self,
        flags: MountUnmountFlags,
        mount_operation: typing.Optional[MountOperation] = None,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def stop_mountable_finish(self, result: AsyncResult) -> bool: ...
    def supports_thread_contexts(self) -> bool: ...
    def trash(self, cancellable: typing.Optional[Cancellable] = None) -> bool: ...
    def trash_async(
        self,
        io_priority: int,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def trash_finish(self, result: AsyncResult) -> bool: ...
    def unmount_mountable(
        self,
        flags: MountUnmountFlags,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def unmount_mountable_finish(self, result: AsyncResult) -> bool: ...
    def unmount_mountable_with_operation(
        self,
        flags: MountUnmountFlags,
        mount_operation: typing.Optional[MountOperation] = None,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def unmount_mountable_with_operation_finish(self, result: AsyncResult) -> bool: ...

class FileAttributeInfo(GObject.GPointer):
    """
    :Constructors:

    ::

        FileAttributeInfo()
    """

    name: str = ...
    type: FileAttributeType = ...
    flags: FileAttributeInfoFlags = ...

class FileAttributeInfoList(GObject.GBoxed):
    """
    :Constructors:

    ::

        FileAttributeInfoList()
        new() -> Gio.FileAttributeInfoList
    """

    infos: FileAttributeInfo = ...
    n_infos: int = ...
    @staticmethod
    def __new__(cls: type[Self]) -> Self: ...
    def add(
        self, name: str, type: FileAttributeType, flags: FileAttributeInfoFlags
    ) -> None: ...
    def dup(self) -> FileAttributeInfoList: ...
    def lookup(self, name: str) -> FileAttributeInfo: ...
    @classmethod
    def new(cls) -> FileAttributeInfoList: ...
    def ref(self) -> FileAttributeInfoList: ...
    def unref(self) -> None: ...

class FileAttributeMatcher(GObject.GBoxed):
    """
    :Constructors:

    ::

        new(attributes:str) -> Gio.FileAttributeMatcher
    """
    @staticmethod
    def __new__(cls: type[Self], attributes: str) -> Self: ...
    def enumerate_namespace(self, ns: str) -> bool: ...
    def enumerate_next(self) -> typing.Optional[str]: ...
    def matches(self, attribute: str) -> bool: ...
    def matches_only(self, attribute: str) -> bool: ...
    @classmethod
    def new(cls, attributes: str) -> FileAttributeMatcher: ...
    def ref(self) -> FileAttributeMatcher: ...
    def subtract(
        self, subtract: typing.Optional[FileAttributeMatcher] = None
    ) -> typing.Optional[FileAttributeMatcher]: ...
    def to_string(self) -> str: ...
    def unref(self) -> None: ...

class FileDescriptorBased(GObject.GInterface):
    """
    Interface GFileDescriptorBased

    Signals from GObject:
      notify (GParam)
    """
    def get_fd(self) -> int: ...

class FileEnumerator(GObject.Object):
    """
    :Constructors:

    ::

        FileEnumerator(**properties)

    Object GFileEnumerator

    Properties from GFileEnumerator:
      container -> GFile: container

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        container: File

    props: Props = ...
    parent_instance: GObject.Object = ...
    priv: FileEnumeratorPrivate = ...
    def __init__(self, *, container: File = ...) -> None: ...
    def __iter__(self): ...  # FIXME: Override is missing typing annotation
    def close(self, cancellable: typing.Optional[Cancellable] = None) -> bool: ...
    def close_async(
        self,
        io_priority: int,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def close_finish(self, result: AsyncResult) -> bool: ...
    def do_close_async(
        self,
        io_priority: int,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def do_close_finish(self, result: AsyncResult) -> bool: ...
    def do_close_fn(self, cancellable: typing.Optional[Cancellable] = None) -> bool: ...
    def do_next_file(
        self, cancellable: typing.Optional[Cancellable] = None
    ) -> typing.Optional[FileInfo]: ...
    def do_next_files_async(
        self,
        num_files: int,
        io_priority: int,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def do_next_files_finish(self, result: AsyncResult) -> list[FileInfo]: ...
    def get_child(self, info: FileInfo) -> File: ...
    def get_container(self) -> File: ...
    def has_pending(self) -> bool: ...
    def is_closed(self) -> bool: ...
    def iterate(
        self, cancellable: typing.Optional[Cancellable] = None
    ) -> typing.Tuple[bool, FileInfo, File]: ...
    def next_file(
        self, cancellable: typing.Optional[Cancellable] = None
    ) -> typing.Optional[FileInfo]: ...
    def next_files_async(
        self,
        num_files: int,
        io_priority: int,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def next_files_finish(self, result: AsyncResult) -> list[FileInfo]: ...
    def set_pending(self, pending: bool) -> None: ...

class FileEnumeratorClass(GObject.GPointer):
    """
    :Constructors:

    ::

        FileEnumeratorClass()
    """

    parent_class: GObject.ObjectClass = ...
    next_file: typing.Callable[
        [FileEnumerator, typing.Optional[Cancellable]], typing.Optional[FileInfo]
    ] = ...
    close_fn: typing.Callable[
        [FileEnumerator, typing.Optional[Cancellable]], bool
    ] = ...
    next_files_async: typing.Callable[..., None] = ...
    next_files_finish: typing.Callable[
        [FileEnumerator, AsyncResult], list[FileInfo]
    ] = ...
    close_async: typing.Callable[..., None] = ...
    close_finish: typing.Callable[[FileEnumerator, AsyncResult], bool] = ...

class FileEnumeratorPrivate(GObject.GPointer): ...

class FileIOStream(IOStream, Seekable):
    """
    :Constructors:

    ::

        FileIOStream(**properties)

    Object GFileIOStream

    Properties from GIOStream:
      input-stream -> GInputStream: input-stream
      output-stream -> GOutputStream: output-stream
      closed -> gboolean: closed

    Signals from GObject:
      notify (GParam)
    """
    class Props(IOStream.Props):
        closed: bool
        input_stream: InputStream
        output_stream: OutputStream

    props: Props = ...
    parent_instance: IOStream = ...
    priv: FileIOStreamPrivate = ...
    def do_can_seek(self) -> bool: ...
    def do_can_truncate(self) -> bool: ...
    def do_get_etag(self) -> typing.Optional[str]: ...
    def do_query_info(
        self, attributes: str, cancellable: typing.Optional[Cancellable] = None
    ) -> FileInfo: ...
    def do_query_info_async(
        self,
        attributes: str,
        io_priority: int,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def do_query_info_finish(self, result: AsyncResult) -> FileInfo: ...
    def do_seek(
        self,
        offset: int,
        type: GLib.SeekType,
        cancellable: typing.Optional[Cancellable] = None,
    ) -> bool: ...
    def do_tell(self) -> int: ...
    def do_truncate_fn(
        self, size: int, cancellable: typing.Optional[Cancellable] = None
    ) -> bool: ...
    def get_etag(self) -> typing.Optional[str]: ...
    def query_info(
        self, attributes: str, cancellable: typing.Optional[Cancellable] = None
    ) -> FileInfo: ...
    def query_info_async(
        self,
        attributes: str,
        io_priority: int,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def query_info_finish(self, result: AsyncResult) -> FileInfo: ...

class FileIOStreamClass(GObject.GPointer):
    """
    :Constructors:

    ::

        FileIOStreamClass()
    """

    parent_class: IOStreamClass = ...
    tell: typing.Callable[[FileIOStream], int] = ...
    can_seek: typing.Callable[[FileIOStream], bool] = ...
    seek: typing.Callable[
        [FileIOStream, int, GLib.SeekType, typing.Optional[Cancellable]], bool
    ] = ...
    can_truncate: typing.Callable[[FileIOStream], bool] = ...
    truncate_fn: typing.Callable[
        [FileIOStream, int, typing.Optional[Cancellable]], bool
    ] = ...
    query_info: typing.Callable[
        [FileIOStream, str, typing.Optional[Cancellable]], FileInfo
    ] = ...
    query_info_async: typing.Callable[..., None] = ...
    query_info_finish: typing.Callable[[FileIOStream, AsyncResult], FileInfo] = ...
    get_etag: typing.Callable[[FileIOStream], typing.Optional[str]] = ...

class FileIOStreamPrivate(GObject.GPointer): ...

class FileIcon(GObject.Object, Icon, LoadableIcon):
    """
    :Constructors:

    ::

        FileIcon(**properties)
        new(file:Gio.File) -> Gio.FileIcon

    Object GFileIcon

    Properties from GFileIcon:
      file -> GFile: file

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        file: File

    props: Props = ...
    # override
    def __init__(self, *, file: File = ...) -> None: ...
    def get_file(self) -> File: ...
    @classmethod
    def new(cls, file: File) -> FileIcon: ...

class FileIconClass(GObject.GPointer): ...

class FileIface(GObject.GPointer):
    """
    :Constructors:

    ::

        FileIface()
    """

    g_iface: GObject.TypeInterface = ...
    dup: typing.Callable[[File], File] = ...
    hash: typing.Callable[[File], int] = ...
    equal: typing.Callable[[File, File], bool] = ...
    is_native: typing.Callable[[File], bool] = ...
    has_uri_scheme: typing.Callable[[File, str], bool] = ...
    get_uri_scheme: typing.Callable[[File], typing.Optional[str]] = ...
    get_basename: typing.Callable[[File], typing.Optional[str]] = ...
    get_path: typing.Callable[[File], typing.Optional[str]] = ...
    get_uri: typing.Callable[[File], str] = ...
    get_parse_name: typing.Callable[[File], str] = ...
    get_parent: typing.Callable[[File], typing.Optional[File]] = ...
    prefix_matches: typing.Callable[[File, File], bool] = ...
    get_relative_path: typing.Callable[[File, File], typing.Optional[str]] = ...
    resolve_relative_path: typing.Callable[[File, str], File] = ...
    get_child_for_display_name: typing.Callable[[File, str], File] = ...
    enumerate_children: typing.Callable[
        [File, str, FileQueryInfoFlags, typing.Optional[Cancellable]], FileEnumerator
    ] = ...
    enumerate_children_async: typing.Callable[..., None] = ...
    enumerate_children_finish: typing.Callable[
        [File, AsyncResult], FileEnumerator
    ] = ...
    query_info: typing.Callable[
        [File, str, FileQueryInfoFlags, typing.Optional[Cancellable]], FileInfo
    ] = ...
    query_info_async: typing.Callable[..., None] = ...
    query_info_finish: typing.Callable[[File, AsyncResult], FileInfo] = ...
    query_filesystem_info: typing.Callable[
        [File, str, typing.Optional[Cancellable]], FileInfo
    ] = ...
    query_filesystem_info_async: typing.Callable[..., None] = ...
    query_filesystem_info_finish: typing.Callable[[File, AsyncResult], FileInfo] = ...
    find_enclosing_mount: typing.Callable[
        [File, typing.Optional[Cancellable]], Mount
    ] = ...
    find_enclosing_mount_async: typing.Callable[..., None] = ...
    find_enclosing_mount_finish: typing.Callable[[File, AsyncResult], Mount] = ...
    set_display_name: typing.Callable[
        [File, str, typing.Optional[Cancellable]], File
    ] = ...
    set_display_name_async: typing.Callable[..., None] = ...
    set_display_name_finish: typing.Callable[[File, AsyncResult], File] = ...
    query_settable_attributes: typing.Callable[
        [File, typing.Optional[Cancellable]], FileAttributeInfoList
    ] = ...
    query_writable_namespaces: typing.Callable[
        [File, typing.Optional[Cancellable]], FileAttributeInfoList
    ] = ...
    set_attribute: typing.Callable[
        [
            File,
            str,
            FileAttributeType,
            None,
            FileQueryInfoFlags,
            typing.Optional[Cancellable],
        ],
        bool,
    ] = ...
    set_attributes_from_info: typing.Callable[
        [File, FileInfo, FileQueryInfoFlags, typing.Optional[Cancellable]], bool
    ] = ...
    set_attributes_async: typing.Callable[..., None] = ...
    set_attributes_finish: typing.Callable[
        [File, AsyncResult], typing.Tuple[bool, FileInfo]
    ] = ...
    read_fn: typing.Callable[
        [File, typing.Optional[Cancellable]], FileInputStream
    ] = ...
    read_async: typing.Callable[..., None] = ...
    read_finish: typing.Callable[[File, AsyncResult], FileInputStream] = ...
    append_to: typing.Callable[
        [File, FileCreateFlags, typing.Optional[Cancellable]], FileOutputStream
    ] = ...
    append_to_async: typing.Callable[..., None] = ...
    append_to_finish: typing.Callable[[File, AsyncResult], FileOutputStream] = ...
    create: typing.Callable[
        [File, FileCreateFlags, typing.Optional[Cancellable]], FileOutputStream
    ] = ...
    create_async: typing.Callable[..., None] = ...
    create_finish: typing.Callable[[File, AsyncResult], FileOutputStream] = ...
    replace: typing.Callable[
        [
            File,
            typing.Optional[str],
            bool,
            FileCreateFlags,
            typing.Optional[Cancellable],
        ],
        FileOutputStream,
    ] = ...
    replace_async: typing.Callable[..., None] = ...
    replace_finish: typing.Callable[[File, AsyncResult], FileOutputStream] = ...
    delete_file: typing.Callable[[File, typing.Optional[Cancellable]], bool] = ...
    delete_file_async: typing.Callable[..., None] = ...
    delete_file_finish: typing.Callable[[File, AsyncResult], bool] = ...
    trash: typing.Callable[[File, typing.Optional[Cancellable]], bool] = ...
    trash_async: typing.Callable[..., None] = ...
    trash_finish: typing.Callable[[File, AsyncResult], bool] = ...
    make_directory: typing.Callable[[File, typing.Optional[Cancellable]], bool] = ...
    make_directory_async: typing.Callable[..., None] = ...
    make_directory_finish: typing.Callable[[File, AsyncResult], bool] = ...
    make_symbolic_link: typing.Callable[
        [File, str, typing.Optional[Cancellable]], bool
    ] = ...
    make_symbolic_link_async: typing.Callable[..., None] = ...
    make_symbolic_link_finish: typing.Callable[[File, AsyncResult], bool] = ...
    copy: typing.Callable[..., bool] = ...
    copy_async: typing.Callable[..., None] = ...
    copy_finish: typing.Callable[[File, AsyncResult], bool] = ...
    move: typing.Callable[..., bool] = ...
    move_async: typing.Callable[..., None] = ...
    move_finish: typing.Callable[[File, AsyncResult], bool] = ...
    mount_mountable: typing.Callable[..., None] = ...
    mount_mountable_finish: typing.Callable[[File, AsyncResult], File] = ...
    unmount_mountable: typing.Callable[..., None] = ...
    unmount_mountable_finish: typing.Callable[[File, AsyncResult], bool] = ...
    eject_mountable: typing.Callable[..., None] = ...
    eject_mountable_finish: typing.Callable[[File, AsyncResult], bool] = ...
    mount_enclosing_volume: typing.Callable[..., None] = ...
    mount_enclosing_volume_finish: typing.Callable[[File, AsyncResult], bool] = ...
    monitor_dir: typing.Callable[
        [File, FileMonitorFlags, typing.Optional[Cancellable]], FileMonitor
    ] = ...
    monitor_file: typing.Callable[
        [File, FileMonitorFlags, typing.Optional[Cancellable]], FileMonitor
    ] = ...
    open_readwrite: typing.Callable[
        [File, typing.Optional[Cancellable]], FileIOStream
    ] = ...
    open_readwrite_async: typing.Callable[..., None] = ...
    open_readwrite_finish: typing.Callable[[File, AsyncResult], FileIOStream] = ...
    create_readwrite: typing.Callable[
        [File, FileCreateFlags, typing.Optional[Cancellable]], FileIOStream
    ] = ...
    create_readwrite_async: typing.Callable[..., None] = ...
    create_readwrite_finish: typing.Callable[[File, AsyncResult], FileIOStream] = ...
    replace_readwrite: typing.Callable[
        [
            File,
            typing.Optional[str],
            bool,
            FileCreateFlags,
            typing.Optional[Cancellable],
        ],
        FileIOStream,
    ] = ...
    replace_readwrite_async: typing.Callable[..., None] = ...
    replace_readwrite_finish: typing.Callable[[File, AsyncResult], FileIOStream] = ...
    start_mountable: typing.Callable[..., None] = ...
    start_mountable_finish: typing.Callable[[File, AsyncResult], bool] = ...
    stop_mountable: typing.Callable[..., None] = ...
    stop_mountable_finish: typing.Callable[[File, AsyncResult], bool] = ...
    supports_thread_contexts: bool = ...
    unmount_mountable_with_operation: typing.Callable[..., None] = ...
    unmount_mountable_with_operation_finish: typing.Callable[
        [File, AsyncResult], bool
    ] = ...
    eject_mountable_with_operation: typing.Callable[..., None] = ...
    eject_mountable_with_operation_finish: typing.Callable[
        [File, AsyncResult], bool
    ] = ...
    poll_mountable: typing.Callable[..., None] = ...
    poll_mountable_finish: typing.Callable[[File, AsyncResult], bool] = ...
    measure_disk_usage: typing.Callable[..., typing.Tuple[bool, int, int, int]] = ...
    measure_disk_usage_async: None = ...
    measure_disk_usage_finish: typing.Callable[
        [File, AsyncResult], typing.Tuple[bool, int, int, int]
    ] = ...
    query_exists: typing.Callable[[File, typing.Optional[Cancellable]], bool] = ...

class FileInfo(GObject.Object):
    """
    :Constructors:

    ::

        FileInfo(**properties)
        new() -> Gio.FileInfo

    Object GFileInfo

    Signals from GObject:
      notify (GParam)
    """
    def clear_status(self) -> None: ...
    def copy_into(self, dest_info: FileInfo) -> None: ...
    def dup(self) -> FileInfo: ...
    def get_access_date_time(self) -> typing.Optional[GLib.DateTime]: ...
    def get_attribute_as_string(self, attribute: str) -> typing.Optional[str]: ...
    def get_attribute_boolean(self, attribute: str) -> bool: ...
    def get_attribute_byte_string(self, attribute: str) -> typing.Optional[str]: ...
    def get_attribute_data(
        self, attribute: str
    ) -> typing.Tuple[bool, FileAttributeType, None, FileAttributeStatus]: ...
    def get_attribute_file_path(self, attribute: str) -> typing.Optional[str]: ...
    def get_attribute_int32(self, attribute: str) -> int: ...
    def get_attribute_int64(self, attribute: str) -> int: ...
    def get_attribute_object(
        self, attribute: str
    ) -> typing.Optional[GObject.Object]: ...
    def get_attribute_status(self, attribute: str) -> FileAttributeStatus: ...
    def get_attribute_string(self, attribute: str) -> typing.Optional[str]: ...
    def get_attribute_stringv(self, attribute: str) -> typing.Optional[list[str]]: ...
    def get_attribute_type(self, attribute: str) -> FileAttributeType: ...
    def get_attribute_uint32(self, attribute: str) -> int: ...
    def get_attribute_uint64(self, attribute: str) -> int: ...
    def get_content_type(self) -> typing.Optional[str]: ...
    def get_creation_date_time(self) -> typing.Optional[GLib.DateTime]: ...
    def get_deletion_date(self) -> typing.Optional[GLib.DateTime]: ...
    def get_display_name(self) -> str: ...
    def get_edit_name(self) -> str: ...
    def get_etag(self) -> typing.Optional[str]: ...
    def get_file_type(self) -> FileType: ...
    def get_icon(self) -> typing.Optional[Icon]: ...
    def get_is_backup(self) -> bool: ...
    def get_is_hidden(self) -> bool: ...
    def get_is_symlink(self) -> bool: ...
    def get_modification_date_time(self) -> typing.Optional[GLib.DateTime]: ...
    def get_modification_time(self) -> GLib.TimeVal: ...
    def get_name(self) -> str: ...
    def get_size(self) -> int: ...
    def get_sort_order(self) -> int: ...
    def get_symbolic_icon(self) -> typing.Optional[Icon]: ...
    def get_symlink_target(self) -> typing.Optional[str]: ...
    def has_attribute(self, attribute: str) -> bool: ...
    def has_namespace(self, name_space: str) -> bool: ...
    def list_attributes(
        self, name_space: typing.Optional[str] = None
    ) -> typing.Optional[list[str]]: ...
    @classmethod
    def new(cls) -> FileInfo: ...
    def remove_attribute(self, attribute: str) -> None: ...
    def set_access_date_time(self, atime: GLib.DateTime) -> None: ...
    def set_attribute(
        self, attribute: str, type: FileAttributeType, value_p: None
    ) -> None: ...
    def set_attribute_boolean(self, attribute: str, attr_value: bool) -> None: ...
    def set_attribute_byte_string(self, attribute: str, attr_value: str) -> None: ...
    def set_attribute_file_path(self, attribute: str, attr_value: str) -> None: ...
    def set_attribute_int32(self, attribute: str, attr_value: int) -> None: ...
    def set_attribute_int64(self, attribute: str, attr_value: int) -> None: ...
    def set_attribute_mask(self, mask: FileAttributeMatcher) -> None: ...
    def set_attribute_object(
        self, attribute: str, attr_value: GObject.Object
    ) -> None: ...
    def set_attribute_status(
        self, attribute: str, status: FileAttributeStatus
    ) -> bool: ...
    def set_attribute_string(self, attribute: str, attr_value: str) -> None: ...
    def set_attribute_stringv(
        self, attribute: str, attr_value: typing.Sequence[str]
    ) -> None: ...
    def set_attribute_uint32(self, attribute: str, attr_value: int) -> None: ...
    def set_attribute_uint64(self, attribute: str, attr_value: int) -> None: ...
    def set_content_type(self, content_type: str) -> None: ...
    def set_creation_date_time(self, creation_time: GLib.DateTime) -> None: ...
    def set_display_name(self, display_name: str) -> None: ...
    def set_edit_name(self, edit_name: str) -> None: ...
    def set_file_type(self, type: FileType) -> None: ...
    def set_icon(self, icon: Icon) -> None: ...
    def set_is_hidden(self, is_hidden: bool) -> None: ...
    def set_is_symlink(self, is_symlink: bool) -> None: ...
    def set_modification_date_time(self, mtime: GLib.DateTime) -> None: ...
    def set_modification_time(self, mtime: GLib.TimeVal) -> None: ...
    def set_name(self, name: str) -> None: ...
    def set_size(self, size: int) -> None: ...
    def set_sort_order(self, sort_order: int) -> None: ...
    def set_symbolic_icon(self, icon: Icon) -> None: ...
    def set_symlink_target(self, symlink_target: str) -> None: ...
    def unset_attribute_mask(self) -> None: ...

class FileInfoClass(GObject.GPointer): ...

class FileInputStream(InputStream, Seekable):
    """
    :Constructors:

    ::

        FileInputStream(**properties)

    Object GFileInputStream

    Signals from GObject:
      notify (GParam)
    """

    parent_instance: InputStream = ...
    priv: FileInputStreamPrivate = ...
    def do_can_seek(self) -> bool: ...
    def do_query_info(
        self, attributes: str, cancellable: typing.Optional[Cancellable] = None
    ) -> FileInfo: ...
    def do_query_info_async(
        self,
        attributes: str,
        io_priority: int,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def do_query_info_finish(self, result: AsyncResult) -> FileInfo: ...
    def do_seek(
        self,
        offset: int,
        type: GLib.SeekType,
        cancellable: typing.Optional[Cancellable] = None,
    ) -> bool: ...
    def do_tell(self) -> int: ...
    def query_info(
        self, attributes: str, cancellable: typing.Optional[Cancellable] = None
    ) -> FileInfo: ...
    def query_info_async(
        self,
        attributes: str,
        io_priority: int,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def query_info_finish(self, result: AsyncResult) -> FileInfo: ...

class FileInputStreamClass(GObject.GPointer):
    """
    :Constructors:

    ::

        FileInputStreamClass()
    """

    parent_class: InputStreamClass = ...
    tell: typing.Callable[[FileInputStream], int] = ...
    can_seek: typing.Callable[[FileInputStream], bool] = ...
    seek: typing.Callable[
        [FileInputStream, int, GLib.SeekType, typing.Optional[Cancellable]], bool
    ] = ...
    query_info: typing.Callable[
        [FileInputStream, str, typing.Optional[Cancellable]], FileInfo
    ] = ...
    query_info_async: typing.Callable[..., None] = ...
    query_info_finish: typing.Callable[[FileInputStream, AsyncResult], FileInfo] = ...

class FileInputStreamPrivate(GObject.GPointer): ...

class FileMonitor(GObject.Object):
    """
    :Constructors:

    ::

        FileMonitor(**properties)

    Object GFileMonitor

    Signals from GFileMonitor:
      changed (GFile, GFile, GFileMonitorEvent)

    Properties from GFileMonitor:
      rate-limit -> gint: rate-limit
      cancelled -> gboolean: cancelled

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        cancelled: bool
        rate_limit: int

    props: Props = ...
    parent_instance: GObject.Object = ...
    priv: FileMonitorPrivate = ...
    def __init__(self, *, rate_limit: int = ...) -> None: ...
    def cancel(self) -> bool: ...
    def do_cancel(self) -> bool: ...
    def do_changed(
        self, file: File, other_file: File, event_type: FileMonitorEvent
    ) -> None: ...
    def emit_event(
        self,
        child: File,
        other_file: typing.Optional[File],
        event_type: FileMonitorEvent,
    ) -> None: ...
    def is_cancelled(self) -> bool: ...
    def set_rate_limit(self, limit_msecs: int) -> None: ...

class FileMonitorClass(GObject.GPointer):
    """
    :Constructors:

    ::

        FileMonitorClass()
    """

    parent_class: GObject.ObjectClass = ...
    changed: typing.Callable[[FileMonitor, File, File, FileMonitorEvent], None] = ...
    cancel: typing.Callable[[FileMonitor], bool] = ...

class FileMonitorPrivate(GObject.GPointer): ...

class FileOutputStream(OutputStream, Seekable):
    """
    :Constructors:

    ::

        FileOutputStream(**properties)

    Object GFileOutputStream

    Signals from GObject:
      notify (GParam)
    """

    parent_instance: OutputStream = ...
    priv: FileOutputStreamPrivate = ...
    def do_can_seek(self) -> bool: ...
    def do_can_truncate(self) -> bool: ...
    def do_get_etag(self) -> typing.Optional[str]: ...
    def do_query_info(
        self, attributes: str, cancellable: typing.Optional[Cancellable] = None
    ) -> FileInfo: ...
    def do_query_info_async(
        self,
        attributes: str,
        io_priority: int,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def do_query_info_finish(self, result: AsyncResult) -> FileInfo: ...
    def do_seek(
        self,
        offset: int,
        type: GLib.SeekType,
        cancellable: typing.Optional[Cancellable] = None,
    ) -> bool: ...
    def do_tell(self) -> int: ...
    def do_truncate_fn(
        self, size: int, cancellable: typing.Optional[Cancellable] = None
    ) -> bool: ...
    def get_etag(self) -> typing.Optional[str]: ...
    def query_info(
        self, attributes: str, cancellable: typing.Optional[Cancellable] = None
    ) -> FileInfo: ...
    def query_info_async(
        self,
        attributes: str,
        io_priority: int,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def query_info_finish(self, result: AsyncResult) -> FileInfo: ...

class FileOutputStreamClass(GObject.GPointer):
    """
    :Constructors:

    ::

        FileOutputStreamClass()
    """

    parent_class: OutputStreamClass = ...
    tell: typing.Callable[[FileOutputStream], int] = ...
    can_seek: typing.Callable[[FileOutputStream], bool] = ...
    seek: typing.Callable[
        [FileOutputStream, int, GLib.SeekType, typing.Optional[Cancellable]], bool
    ] = ...
    can_truncate: typing.Callable[[FileOutputStream], bool] = ...
    truncate_fn: typing.Callable[
        [FileOutputStream, int, typing.Optional[Cancellable]], bool
    ] = ...
    query_info: typing.Callable[
        [FileOutputStream, str, typing.Optional[Cancellable]], FileInfo
    ] = ...
    query_info_async: typing.Callable[..., None] = ...
    query_info_finish: typing.Callable[[FileOutputStream, AsyncResult], FileInfo] = ...
    get_etag: typing.Callable[[FileOutputStream], typing.Optional[str]] = ...

class FileOutputStreamPrivate(GObject.GPointer): ...

class FilenameCompleter(GObject.Object):
    """
    :Constructors:

    ::

        FilenameCompleter(**properties)
        new() -> Gio.FilenameCompleter

    Object GFilenameCompleter

    Signals from GFilenameCompleter:
      got-completion-data ()

    Signals from GObject:
      notify (GParam)
    """
    def do_got_completion_data(self) -> None: ...
    def get_completion_suffix(self, initial_text: str) -> typing.Optional[str]: ...
    def get_completions(self, initial_text: str) -> list[str]: ...
    @classmethod
    def new(cls) -> FilenameCompleter: ...
    def set_dirs_only(self, dirs_only: bool) -> None: ...

class FilenameCompleterClass(GObject.GPointer):
    """
    :Constructors:

    ::

        FilenameCompleterClass()
    """

    parent_class: GObject.ObjectClass = ...
    got_completion_data: typing.Callable[[FilenameCompleter], None] = ...

class FilterInputStream(InputStream):
    """
    :Constructors:

    ::

        FilterInputStream(**properties)

    Object GFilterInputStream

    Properties from GFilterInputStream:
      base-stream -> GInputStream: base-stream
      close-base-stream -> gboolean: close-base-stream

    Signals from GObject:
      notify (GParam)
    """
    class Props(InputStream.Props):
        base_stream: InputStream
        close_base_stream: bool

    props: Props = ...
    parent_instance: InputStream = ...
    base_stream: InputStream = ...
    def __init__(
        self, *, base_stream: InputStream = ..., close_base_stream: bool = ...
    ) -> None: ...
    def get_base_stream(self) -> InputStream: ...
    def get_close_base_stream(self) -> bool: ...
    def set_close_base_stream(self, close_base: bool) -> None: ...

class FilterInputStreamClass(GObject.GPointer):
    """
    :Constructors:

    ::

        FilterInputStreamClass()
    """

    parent_class: InputStreamClass = ...

class FilterOutputStream(OutputStream):
    """
    :Constructors:

    ::

        FilterOutputStream(**properties)

    Object GFilterOutputStream

    Properties from GFilterOutputStream:
      base-stream -> GOutputStream: base-stream
      close-base-stream -> gboolean: close-base-stream

    Signals from GObject:
      notify (GParam)
    """
    class Props(OutputStream.Props):
        base_stream: OutputStream
        close_base_stream: bool

    props: Props = ...
    parent_instance: OutputStream = ...
    base_stream: OutputStream = ...
    def __init__(
        self, *, base_stream: OutputStream = ..., close_base_stream: bool = ...
    ) -> None: ...
    def get_base_stream(self) -> OutputStream: ...
    def get_close_base_stream(self) -> bool: ...
    def set_close_base_stream(self, close_base: bool) -> None: ...

class FilterOutputStreamClass(GObject.GPointer):
    """
    :Constructors:

    ::

        FilterOutputStreamClass()
    """

    parent_class: OutputStreamClass = ...

class IOExtension(GObject.GPointer):
    def get_name(self) -> str: ...
    def get_priority(self) -> int: ...
    def get_type(self) -> typing.Type[typing.Any]: ...

class IOExtensionPoint(GObject.GPointer):
    def get_extension_by_name(self, name: str) -> IOExtension: ...
    def get_extensions(self) -> list[IOExtension]: ...
    def get_required_type(self) -> typing.Type[typing.Any]: ...
    @staticmethod
    def implement(
        extension_point_name: str,
        type: typing.Type[typing.Any],
        extension_name: str,
        priority: int,
    ) -> IOExtension: ...
    @staticmethod
    def lookup(name: str) -> IOExtensionPoint: ...
    @staticmethod
    def register(name: str) -> IOExtensionPoint: ...
    def set_required_type(self, type: typing.Type[typing.Any]) -> None: ...

class IOModule(GObject.TypeModule, GObject.TypePlugin):
    """
    :Constructors:

    ::

        IOModule(**properties)
        new(filename:str) -> Gio.IOModule

    Object GIOModule

    Signals from GObject:
      notify (GParam)
    """
    @classmethod
    def new(cls, filename: str) -> IOModule: ...
    @staticmethod
    def query() -> list[str]: ...

class IOModuleClass(GObject.GPointer): ...

class IOModuleScope(GObject.GPointer):
    def block(self, basename: str) -> None: ...
    def free(self) -> None: ...

class IOSchedulerJob(GObject.GPointer):
    def send_to_mainloop(
        self, func: typing.Callable[..., bool], *user_data: typing.Any
    ) -> bool: ...
    def send_to_mainloop_async(
        self, func: typing.Callable[..., bool], *user_data: typing.Any
    ) -> None: ...

class IOStream(GObject.Object):
    """
    :Constructors:

    ::

        IOStream(**properties)

    Object GIOStream

    Properties from GIOStream:
      input-stream -> GInputStream: input-stream
      output-stream -> GOutputStream: output-stream
      closed -> gboolean: closed

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        closed: bool
        input_stream: InputStream
        output_stream: OutputStream

    props: Props = ...
    parent_instance: GObject.Object = ...
    priv: IOStreamPrivate = ...
    def clear_pending(self) -> None: ...
    def close(self, cancellable: typing.Optional[Cancellable] = None) -> bool: ...
    def close_async(
        self,
        io_priority: int,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def close_finish(self, result: AsyncResult) -> bool: ...
    def do_close_async(
        self,
        io_priority: int,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def do_close_finish(self, result: AsyncResult) -> bool: ...
    def do_close_fn(self, cancellable: typing.Optional[Cancellable] = None) -> bool: ...
    def do_get_input_stream(self) -> InputStream: ...
    def do_get_output_stream(self) -> OutputStream: ...
    def get_input_stream(self) -> InputStream: ...
    def get_output_stream(self) -> OutputStream: ...
    def has_pending(self) -> bool: ...
    def is_closed(self) -> bool: ...
    def set_pending(self) -> bool: ...
    def splice_async(
        self,
        stream2: IOStream,
        flags: IOStreamSpliceFlags,
        io_priority: int,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    @staticmethod
    def splice_finish(result: AsyncResult) -> bool: ...

class IOStreamAdapter(GObject.GPointer): ...

class IOStreamClass(GObject.GPointer):
    """
    :Constructors:

    ::

        IOStreamClass()
    """

    parent_class: GObject.ObjectClass = ...
    get_input_stream: typing.Callable[[IOStream], InputStream] = ...
    get_output_stream: typing.Callable[[IOStream], OutputStream] = ...
    close_fn: typing.Callable[[IOStream, typing.Optional[Cancellable]], bool] = ...
    close_async: typing.Callable[..., None] = ...
    close_finish: typing.Callable[[IOStream, AsyncResult], bool] = ...

class IOStreamPrivate(GObject.GPointer): ...

class Icon(GObject.GInterface):
    """
    Interface GIcon

    Signals from GObject:
      notify (GParam)
    """
    @staticmethod
    def deserialize(value: GLib.Variant) -> typing.Optional[Icon]: ...
    def equal(self, icon2: typing.Optional[Icon] = None) -> bool: ...
    def hash(self) -> int: ...
    @staticmethod
    def new_for_string(str: str) -> Icon: ...
    def serialize(self) -> typing.Optional[GLib.Variant]: ...
    def to_string(self) -> typing.Optional[str]: ...

class IconIface(GObject.GPointer):
    """
    :Constructors:

    ::

        IconIface()
    """

    g_iface: GObject.TypeInterface = ...
    hash: typing.Callable[[Icon], int] = ...
    equal: typing.Callable[[typing.Optional[Icon], typing.Optional[Icon]], bool] = ...
    to_tokens: typing.Callable[[Icon], typing.Tuple[bool, list[str], int]] = ...
    from_tokens: None = ...
    serialize: typing.Callable[[Icon], typing.Optional[GLib.Variant]] = ...

class InetAddress(GObject.Object):
    """
    :Constructors:

    ::

        InetAddress(**properties)
        new_any(family:Gio.SocketFamily) -> Gio.InetAddress
        new_from_bytes(bytes:list, family:Gio.SocketFamily) -> Gio.InetAddress
        new_from_bytes_with_ipv6_info(bytes:list, family:Gio.SocketFamily, flowinfo:int, scope_id:int) -> Gio.InetAddress
        new_from_string(string:str) -> Gio.InetAddress or None
        new_loopback(family:Gio.SocketFamily) -> Gio.InetAddress

    Object GInetAddress

    Properties from GInetAddress:
      family -> GSocketFamily: family
      bytes -> gpointer: bytes
      is-any -> gboolean: is-any
      is-loopback -> gboolean: is-loopback
      is-link-local -> gboolean: is-link-local
      is-site-local -> gboolean: is-site-local
      is-multicast -> gboolean: is-multicast
      is-mc-global -> gboolean: is-mc-global
      is-mc-link-local -> gboolean: is-mc-link-local
      is-mc-node-local -> gboolean: is-mc-node-local
      is-mc-org-local -> gboolean: is-mc-org-local
      is-mc-site-local -> gboolean: is-mc-site-local
      flowinfo -> guint: flowinfo
      scope-id -> guint: scope-id

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        bytes: None
        family: SocketFamily
        flowinfo: int
        is_any: bool
        is_link_local: bool
        is_loopback: bool
        is_mc_global: bool
        is_mc_link_local: bool
        is_mc_node_local: bool
        is_mc_org_local: bool
        is_mc_site_local: bool
        is_multicast: bool
        is_site_local: bool
        scope_id: int

    props: Props = ...
    parent_instance: GObject.Object = ...
    priv: InetAddressPrivate = ...
    def __init__(
        self,
        *,
        bytes: None = ...,
        family: SocketFamily = ...,
        flowinfo: int = ...,
        scope_id: int = ...,
    ) -> None: ...
    def do_to_string(self) -> str: ...
    def equal(self, other_address: InetAddress) -> bool: ...
    def get_family(self) -> SocketFamily: ...
    def get_flowinfo(self) -> int: ...
    def get_is_any(self) -> bool: ...
    def get_is_link_local(self) -> bool: ...
    def get_is_loopback(self) -> bool: ...
    def get_is_mc_global(self) -> bool: ...
    def get_is_mc_link_local(self) -> bool: ...
    def get_is_mc_node_local(self) -> bool: ...
    def get_is_mc_org_local(self) -> bool: ...
    def get_is_mc_site_local(self) -> bool: ...
    def get_is_multicast(self) -> bool: ...
    def get_is_site_local(self) -> bool: ...
    def get_native_size(self) -> int: ...
    def get_scope_id(self) -> int: ...
    @classmethod
    def new_any(cls, family: SocketFamily) -> InetAddress: ...
    @classmethod
    def new_from_bytes(
        cls, bytes: typing.Sequence[int], family: SocketFamily
    ) -> InetAddress: ...
    @classmethod
    def new_from_bytes_with_ipv6_info(
        cls,
        bytes: typing.Sequence[int],
        family: SocketFamily,
        flowinfo: int,
        scope_id: int,
    ) -> InetAddress: ...
    @classmethod
    def new_from_string(cls, string: str) -> typing.Optional[InetAddress]: ...
    @classmethod
    def new_loopback(cls, family: SocketFamily) -> InetAddress: ...
    def to_string(self) -> str: ...

class InetAddressClass(GObject.GPointer):
    """
    :Constructors:

    ::

        InetAddressClass()
    """

    parent_class: GObject.ObjectClass = ...
    to_string: typing.Callable[[InetAddress], str] = ...
    to_bytes: typing.Callable[[InetAddress], int] = ...

class InetAddressMask(GObject.Object, Initable):
    """
    :Constructors:

    ::

        InetAddressMask(**properties)
        new(addr:Gio.InetAddress, length:int) -> Gio.InetAddressMask
        new_from_string(mask_string:str) -> Gio.InetAddressMask

    Object GInetAddressMask

    Properties from GInetAddressMask:
      family -> GSocketFamily: family
      address -> GInetAddress: address
      length -> guint: length

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        address: InetAddress
        family: SocketFamily
        length: int

    props: Props = ...
    parent_instance: GObject.Object = ...
    priv: InetAddressMaskPrivate = ...
    def __init__(self, *, address: InetAddress = ..., length: int = ...) -> None: ...
    def equal(self, mask2: InetAddressMask) -> bool: ...
    def get_address(self) -> InetAddress: ...
    def get_family(self) -> SocketFamily: ...
    def get_length(self) -> int: ...
    def matches(self, address: InetAddress) -> bool: ...
    @classmethod
    def new(cls, addr: InetAddress, length: int) -> InetAddressMask: ...
    @classmethod
    def new_from_string(cls, mask_string: str) -> InetAddressMask: ...
    def to_string(self) -> str: ...

class InetAddressMaskClass(GObject.GPointer):
    """
    :Constructors:

    ::

        InetAddressMaskClass()
    """

    parent_class: GObject.ObjectClass = ...

class InetAddressMaskPrivate(GObject.GPointer): ...
class InetAddressPrivate(GObject.GPointer): ...

class InetSocketAddress(SocketAddress, SocketConnectable):
    """
    :Constructors:

    ::

        InetSocketAddress(**properties)
        new(address:Gio.InetAddress, port:int) -> Gio.SocketAddress
        new_from_string(address:str, port:int) -> Gio.SocketAddress or None

    Object GInetSocketAddress

    Properties from GInetSocketAddress:
      address -> GInetAddress: address
      port -> guint: port
      flowinfo -> guint: flowinfo
      scope-id -> guint: scope-id

    Properties from GSocketAddress:
      family -> GSocketFamily: family

    Signals from GObject:
      notify (GParam)
    """
    class Props(SocketAddress.Props):
        address: InetAddress
        flowinfo: int
        port: int
        scope_id: int
        family: SocketFamily

    props: Props = ...
    parent_instance: SocketAddress = ...
    priv: InetSocketAddressPrivate = ...
    def __init__(
        self,
        *,
        address: InetAddress = ...,
        flowinfo: int = ...,
        port: int = ...,
        scope_id: int = ...,
    ) -> None: ...
    def get_address(self) -> InetAddress: ...
    def get_flowinfo(self) -> int: ...
    def get_port(self) -> int: ...
    def get_scope_id(self) -> int: ...
    @classmethod
    def new(cls, address: InetAddress, port: int) -> InetSocketAddress: ...
    @classmethod
    def new_from_string(cls, address: str, port: int) -> InetSocketAddress: ...

class InetSocketAddressClass(GObject.GPointer):
    """
    :Constructors:

    ::

        InetSocketAddressClass()
    """

    parent_class: SocketAddressClass = ...

class InetSocketAddressPrivate(GObject.GPointer): ...

class Initable(GObject.GInterface):
    """
    Interface GInitable

    Signals from GObject:
      notify (GParam)
    """
    def init(self, cancellable: typing.Optional[Cancellable] = None) -> bool: ...
    @staticmethod
    def newv(
        object_type: typing.Type[typing.Any],
        parameters: typing.Sequence[GObject.Parameter],
        cancellable: typing.Optional[Cancellable] = None,
    ) -> GObject.Object: ...

class InitableIface(GObject.GPointer):
    """
    :Constructors:

    ::

        InitableIface()
    """

    g_iface: GObject.TypeInterface = ...
    init: typing.Callable[[Initable, typing.Optional[Cancellable]], bool] = ...

class InputMessage(GObject.GPointer):
    """
    :Constructors:

    ::

        InputMessage()
    """

    address: SocketAddress = ...
    vectors: list[InputVector] = ...
    num_vectors: int = ...
    bytes_received: int = ...
    flags: int = ...
    control_messages: list[SocketControlMessage] = ...
    num_control_messages: int = ...

class InputStream(GObject.Object):
    """
    :Constructors:

    ::

        InputStream(**properties)

    Object GInputStream

    Signals from GObject:
      notify (GParam)
    """

    parent_instance: GObject.Object = ...
    priv: InputStreamPrivate = ...
    def clear_pending(self) -> None: ...
    def close(self, cancellable: typing.Optional[Cancellable] = None) -> bool: ...
    def close_async(
        self,
        io_priority: int,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def close_finish(self, result: AsyncResult) -> bool: ...
    def do_close_async(
        self,
        io_priority: int,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def do_close_finish(self, result: AsyncResult) -> bool: ...
    def do_close_fn(self, cancellable: typing.Optional[Cancellable] = None) -> bool: ...
    def do_read_async(
        self,
        io_priority: int,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> bytes: ...
    def do_read_finish(self, result: AsyncResult) -> int: ...
    def do_read_fn(
        self, buffer: None, count: int, cancellable: typing.Optional[Cancellable] = None
    ) -> int: ...
    def do_skip(
        self, count: int, cancellable: typing.Optional[Cancellable] = None
    ) -> int: ...
    def do_skip_async(
        self,
        count: int,
        io_priority: int,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def do_skip_finish(self, result: AsyncResult) -> int: ...
    def has_pending(self) -> bool: ...
    def is_closed(self) -> bool: ...
    def read(
        self, cancellable: typing.Optional[Cancellable] = None
    ) -> typing.Tuple[int, bytes]: ...
    def read_all(
        self, cancellable: typing.Optional[Cancellable] = None
    ) -> typing.Tuple[bool, bytes, int]: ...
    def read_all_async(
        self,
        io_priority: int,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> bytes: ...
    def read_all_finish(self, result: AsyncResult) -> typing.Tuple[bool, int]: ...
    def read_async(
        self,
        io_priority: int,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> bytes: ...
    def read_bytes(
        self, count: int, cancellable: typing.Optional[Cancellable] = None
    ) -> GLib.Bytes: ...
    def read_bytes_async(
        self,
        count: int,
        io_priority: int,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def read_bytes_finish(self, result: AsyncResult) -> GLib.Bytes: ...
    def read_finish(self, result: AsyncResult) -> int: ...
    def set_pending(self) -> bool: ...
    def skip(
        self, count: int, cancellable: typing.Optional[Cancellable] = None
    ) -> int: ...
    def skip_async(
        self,
        count: int,
        io_priority: int,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def skip_finish(self, result: AsyncResult) -> int: ...

class InputStreamClass(GObject.GPointer):
    """
    :Constructors:

    ::

        InputStreamClass()
    """

    parent_class: GObject.ObjectClass = ...
    read_fn: typing.Callable[
        [InputStream, None, int, typing.Optional[Cancellable]], int
    ] = ...
    skip: typing.Callable[[InputStream, int, typing.Optional[Cancellable]], int] = ...
    close_fn: typing.Callable[[InputStream, typing.Optional[Cancellable]], bool] = ...
    read_async: typing.Callable[..., bytes] = ...
    read_finish: typing.Callable[[InputStream, AsyncResult], int] = ...
    skip_async: typing.Callable[..., None] = ...
    skip_finish: typing.Callable[[InputStream, AsyncResult], int] = ...
    close_async: typing.Callable[..., None] = ...
    close_finish: typing.Callable[[InputStream, AsyncResult], bool] = ...

class InputStreamPrivate(GObject.GPointer): ...

class InputVector(GObject.GPointer):
    """
    :Constructors:

    ::

        InputVector()
    """

    buffer: None = ...
    size: int = ...

# override
class ListModel(GObject.GInterface, typing.Generic[ObjectItemType]):
    """
    Interface GListModel

    Signals from GObject:
      notify (GParam)
    """

    @typing.overload
    def __getitem__(self, key: slice) -> list[ObjectItemType]: ...
    @typing.overload
    def __getitem__(self, key: int) -> ObjectItemType: ...
    def __contains__(self, item: ObjectItemType) -> bool: ...
    def __iter__(self) -> typing.Iterator[ObjectItemType]: ...
    def __len__(self) -> int: ...
    def get_item(self, position: int) -> typing.Optional[ObjectItemType]: ...
    def get_item_type(self) -> typing.Type[ObjectItemType]: ...
    def get_n_items(self) -> int: ...
    def items_changed(self, position: int, removed: int, added: int) -> None: ...

class ListModelInterface(GObject.GPointer):
    """
    :Constructors:

    ::

        ListModelInterface()
    """

    g_iface: GObject.TypeInterface = ...
    get_item_type: typing.Callable[[ListModel], typing.Type[typing.Any]] = ...
    get_n_items: typing.Callable[[ListModel], int] = ...
    get_item: typing.Callable[[ListModel, int], typing.Optional[GObject.Object]] = ...

# override
class ListStore(
    GObject.Object, ListModel[ObjectItemType], typing.Generic[ObjectItemType]
):
    """
    :Constructors:

    ::

        ListStore(**properties)
        new(item_type:GType) -> Gio.ListStore

    Object GListStore

    Properties from GListStore:
      item-type -> GType: item-type
      n-items -> guint: n-items

    Signals from GListModel:
      items-changed (guint, guint, guint)

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        item_type: typing.Type[ObjectItemType]
        n_items: int

    props: Props = ...
    def __init__(self, *, item_type: typing.Type[ObjectItemType] = ...) -> None: ...
    def __delitem__(self, key: typing.Union[int, slice]) -> None: ...
    @typing.overload
    def __setitem__(
        self, key: slice, value: typing.Sequence[ObjectItemType]
    ) -> None: ...
    @typing.overload
    def __setitem__(self, key: int, value: ObjectItemType) -> None: ...
    def append(self, item: ObjectItemType) -> None: ...
    def find(self, item: ObjectItemType) -> typing.Tuple[bool, int]: ...
    def find_with_equal_func(
        self,
        item: ObjectItemType,
        equal_func: typing.Callable[
            [typing.Optional[ObjectItemType], typing.Optional[ObjectItemType]], bool
        ],
        *user_data: typing.Any,
    ) -> typing.Tuple[bool, int]: ...
    def find_with_equal_func_full(
        self,
        item: ObjectItemType,
        equal_func: typing.Callable[
            [
                typing.Optional[ObjectItemType],
                typing.Optional[ObjectItemType],
                typing.Any,
            ],
            bool,
        ],
        *user_data: typing.Any,
    ) -> typing.Tuple[bool, int]: ...
    def insert(self, position: int, item: ObjectItemType) -> None: ...
    def insert_sorted(
        self,
        item: ObjectItemType,
        compare_func: typing.Callable[
            [ObjectItemType, ObjectItemType, typing.Any], int
        ],
        *user_data: typing.Any,
    ) -> None: ...
    @classmethod
    def new(
        cls, item_type: typing.Type[ObjectItemType]
    ) -> ListStore[ObjectItemType]: ...
    def remove(self, position: int) -> None: ...
    def remove_all(self) -> None: ...
    def sort(
        self, compare_func: typing.Callable[..., int], *user_data: typing.Any
    ) -> None: ...
    def splice(
        self, position: int, n_removals: int, additions: typing.Sequence[ObjectItemType]
    ) -> None: ...

class ListStoreClass(GObject.GPointer):
    """
    :Constructors:

    ::

        ListStoreClass()
    """

    parent_class: GObject.ObjectClass = ...

class LoadableIcon(GObject.GInterface):
    """
    Interface GLoadableIcon

    Signals from GObject:
      notify (GParam)
    """
    def load(
        self, size: int, cancellable: typing.Optional[Cancellable] = None
    ) -> typing.Tuple[InputStream, str]: ...
    def load_async(
        self,
        size: int,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def load_finish(self, res: AsyncResult) -> typing.Tuple[InputStream, str]: ...

class LoadableIconIface(GObject.GPointer):
    """
    :Constructors:

    ::

        LoadableIconIface()
    """

    g_iface: GObject.TypeInterface = ...
    load: typing.Callable[
        [LoadableIcon, int, typing.Optional[Cancellable]],
        typing.Tuple[InputStream, str],
    ] = ...
    load_async: typing.Callable[..., None] = ...
    load_finish: typing.Callable[
        [LoadableIcon, AsyncResult], typing.Tuple[InputStream, str]
    ] = ...

class MemoryInputStream(InputStream, PollableInputStream, Seekable):
    """
    :Constructors:

    ::

        MemoryInputStream(**properties)
        new() -> Gio.InputStream
        new_from_bytes(bytes:GLib.Bytes) -> Gio.InputStream
        new_from_data(data:list, destroy:GLib.DestroyNotify=None) -> Gio.InputStream

    Object GMemoryInputStream

    Signals from GObject:
      notify (GParam)
    """

    parent_instance: InputStream = ...
    priv: MemoryInputStreamPrivate = ...
    def add_bytes(self, bytes: GLib.Bytes) -> None: ...
    def add_data(
        self,
        data: typing.Sequence[int],
        destroy: typing.Optional[typing.Callable[[None], None]] = None,
    ) -> None: ...
    @classmethod
    def new(cls) -> MemoryInputStream: ...
    @classmethod
    def new_from_bytes(cls, bytes: GLib.Bytes) -> MemoryInputStream: ...
    @classmethod
    def new_from_data(
        cls,
        data: typing.Sequence[int],
        destroy: typing.Optional[typing.Callable[[None], None]] = None,
    ) -> MemoryInputStream: ...

class MemoryInputStreamClass(GObject.GPointer):
    """
    :Constructors:

    ::

        MemoryInputStreamClass()
    """

    parent_class: InputStreamClass = ...

class MemoryInputStreamPrivate(GObject.GPointer): ...

class MemoryMonitor(GObject.GInterface):
    """
    Interface GMemoryMonitor

    Signals from GObject:
      notify (GParam)
    """
    @staticmethod
    def dup_default() -> MemoryMonitor: ...

class MemoryMonitorInterface(GObject.GPointer):
    """
    :Constructors:

    ::

        MemoryMonitorInterface()
    """

    g_iface: GObject.TypeInterface = ...
    low_memory_warning: typing.Callable[
        [MemoryMonitor, MemoryMonitorWarningLevel], None
    ] = ...

class MemoryOutputStream(OutputStream, PollableOutputStream, Seekable):
    """
    :Constructors:

    ::

        MemoryOutputStream(**properties)
        new_resizable() -> Gio.OutputStream

    Object GMemoryOutputStream

    Properties from GMemoryOutputStream:
      data -> gpointer: data
      size -> gulong: size
      data-size -> gulong: data-size
      realloc-function -> gpointer: realloc-function
      destroy-function -> gpointer: destroy-function

    Signals from GObject:
      notify (GParam)
    """
    class Props(OutputStream.Props):
        data: typing.Optional[None]
        data_size: int
        size: int

    props: Props = ...
    parent_instance: OutputStream = ...
    priv: MemoryOutputStreamPrivate = ...
    def __init__(self, *, data: None = ..., size: int = ...) -> None: ...
    def get_data(self) -> None: ...
    def get_data_size(self) -> int: ...
    def get_size(self) -> int: ...
    @classmethod
    def new_resizable(cls) -> MemoryOutputStream: ...
    def steal_as_bytes(self) -> GLib.Bytes: ...
    def steal_data(self) -> None: ...

class MemoryOutputStreamClass(GObject.GPointer):
    """
    :Constructors:

    ::

        MemoryOutputStreamClass()
    """

    parent_class: OutputStreamClass = ...

class MemoryOutputStreamPrivate(GObject.GPointer): ...

class Menu(MenuModel):
    """
    :Constructors:

    ::

        Menu(**properties)
        new() -> Gio.Menu

    Object GMenu

    Signals from GMenuModel:
      items-changed (gint, gint, gint)

    Signals from GObject:
      notify (GParam)
    """
    def append(
        self,
        label: typing.Optional[str] = None,
        detailed_action: typing.Optional[str] = None,
    ) -> None: ...
    def append_item(self, item: MenuItem) -> None: ...
    def append_section(
        self, label: typing.Optional[str], section: MenuModel
    ) -> None: ...
    def append_submenu(
        self, label: typing.Optional[str], submenu: MenuModel
    ) -> None: ...
    def freeze(self) -> None: ...
    def insert(
        self,
        position: int,
        label: typing.Optional[str] = None,
        detailed_action: typing.Optional[str] = None,
    ) -> None: ...
    def insert_item(self, position: int, item: MenuItem) -> None: ...
    def insert_section(
        self, position: int, label: typing.Optional[str], section: MenuModel
    ) -> None: ...
    def insert_submenu(
        self, position: int, label: typing.Optional[str], submenu: MenuModel
    ) -> None: ...
    @classmethod
    def new(cls) -> Menu: ...
    def prepend(
        self,
        label: typing.Optional[str] = None,
        detailed_action: typing.Optional[str] = None,
    ) -> None: ...
    def prepend_item(self, item: MenuItem) -> None: ...
    def prepend_section(
        self, label: typing.Optional[str], section: MenuModel
    ) -> None: ...
    def prepend_submenu(
        self, label: typing.Optional[str], submenu: MenuModel
    ) -> None: ...
    def remove(self, position: int) -> None: ...
    def remove_all(self) -> None: ...

class MenuAttributeIter(GObject.Object):
    """
    :Constructors:

    ::

        MenuAttributeIter(**properties)

    Object GMenuAttributeIter

    Signals from GObject:
      notify (GParam)
    """

    parent_instance: GObject.Object = ...
    priv: MenuAttributeIterPrivate = ...
    def do_get_next(self) -> typing.Tuple[bool, str, GLib.Variant]: ...
    def get_name(self) -> str: ...
    def get_next(self) -> typing.Tuple[bool, str, GLib.Variant]: ...
    def get_value(self) -> GLib.Variant: ...
    def next(self) -> bool: ...

class MenuAttributeIterClass(GObject.GPointer):
    """
    :Constructors:

    ::

        MenuAttributeIterClass()
    """

    parent_class: GObject.ObjectClass = ...
    get_next: typing.Callable[
        [MenuAttributeIter], typing.Tuple[bool, str, GLib.Variant]
    ] = ...

class MenuAttributeIterPrivate(GObject.GPointer): ...

class MenuItem(GObject.Object):
    """
    :Constructors:

    ::

        MenuItem(**properties)
        new(label:str=None, detailed_action:str=None) -> Gio.MenuItem
        new_from_model(model:Gio.MenuModel, item_index:int) -> Gio.MenuItem
        new_section(label:str=None, section:Gio.MenuModel) -> Gio.MenuItem
        new_submenu(label:str=None, submenu:Gio.MenuModel) -> Gio.MenuItem

    Object GMenuItem

    Signals from GObject:
      notify (GParam)
    """
    def get_attribute_value(
        self, attribute: str, expected_type: typing.Optional[GLib.VariantType] = None
    ) -> typing.Optional[GLib.Variant]: ...
    def get_link(self, link: str) -> typing.Optional[MenuModel]: ...
    @classmethod
    def new(
        cls,
        label: typing.Optional[str] = None,
        detailed_action: typing.Optional[str] = None,
    ) -> MenuItem: ...
    @classmethod
    def new_from_model(cls, model: MenuModel, item_index: int) -> MenuItem: ...
    @classmethod
    def new_section(
        cls, label: typing.Optional[str], section: MenuModel
    ) -> MenuItem: ...
    @classmethod
    def new_submenu(
        cls, label: typing.Optional[str], submenu: MenuModel
    ) -> MenuItem: ...
    def set_action_and_target_value(
        self,
        action: typing.Optional[str] = None,
        target_value: typing.Optional[GLib.Variant] = None,
    ) -> None: ...
    # override
    def set_attribute(
        self, attributes: list[typing.Tuple[str, str, typing.Any]]
    ) -> None: ...
    def set_attribute_value(
        self, attribute: str, value: typing.Optional[GLib.Variant] = None
    ) -> None: ...
    def set_detailed_action(self, detailed_action: str) -> None: ...
    def set_icon(self, icon: Icon) -> None: ...
    def set_label(self, label: typing.Optional[str] = None) -> None: ...
    def set_link(self, link: str, model: typing.Optional[MenuModel] = None) -> None: ...
    def set_section(self, section: typing.Optional[MenuModel] = None) -> None: ...
    def set_submenu(self, submenu: typing.Optional[MenuModel] = None) -> None: ...

class MenuLinkIter(GObject.Object):
    """
    :Constructors:

    ::

        MenuLinkIter(**properties)

    Object GMenuLinkIter

    Signals from GObject:
      notify (GParam)
    """

    parent_instance: GObject.Object = ...
    priv: MenuLinkIterPrivate = ...
    def do_get_next(self) -> typing.Tuple[bool, str, MenuModel]: ...
    def get_name(self) -> str: ...
    def get_next(self) -> typing.Tuple[bool, str, MenuModel]: ...
    def get_value(self) -> MenuModel: ...
    def next(self) -> bool: ...

class MenuLinkIterClass(GObject.GPointer):
    """
    :Constructors:

    ::

        MenuLinkIterClass()
    """

    parent_class: GObject.ObjectClass = ...
    get_next: typing.Callable[[MenuLinkIter], typing.Tuple[bool, str, MenuModel]] = ...

class MenuLinkIterPrivate(GObject.GPointer): ...

class MenuModel(GObject.Object):
    """
    :Constructors:

    ::

        MenuModel(**properties)

    Object GMenuModel

    Signals from GMenuModel:
      items-changed (gint, gint, gint)

    Signals from GObject:
      notify (GParam)
    """

    parent_instance: GObject.Object = ...
    priv: MenuModelPrivate = ...
    def do_get_item_attribute_value(
        self,
        item_index: int,
        attribute: str,
        expected_type: typing.Optional[GLib.VariantType] = None,
    ) -> typing.Optional[GLib.Variant]: ...
    def do_get_item_attributes(self, item_index: int) -> dict[str, GLib.Variant]: ...
    def do_get_item_link(
        self, item_index: int, link: str
    ) -> typing.Optional[MenuModel]: ...
    def do_get_item_links(self, item_index: int) -> dict[str, MenuModel]: ...
    def do_get_n_items(self) -> int: ...
    def do_is_mutable(self) -> bool: ...
    def do_iterate_item_attributes(self, item_index: int) -> MenuAttributeIter: ...
    def do_iterate_item_links(self, item_index: int) -> MenuLinkIter: ...
    def get_item_attribute_value(
        self,
        item_index: int,
        attribute: str,
        expected_type: typing.Optional[GLib.VariantType] = None,
    ) -> typing.Optional[GLib.Variant]: ...
    def get_item_link(
        self, item_index: int, link: str
    ) -> typing.Optional[MenuModel]: ...
    def get_n_items(self) -> int: ...
    def is_mutable(self) -> bool: ...
    def items_changed(self, position: int, removed: int, added: int) -> None: ...
    def iterate_item_attributes(self, item_index: int) -> MenuAttributeIter: ...
    def iterate_item_links(self, item_index: int) -> MenuLinkIter: ...

class MenuModelClass(GObject.GPointer):
    """
    :Constructors:

    ::

        MenuModelClass()
    """

    parent_class: GObject.ObjectClass = ...
    is_mutable: typing.Callable[[MenuModel], bool] = ...
    get_n_items: typing.Callable[[MenuModel], int] = ...
    get_item_attributes: typing.Callable[
        [MenuModel, int], dict[str, GLib.Variant]
    ] = ...
    iterate_item_attributes: typing.Callable[[MenuModel, int], MenuAttributeIter] = ...
    get_item_attribute_value: typing.Callable[
        [MenuModel, int, str, typing.Optional[GLib.VariantType]],
        typing.Optional[GLib.Variant],
    ] = ...
    get_item_links: typing.Callable[[MenuModel, int], dict[str, MenuModel]] = ...
    iterate_item_links: typing.Callable[[MenuModel, int], MenuLinkIter] = ...
    get_item_link: typing.Callable[
        [MenuModel, int, str], typing.Optional[MenuModel]
    ] = ...

class MenuModelPrivate(GObject.GPointer): ...

class Mount(GObject.GInterface):
    """
    Interface GMount

    Signals from GObject:
      notify (GParam)
    """
    def can_eject(self) -> bool: ...
    def can_unmount(self) -> bool: ...
    def eject(
        self,
        flags: MountUnmountFlags,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def eject_finish(self, result: AsyncResult) -> bool: ...
    def eject_with_operation(
        self,
        flags: MountUnmountFlags,
        mount_operation: typing.Optional[MountOperation] = None,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def eject_with_operation_finish(self, result: AsyncResult) -> bool: ...
    def get_default_location(self) -> File: ...
    def get_drive(self) -> typing.Optional[Drive]: ...
    def get_icon(self) -> Icon: ...
    def get_name(self) -> str: ...
    def get_root(self) -> File: ...
    def get_sort_key(self) -> typing.Optional[str]: ...
    def get_symbolic_icon(self) -> Icon: ...
    def get_uuid(self) -> typing.Optional[str]: ...
    def get_volume(self) -> typing.Optional[Volume]: ...
    def guess_content_type(
        self,
        force_rescan: bool,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def guess_content_type_finish(self, result: AsyncResult) -> list[str]: ...
    def guess_content_type_sync(
        self, force_rescan: bool, cancellable: typing.Optional[Cancellable] = None
    ) -> list[str]: ...
    def is_shadowed(self) -> bool: ...
    def remount(
        self,
        flags: MountMountFlags,
        mount_operation: typing.Optional[MountOperation] = None,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def remount_finish(self, result: AsyncResult) -> bool: ...
    def shadow(self) -> None: ...
    def unmount(
        self,
        flags: MountUnmountFlags,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def unmount_finish(self, result: AsyncResult) -> bool: ...
    def unmount_with_operation(
        self,
        flags: MountUnmountFlags,
        mount_operation: typing.Optional[MountOperation] = None,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def unmount_with_operation_finish(self, result: AsyncResult) -> bool: ...
    def unshadow(self) -> None: ...

class MountIface(GObject.GPointer):
    """
    :Constructors:

    ::

        MountIface()
    """

    g_iface: GObject.TypeInterface = ...
    changed: typing.Callable[[Mount], None] = ...
    unmounted: typing.Callable[[Mount], None] = ...
    get_root: typing.Callable[[Mount], File] = ...
    get_name: typing.Callable[[Mount], str] = ...
    get_icon: typing.Callable[[Mount], Icon] = ...
    get_uuid: typing.Callable[[Mount], typing.Optional[str]] = ...
    get_volume: typing.Callable[[Mount], typing.Optional[Volume]] = ...
    get_drive: typing.Callable[[Mount], typing.Optional[Drive]] = ...
    can_unmount: typing.Callable[[Mount], bool] = ...
    can_eject: typing.Callable[[Mount], bool] = ...
    unmount: typing.Callable[..., None] = ...
    unmount_finish: typing.Callable[[Mount, AsyncResult], bool] = ...
    eject: typing.Callable[..., None] = ...
    eject_finish: typing.Callable[[Mount, AsyncResult], bool] = ...
    remount: typing.Callable[..., None] = ...
    remount_finish: typing.Callable[[Mount, AsyncResult], bool] = ...
    guess_content_type: typing.Callable[..., None] = ...
    guess_content_type_finish: typing.Callable[[Mount, AsyncResult], list[str]] = ...
    guess_content_type_sync: typing.Callable[
        [Mount, bool, typing.Optional[Cancellable]], list[str]
    ] = ...
    pre_unmount: typing.Callable[[Mount], None] = ...
    unmount_with_operation: typing.Callable[..., None] = ...
    unmount_with_operation_finish: typing.Callable[[Mount, AsyncResult], bool] = ...
    eject_with_operation: typing.Callable[..., None] = ...
    eject_with_operation_finish: typing.Callable[[Mount, AsyncResult], bool] = ...
    get_default_location: typing.Callable[[Mount], File] = ...
    get_sort_key: typing.Callable[[Mount], typing.Optional[str]] = ...
    get_symbolic_icon: typing.Callable[[Mount], Icon] = ...

class MountOperation(GObject.Object):
    """
    :Constructors:

    ::

        MountOperation(**properties)
        new() -> Gio.MountOperation

    Object GMountOperation

    Signals from GMountOperation:
      ask-password (gchararray, gchararray, gchararray, GAskPasswordFlags)
      ask-question (gchararray, GStrv)
      reply (GMountOperationResult)
      aborted ()
      show-processes (gchararray, GArray, GStrv)
      show-unmount-progress (gchararray, gint64, gint64)

    Properties from GMountOperation:
      username -> gchararray: username
      password -> gchararray: password
      anonymous -> gboolean: anonymous
      domain -> gchararray: domain
      password-save -> GPasswordSave: password-save
      choice -> gint: choice
      is-tcrypt-hidden-volume -> gboolean: is-tcrypt-hidden-volume
      is-tcrypt-system-volume -> gboolean: is-tcrypt-system-volume
      pim -> guint: pim

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        anonymous: bool
        choice: int
        domain: typing.Optional[str]
        is_tcrypt_hidden_volume: bool
        is_tcrypt_system_volume: bool
        password: typing.Optional[str]
        password_save: PasswordSave
        pim: int
        username: typing.Optional[str]

    props: Props = ...
    parent_instance: GObject.Object = ...
    priv: MountOperationPrivate = ...
    def __init__(
        self,
        *,
        anonymous: bool = ...,
        choice: int = ...,
        domain: typing.Optional[str] = ...,
        is_tcrypt_hidden_volume: bool = ...,
        is_tcrypt_system_volume: bool = ...,
        password: typing.Optional[str] = ...,
        password_save: PasswordSave = ...,
        pim: int = ...,
        username: typing.Optional[str] = ...,
    ) -> None: ...
    def do_aborted(self) -> None: ...
    def do_ask_password(
        self,
        message: str,
        default_user: str,
        default_domain: str,
        flags: AskPasswordFlags,
    ) -> None: ...
    def do_ask_question(self, message: str, choices: typing.Sequence[str]) -> None: ...
    def do_reply(self, result: MountOperationResult) -> None: ...
    def do_show_processes(
        self,
        message: str,
        processes: typing.Sequence[int],
        choices: typing.Sequence[str],
    ) -> None: ...
    def do_show_unmount_progress(
        self, message: str, time_left: int, bytes_left: int
    ) -> None: ...
    def get_anonymous(self) -> bool: ...
    def get_choice(self) -> int: ...
    def get_domain(self) -> typing.Optional[str]: ...
    def get_is_tcrypt_hidden_volume(self) -> bool: ...
    def get_is_tcrypt_system_volume(self) -> bool: ...
    def get_password(self) -> typing.Optional[str]: ...
    def get_password_save(self) -> PasswordSave: ...
    def get_pim(self) -> int: ...
    def get_username(self) -> typing.Optional[str]: ...
    @classmethod
    def new(cls) -> MountOperation: ...
    def reply(self, result: MountOperationResult) -> None: ...
    def set_anonymous(self, anonymous: bool) -> None: ...
    def set_choice(self, choice: int) -> None: ...
    def set_domain(self, domain: typing.Optional[str] = None) -> None: ...
    def set_is_tcrypt_hidden_volume(self, hidden_volume: bool) -> None: ...
    def set_is_tcrypt_system_volume(self, system_volume: bool) -> None: ...
    def set_password(self, password: typing.Optional[str] = None) -> None: ...
    def set_password_save(self, save: PasswordSave) -> None: ...
    def set_pim(self, pim: int) -> None: ...
    def set_username(self, username: typing.Optional[str] = None) -> None: ...

class MountOperationClass(GObject.GPointer):
    """
    :Constructors:

    ::

        MountOperationClass()
    """

    parent_class: GObject.ObjectClass = ...
    ask_password: typing.Callable[
        [MountOperation, str, str, str, AskPasswordFlags], None
    ] = ...
    ask_question: typing.Callable[
        [MountOperation, str, typing.Sequence[str]], None
    ] = ...
    reply: typing.Callable[[MountOperation, MountOperationResult], None] = ...
    aborted: typing.Callable[[MountOperation], None] = ...
    show_processes: typing.Callable[
        [MountOperation, str, typing.Sequence[int], typing.Sequence[str]], None
    ] = ...
    show_unmount_progress: typing.Callable[[MountOperation, str, int, int], None] = ...

class MountOperationPrivate(GObject.GPointer): ...

class NativeSocketAddress(SocketAddress, SocketConnectable):
    """
    :Constructors:

    ::

        NativeSocketAddress(**properties)
        new(native=None, len:int) -> Gio.SocketAddress

    Object GNativeSocketAddress

    Properties from GSocketAddress:
      family -> GSocketFamily: family

    Signals from GObject:
      notify (GParam)
    """
    class Props(SocketAddress.Props):
        family: SocketFamily

    props: Props = ...
    parent_instance: SocketAddress = ...
    priv: NativeSocketAddressPrivate = ...
    @classmethod
    def new(cls, native: None, len: int) -> NativeSocketAddress: ...

class NativeSocketAddressClass(GObject.GPointer):
    """
    :Constructors:

    ::

        NativeSocketAddressClass()
    """

    parent_class: SocketAddressClass = ...

class NativeSocketAddressPrivate(GObject.GPointer): ...

class NativeVolumeMonitor(VolumeMonitor):
    """
    :Constructors:

    ::

        NativeVolumeMonitor(**properties)

    Object GNativeVolumeMonitor

    Signals from GVolumeMonitor:
      volume-added (GVolume)
      volume-removed (GVolume)
      volume-changed (GVolume)
      mount-added (GMount)
      mount-removed (GMount)
      mount-pre-unmount (GMount)
      mount-changed (GMount)
      drive-connected (GDrive)
      drive-disconnected (GDrive)
      drive-changed (GDrive)
      drive-eject-button (GDrive)
      drive-stop-button (GDrive)

    Signals from GObject:
      notify (GParam)
    """

    parent_instance: VolumeMonitor = ...

class NativeVolumeMonitorClass(GObject.GPointer):
    """
    :Constructors:

    ::

        NativeVolumeMonitorClass()
    """

    parent_class: VolumeMonitorClass = ...
    get_mount_for_mount_path: None = ...

class NetworkAddress(GObject.Object, SocketConnectable):
    """
    :Constructors:

    ::

        NetworkAddress(**properties)
        new(hostname:str, port:int) -> Gio.NetworkAddress
        new_loopback(port:int) -> Gio.NetworkAddress

    Object GNetworkAddress

    Properties from GNetworkAddress:
      hostname -> gchararray: hostname
      port -> guint: port
      scheme -> gchararray: scheme

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        hostname: str
        port: int
        scheme: typing.Optional[str]

    props: Props = ...
    parent_instance: GObject.Object = ...
    priv: NetworkAddressPrivate = ...
    def __init__(
        self, *, hostname: str = ..., port: int = ..., scheme: str = ...
    ) -> None: ...
    def get_hostname(self) -> str: ...
    def get_port(self) -> int: ...
    def get_scheme(self) -> typing.Optional[str]: ...
    @classmethod
    def new(cls, hostname: str, port: int) -> NetworkAddress: ...
    @classmethod
    def new_loopback(cls, port: int) -> NetworkAddress: ...
    @staticmethod
    def parse(host_and_port: str, default_port: int) -> NetworkAddress: ...
    @staticmethod
    def parse_uri(uri: str, default_port: int) -> NetworkAddress: ...

class NetworkAddressClass(GObject.GPointer):
    """
    :Constructors:

    ::

        NetworkAddressClass()
    """

    parent_class: GObject.ObjectClass = ...

class NetworkAddressPrivate(GObject.GPointer): ...

class NetworkMonitor(GObject.GInterface):
    """
    Interface GNetworkMonitor

    Signals from GObject:
      notify (GParam)
    """
    def can_reach(
        self,
        connectable: SocketConnectable,
        cancellable: typing.Optional[Cancellable] = None,
    ) -> bool: ...
    def can_reach_async(
        self,
        connectable: SocketConnectable,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def can_reach_finish(self, result: AsyncResult) -> bool: ...
    def get_connectivity(self) -> NetworkConnectivity: ...
    @staticmethod
    def get_default() -> NetworkMonitor: ...
    def get_network_available(self) -> bool: ...
    def get_network_metered(self) -> bool: ...

class NetworkMonitorInterface(GObject.GPointer):
    """
    :Constructors:

    ::

        NetworkMonitorInterface()
    """

    g_iface: GObject.TypeInterface = ...
    network_changed: typing.Callable[[NetworkMonitor, bool], None] = ...
    can_reach: typing.Callable[
        [NetworkMonitor, SocketConnectable, typing.Optional[Cancellable]], bool
    ] = ...
    can_reach_async: typing.Callable[..., None] = ...
    can_reach_finish: typing.Callable[[NetworkMonitor, AsyncResult], bool] = ...

class NetworkService(GObject.Object, SocketConnectable):
    """
    :Constructors:

    ::

        NetworkService(**properties)
        new(service:str, protocol:str, domain:str) -> Gio.NetworkService

    Object GNetworkService

    Properties from GNetworkService:
      service -> gchararray: service
      protocol -> gchararray: protocol
      domain -> gchararray: domain
      scheme -> gchararray: scheme

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        domain: str
        protocol: str
        scheme: str
        service: str

    props: Props = ...
    parent_instance: GObject.Object = ...
    priv: NetworkServicePrivate = ...
    def __init__(
        self,
        *,
        domain: str = ...,
        protocol: str = ...,
        scheme: str = ...,
        service: str = ...,
    ) -> None: ...
    def get_domain(self) -> str: ...
    def get_protocol(self) -> str: ...
    def get_scheme(self) -> str: ...
    def get_service(self) -> str: ...
    @classmethod
    def new(cls, service: str, protocol: str, domain: str) -> NetworkService: ...
    def set_scheme(self, scheme: str) -> None: ...

class NetworkServiceClass(GObject.GPointer):
    """
    :Constructors:

    ::

        NetworkServiceClass()
    """

    parent_class: GObject.ObjectClass = ...

class NetworkServicePrivate(GObject.GPointer): ...

class Notification(GObject.Object):
    """
    :Constructors:

    ::

        Notification(**properties)
        new(title:str) -> Gio.Notification

    Object GNotification

    Signals from GObject:
      notify (GParam)
    """
    def add_button(self, label: str, detailed_action: str) -> None: ...
    def add_button_with_target(
        self, label: str, action: str, target: typing.Optional[GLib.Variant] = None
    ) -> None: ...
    @classmethod
    def new(cls, title: str) -> Notification: ...
    def set_body(self, body: typing.Optional[str] = None) -> None: ...
    def set_category(self, category: typing.Optional[str] = None) -> None: ...
    def set_default_action(self, detailed_action: str) -> None: ...
    def set_default_action_and_target(
        self, action: str, target: typing.Optional[GLib.Variant] = None
    ) -> None: ...
    def set_icon(self, icon: Icon) -> None: ...
    def set_priority(self, priority: NotificationPriority) -> None: ...
    def set_title(self, title: str) -> None: ...
    def set_urgent(self, urgent: bool) -> None: ...

class OutputMessage(GObject.GPointer):
    """
    :Constructors:

    ::

        OutputMessage()
    """

    address: SocketAddress = ...
    vectors: OutputVector = ...
    num_vectors: int = ...
    bytes_sent: int = ...
    control_messages: list[SocketControlMessage] = ...
    num_control_messages: int = ...

class OutputStream(GObject.Object):
    """
    :Constructors:

    ::

        OutputStream(**properties)

    Object GOutputStream

    Signals from GObject:
      notify (GParam)
    """

    parent_instance: GObject.Object = ...
    priv: OutputStreamPrivate = ...
    def clear_pending(self) -> None: ...
    def close(self, cancellable: typing.Optional[Cancellable] = None) -> bool: ...
    def close_async(
        self,
        io_priority: int,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def close_finish(self, result: AsyncResult) -> bool: ...
    def do_close_async(
        self,
        io_priority: int,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def do_close_finish(self, result: AsyncResult) -> bool: ...
    def do_close_fn(self, cancellable: typing.Optional[Cancellable] = None) -> bool: ...
    def do_flush(self, cancellable: typing.Optional[Cancellable] = None) -> bool: ...
    def do_flush_async(
        self,
        io_priority: int,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def do_flush_finish(self, result: AsyncResult) -> bool: ...
    def do_splice(
        self,
        source: InputStream,
        flags: OutputStreamSpliceFlags,
        cancellable: typing.Optional[Cancellable] = None,
    ) -> int: ...
    def do_splice_async(
        self,
        source: InputStream,
        flags: OutputStreamSpliceFlags,
        io_priority: int,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def do_splice_finish(self, result: AsyncResult) -> int: ...
    def do_write_async(
        self,
        buffer: typing.Optional[typing.Sequence[int]],
        io_priority: int,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def do_write_finish(self, result: AsyncResult) -> int: ...
    def do_write_fn(
        self,
        buffer: typing.Optional[typing.Sequence[int]] = None,
        cancellable: typing.Optional[Cancellable] = None,
    ) -> int: ...
    def do_writev_async(
        self,
        vectors: typing.Sequence[OutputVector],
        io_priority: int,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def do_writev_finish(self, result: AsyncResult) -> typing.Tuple[bool, int]: ...
    def do_writev_fn(
        self,
        vectors: typing.Sequence[OutputVector],
        cancellable: typing.Optional[Cancellable] = None,
    ) -> typing.Tuple[bool, int]: ...
    def flush(self, cancellable: typing.Optional[Cancellable] = None) -> bool: ...
    def flush_async(
        self,
        io_priority: int,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def flush_finish(self, result: AsyncResult) -> bool: ...
    def has_pending(self) -> bool: ...
    def is_closed(self) -> bool: ...
    def is_closing(self) -> bool: ...
    def set_pending(self) -> bool: ...
    def splice(
        self,
        source: InputStream,
        flags: OutputStreamSpliceFlags,
        cancellable: typing.Optional[Cancellable] = None,
    ) -> int: ...
    def splice_async(
        self,
        source: InputStream,
        flags: OutputStreamSpliceFlags,
        io_priority: int,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def splice_finish(self, result: AsyncResult) -> int: ...
    def write(
        self,
        buffer: typing.Sequence[int],
        cancellable: typing.Optional[Cancellable] = None,
    ) -> int: ...
    def write_all(
        self,
        buffer: typing.Sequence[int],
        cancellable: typing.Optional[Cancellable] = None,
    ) -> typing.Tuple[bool, int]: ...
    def write_all_async(
        self,
        buffer: typing.Sequence[int],
        io_priority: int,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def write_all_finish(self, result: AsyncResult) -> typing.Tuple[bool, int]: ...
    def write_async(
        self,
        buffer: typing.Sequence[int],
        io_priority: int,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def write_bytes(
        self, bytes: GLib.Bytes, cancellable: typing.Optional[Cancellable] = None
    ) -> int: ...
    def write_bytes_async(
        self,
        bytes: GLib.Bytes,
        io_priority: int,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def write_bytes_finish(self, result: AsyncResult) -> int: ...
    def write_finish(self, result: AsyncResult) -> int: ...
    def writev(
        self,
        vectors: typing.Sequence[OutputVector],
        cancellable: typing.Optional[Cancellable] = None,
    ) -> typing.Tuple[bool, int]: ...
    def writev_all(
        self,
        vectors: typing.Sequence[OutputVector],
        cancellable: typing.Optional[Cancellable] = None,
    ) -> typing.Tuple[bool, int]: ...
    def writev_all_async(
        self,
        vectors: typing.Sequence[OutputVector],
        io_priority: int,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def writev_all_finish(self, result: AsyncResult) -> typing.Tuple[bool, int]: ...
    def writev_async(
        self,
        vectors: typing.Sequence[OutputVector],
        io_priority: int,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def writev_finish(self, result: AsyncResult) -> typing.Tuple[bool, int]: ...

class OutputStreamClass(GObject.GPointer):
    """
    :Constructors:

    ::

        OutputStreamClass()
    """

    parent_class: GObject.ObjectClass = ...
    write_fn: typing.Callable[
        [
            OutputStream,
            typing.Optional[typing.Sequence[int]],
            typing.Optional[Cancellable],
        ],
        int,
    ] = ...
    splice: typing.Callable[
        [
            OutputStream,
            InputStream,
            OutputStreamSpliceFlags,
            typing.Optional[Cancellable],
        ],
        int,
    ] = ...
    flush: typing.Callable[[OutputStream, typing.Optional[Cancellable]], bool] = ...
    close_fn: typing.Callable[[OutputStream, typing.Optional[Cancellable]], bool] = ...
    write_async: typing.Callable[..., None] = ...
    write_finish: typing.Callable[[OutputStream, AsyncResult], int] = ...
    splice_async: typing.Callable[..., None] = ...
    splice_finish: typing.Callable[[OutputStream, AsyncResult], int] = ...
    flush_async: typing.Callable[..., None] = ...
    flush_finish: typing.Callable[[OutputStream, AsyncResult], bool] = ...
    close_async: typing.Callable[..., None] = ...
    close_finish: typing.Callable[[OutputStream, AsyncResult], bool] = ...
    writev_fn: typing.Callable[
        [OutputStream, typing.Sequence[OutputVector], typing.Optional[Cancellable]],
        typing.Tuple[bool, int],
    ] = ...
    writev_async: typing.Callable[..., None] = ...
    writev_finish: typing.Callable[
        [OutputStream, AsyncResult], typing.Tuple[bool, int]
    ] = ...

class OutputStreamPrivate(GObject.GPointer): ...

class OutputVector(GObject.GPointer):
    """
    :Constructors:

    ::

        OutputVector()
    """

    buffer: None = ...
    size: int = ...

class Permission(GObject.Object):
    """
    :Constructors:

    ::

        Permission(**properties)

    Object GPermission

    Properties from GPermission:
      allowed -> gboolean: allowed
      can-acquire -> gboolean: can-acquire
      can-release -> gboolean: can-release

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        allowed: bool
        can_acquire: bool
        can_release: bool

    props: Props = ...
    parent_instance: GObject.Object = ...
    priv: PermissionPrivate = ...
    def acquire(self, cancellable: typing.Optional[Cancellable] = None) -> bool: ...
    def acquire_async(
        self,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def acquire_finish(self, result: AsyncResult) -> bool: ...
    def do_acquire(self, cancellable: typing.Optional[Cancellable] = None) -> bool: ...
    def do_acquire_async(
        self,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def do_acquire_finish(self, result: AsyncResult) -> bool: ...
    def do_release(self, cancellable: typing.Optional[Cancellable] = None) -> bool: ...
    def do_release_async(
        self,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def do_release_finish(self, result: AsyncResult) -> bool: ...
    def get_allowed(self) -> bool: ...
    def get_can_acquire(self) -> bool: ...
    def get_can_release(self) -> bool: ...
    def impl_update(
        self, allowed: bool, can_acquire: bool, can_release: bool
    ) -> None: ...
    def release(self, cancellable: typing.Optional[Cancellable] = None) -> bool: ...
    def release_async(
        self,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def release_finish(self, result: AsyncResult) -> bool: ...

class PermissionClass(GObject.GPointer):
    """
    :Constructors:

    ::

        PermissionClass()
    """

    parent_class: GObject.ObjectClass = ...
    acquire: typing.Callable[[Permission, typing.Optional[Cancellable]], bool] = ...
    acquire_async: typing.Callable[..., None] = ...
    acquire_finish: typing.Callable[[Permission, AsyncResult], bool] = ...
    release: typing.Callable[[Permission, typing.Optional[Cancellable]], bool] = ...
    release_async: typing.Callable[..., None] = ...
    release_finish: typing.Callable[[Permission, AsyncResult], bool] = ...
    reserved: list[None] = ...

class PermissionPrivate(GObject.GPointer): ...

class PollableInputStream(GObject.GInterface):
    """
    Interface GPollableInputStream

    Signals from GObject:
      notify (GParam)
    """
    def can_poll(self) -> bool: ...
    def create_source(
        self, cancellable: typing.Optional[Cancellable] = None
    ) -> GLib.Source: ...
    def is_readable(self) -> bool: ...
    def read_nonblocking(
        self, cancellable: typing.Optional[Cancellable] = None
    ) -> typing.Tuple[int, bytes]: ...

class PollableInputStreamInterface(GObject.GPointer):
    """
    :Constructors:

    ::

        PollableInputStreamInterface()
    """

    g_iface: GObject.TypeInterface = ...
    can_poll: typing.Callable[[PollableInputStream], bool] = ...
    is_readable: typing.Callable[[PollableInputStream], bool] = ...
    create_source: typing.Callable[
        [PollableInputStream, typing.Optional[Cancellable]], GLib.Source
    ] = ...
    read_nonblocking: typing.Callable[
        [PollableInputStream], typing.Tuple[int, bytes]
    ] = ...

class PollableOutputStream(GObject.GInterface):
    """
    Interface GPollableOutputStream

    Signals from GObject:
      notify (GParam)
    """
    def can_poll(self) -> bool: ...
    def create_source(
        self, cancellable: typing.Optional[Cancellable] = None
    ) -> GLib.Source: ...
    def is_writable(self) -> bool: ...
    def write_nonblocking(
        self,
        buffer: typing.Sequence[int],
        cancellable: typing.Optional[Cancellable] = None,
    ) -> int: ...
    def writev_nonblocking(
        self,
        vectors: typing.Sequence[OutputVector],
        cancellable: typing.Optional[Cancellable] = None,
    ) -> typing.Tuple[PollableReturn, int]: ...

class PollableOutputStreamInterface(GObject.GPointer):
    """
    :Constructors:

    ::

        PollableOutputStreamInterface()
    """

    g_iface: GObject.TypeInterface = ...
    can_poll: typing.Callable[[PollableOutputStream], bool] = ...
    is_writable: typing.Callable[[PollableOutputStream], bool] = ...
    create_source: typing.Callable[
        [PollableOutputStream, typing.Optional[Cancellable]], GLib.Source
    ] = ...
    write_nonblocking: typing.Callable[
        [PollableOutputStream, typing.Optional[typing.Sequence[int]]], int
    ] = ...
    writev_nonblocking: typing.Callable[
        [PollableOutputStream, typing.Sequence[OutputVector]],
        typing.Tuple[PollableReturn, int],
    ] = ...

class PowerProfileMonitor(GObject.GInterface):
    """
    Interface GPowerProfileMonitor

    Signals from GObject:
      notify (GParam)
    """
    @staticmethod
    def dup_default() -> PowerProfileMonitor: ...
    def get_power_saver_enabled(self) -> bool: ...

class PowerProfileMonitorInterface(GObject.GPointer):
    """
    :Constructors:

    ::

        PowerProfileMonitorInterface()
    """

    g_iface: GObject.TypeInterface = ...

class PropertyAction(GObject.Object, Action):
    """
    :Constructors:

    ::

        PropertyAction(**properties)
        new(name:str, object:GObject.Object, property_name:str) -> Gio.PropertyAction

    Object GPropertyAction

    Properties from GPropertyAction:
      name -> gchararray: name
      parameter-type -> GVariantType: parameter-type
      enabled -> gboolean: enabled
      state-type -> GVariantType: state-type
      state -> GVariant: state
      object -> GObject: object
      property-name -> gchararray: property-name
      invert-boolean -> gboolean: invert-boolean

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        enabled: bool
        invert_boolean: bool
        name: str
        parameter_type: GLib.VariantType
        state: GLib.Variant
        state_type: GLib.VariantType
        object: GObject.Object
        property_name: str

    props: Props = ...
    def __init__(
        self,
        *,
        invert_boolean: bool = ...,
        name: str = ...,
        object: GObject.Object = ...,
        property_name: str = ...,
    ) -> None: ...
    @classmethod
    def new(
        cls, name: str, object: GObject.Object, property_name: str
    ) -> PropertyAction: ...

class Proxy(GObject.GInterface):
    """
    Interface GProxy

    Signals from GObject:
      notify (GParam)
    """
    def connect(
        self,
        connection: IOStream,
        proxy_address: ProxyAddress,
        cancellable: typing.Optional[Cancellable] = None,
    ) -> IOStream: ...
    def connect_async(
        self,
        connection: IOStream,
        proxy_address: ProxyAddress,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def connect_finish(self, result: AsyncResult) -> IOStream: ...
    @staticmethod
    def get_default_for_protocol(protocol: str) -> typing.Optional[Proxy]: ...
    def supports_hostname(self) -> bool: ...

class ProxyAddress(InetSocketAddress, SocketConnectable):
    """
    :Constructors:

    ::

        ProxyAddress(**properties)
        new(inetaddr:Gio.InetAddress, port:int, protocol:str, dest_hostname:str, dest_port:int, username:str=None, password:str=None) -> Gio.SocketAddress

    Object GProxyAddress

    Properties from GProxyAddress:
      protocol -> gchararray: protocol
      destination-protocol -> gchararray: destination-protocol
      destination-hostname -> gchararray: destination-hostname
      destination-port -> guint: destination-port
      username -> gchararray: username
      password -> gchararray: password
      uri -> gchararray: uri

    Properties from GInetSocketAddress:
      address -> GInetAddress: address
      port -> guint: port
      flowinfo -> guint: flowinfo
      scope-id -> guint: scope-id

    Properties from GSocketAddress:
      family -> GSocketFamily: family

    Signals from GObject:
      notify (GParam)
    """
    class Props(InetSocketAddress.Props):
        destination_hostname: str
        destination_port: int
        destination_protocol: str
        password: typing.Optional[str]
        protocol: str
        uri: typing.Optional[str]
        username: typing.Optional[str]
        address: InetAddress
        flowinfo: int
        port: int
        scope_id: int
        family: SocketFamily

    props: Props = ...
    parent_instance: InetSocketAddress = ...
    priv: ProxyAddressPrivate = ...
    def __init__(
        self,
        *,
        destination_hostname: str = ...,
        destination_port: int = ...,
        destination_protocol: str = ...,
        password: str = ...,
        protocol: str = ...,
        uri: str = ...,
        username: str = ...,
        address: InetAddress = ...,
        flowinfo: int = ...,
        port: int = ...,
        scope_id: int = ...,
    ) -> None: ...
    def get_destination_hostname(self) -> str: ...
    def get_destination_port(self) -> int: ...
    def get_destination_protocol(self) -> str: ...
    def get_password(self) -> typing.Optional[str]: ...
    def get_protocol(self) -> str: ...
    def get_uri(self) -> typing.Optional[str]: ...
    def get_username(self) -> typing.Optional[str]: ...
    @classmethod
    def new(
        cls,
        inetaddr: InetAddress,
        port: int,
        protocol: str,
        dest_hostname: str,
        dest_port: int,
        username: typing.Optional[str] = None,
        password: typing.Optional[str] = None,
    ) -> ProxyAddress: ...

class ProxyAddressClass(GObject.GPointer):
    """
    :Constructors:

    ::

        ProxyAddressClass()
    """

    parent_class: InetSocketAddressClass = ...

class ProxyAddressEnumerator(SocketAddressEnumerator):
    """
    :Constructors:

    ::

        ProxyAddressEnumerator(**properties)

    Object GProxyAddressEnumerator

    Properties from GProxyAddressEnumerator:
      uri -> gchararray: uri
      default-port -> guint: default-port
      connectable -> GSocketConnectable: connectable
      proxy-resolver -> GProxyResolver: proxy-resolver

    Signals from GObject:
      notify (GParam)
    """
    class Props(SocketAddressEnumerator.Props):
        connectable: SocketConnectable
        default_port: int
        proxy_resolver: ProxyResolver
        uri: str

    props: Props = ...
    parent_instance: SocketAddressEnumerator = ...
    priv: ProxyAddressEnumeratorPrivate = ...
    def __init__(
        self,
        *,
        connectable: SocketConnectable = ...,
        default_port: int = ...,
        proxy_resolver: ProxyResolver = ...,
        uri: str = ...,
    ) -> None: ...

class ProxyAddressEnumeratorClass(GObject.GPointer):
    """
    :Constructors:

    ::

        ProxyAddressEnumeratorClass()
    """

    parent_class: SocketAddressEnumeratorClass = ...

class ProxyAddressEnumeratorPrivate(GObject.GPointer): ...
class ProxyAddressPrivate(GObject.GPointer): ...

class ProxyInterface(GObject.GPointer):
    """
    :Constructors:

    ::

        ProxyInterface()
    """

    g_iface: GObject.TypeInterface = ...
    connect: typing.Callable[
        [Proxy, IOStream, ProxyAddress, typing.Optional[Cancellable]], IOStream
    ] = ...
    connect_async: typing.Callable[..., None] = ...
    connect_finish: typing.Callable[[Proxy, AsyncResult], IOStream] = ...
    supports_hostname: typing.Callable[[Proxy], bool] = ...

class ProxyResolver(GObject.GInterface):
    """
    Interface GProxyResolver

    Signals from GObject:
      notify (GParam)
    """
    @staticmethod
    def get_default() -> ProxyResolver: ...
    def is_supported(self) -> bool: ...
    def lookup(
        self, uri: str, cancellable: typing.Optional[Cancellable] = None
    ) -> list[str]: ...
    def lookup_async(
        self,
        uri: str,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def lookup_finish(self, result: AsyncResult) -> list[str]: ...

class ProxyResolverInterface(GObject.GPointer):
    """
    :Constructors:

    ::

        ProxyResolverInterface()
    """

    g_iface: GObject.TypeInterface = ...
    is_supported: typing.Callable[[ProxyResolver], bool] = ...
    lookup: typing.Callable[
        [ProxyResolver, str, typing.Optional[Cancellable]], list[str]
    ] = ...
    lookup_async: typing.Callable[..., None] = ...
    lookup_finish: typing.Callable[[ProxyResolver, AsyncResult], list[str]] = ...

class RemoteActionGroup(GObject.GInterface):
    """
    Interface GRemoteActionGroup

    Signals from GObject:
      notify (GParam)
    """
    def activate_action_full(
        self,
        action_name: str,
        parameter: typing.Optional[GLib.Variant],
        platform_data: GLib.Variant,
    ) -> None: ...
    def change_action_state_full(
        self, action_name: str, value: GLib.Variant, platform_data: GLib.Variant
    ) -> None: ...

class RemoteActionGroupInterface(GObject.GPointer):
    """
    :Constructors:

    ::

        RemoteActionGroupInterface()
    """

    g_iface: GObject.TypeInterface = ...
    activate_action_full: typing.Callable[
        [RemoteActionGroup, str, typing.Optional[GLib.Variant], GLib.Variant], None
    ] = ...
    change_action_state_full: typing.Callable[
        [RemoteActionGroup, str, GLib.Variant, GLib.Variant], None
    ] = ...

class Resolver(GObject.Object):
    """
    :Constructors:

    ::

        Resolver(**properties)

    Object GResolver

    Signals from GResolver:
      reload ()

    Properties from GResolver:
      timeout -> guint: timeout

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        timeout: int

    props: Props = ...
    parent_instance: GObject.Object = ...
    priv: ResolverPrivate = ...
    def __init__(self, *, timeout: int = ...) -> None: ...
    def do_lookup_by_address(
        self, address: InetAddress, cancellable: typing.Optional[Cancellable] = None
    ) -> str: ...
    def do_lookup_by_address_async(
        self,
        address: InetAddress,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def do_lookup_by_address_finish(self, result: AsyncResult) -> str: ...
    def do_lookup_by_name(
        self, hostname: str, cancellable: typing.Optional[Cancellable] = None
    ) -> list[InetAddress]: ...
    def do_lookup_by_name_async(
        self,
        hostname: str,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def do_lookup_by_name_finish(self, result: AsyncResult) -> list[InetAddress]: ...
    def do_lookup_by_name_with_flags(
        self,
        hostname: str,
        flags: ResolverNameLookupFlags,
        cancellable: typing.Optional[Cancellable] = None,
    ) -> list[InetAddress]: ...
    def do_lookup_by_name_with_flags_async(
        self,
        hostname: str,
        flags: ResolverNameLookupFlags,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def do_lookup_by_name_with_flags_finish(
        self, result: AsyncResult
    ) -> list[InetAddress]: ...
    def do_lookup_records(
        self,
        rrname: str,
        record_type: ResolverRecordType,
        cancellable: typing.Optional[Cancellable] = None,
    ) -> list[GLib.Variant]: ...
    def do_lookup_records_async(
        self,
        rrname: str,
        record_type: ResolverRecordType,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def do_lookup_records_finish(self, result: AsyncResult) -> list[GLib.Variant]: ...
    def do_lookup_service_async(
        self,
        rrname: str,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def do_lookup_service_finish(self, result: AsyncResult) -> list[SrvTarget]: ...
    def do_reload(self) -> None: ...
    @staticmethod
    def get_default() -> Resolver: ...
    def get_timeout(self) -> int: ...
    def lookup_by_address(
        self, address: InetAddress, cancellable: typing.Optional[Cancellable] = None
    ) -> str: ...
    def lookup_by_address_async(
        self,
        address: InetAddress,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def lookup_by_address_finish(self, result: AsyncResult) -> str: ...
    def lookup_by_name(
        self, hostname: str, cancellable: typing.Optional[Cancellable] = None
    ) -> list[InetAddress]: ...
    def lookup_by_name_async(
        self,
        hostname: str,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def lookup_by_name_finish(self, result: AsyncResult) -> list[InetAddress]: ...
    def lookup_by_name_with_flags(
        self,
        hostname: str,
        flags: ResolverNameLookupFlags,
        cancellable: typing.Optional[Cancellable] = None,
    ) -> list[InetAddress]: ...
    def lookup_by_name_with_flags_async(
        self,
        hostname: str,
        flags: ResolverNameLookupFlags,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def lookup_by_name_with_flags_finish(
        self, result: AsyncResult
    ) -> list[InetAddress]: ...
    def lookup_records(
        self,
        rrname: str,
        record_type: ResolverRecordType,
        cancellable: typing.Optional[Cancellable] = None,
    ) -> list[GLib.Variant]: ...
    def lookup_records_async(
        self,
        rrname: str,
        record_type: ResolverRecordType,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def lookup_records_finish(self, result: AsyncResult) -> list[GLib.Variant]: ...
    def lookup_service(
        self,
        service: str,
        protocol: str,
        domain: str,
        cancellable: typing.Optional[Cancellable] = None,
    ) -> list[SrvTarget]: ...
    def lookup_service_async(
        self,
        service: str,
        protocol: str,
        domain: str,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def lookup_service_finish(self, result: AsyncResult) -> list[SrvTarget]: ...
    def set_default(self) -> None: ...
    def set_timeout(self, timeout_ms: int) -> None: ...

class ResolverClass(GObject.GPointer):
    """
    :Constructors:

    ::

        ResolverClass()
    """

    parent_class: GObject.ObjectClass = ...
    reload: typing.Callable[[Resolver], None] = ...
    lookup_by_name: typing.Callable[
        [Resolver, str, typing.Optional[Cancellable]], list[InetAddress]
    ] = ...
    lookup_by_name_async: typing.Callable[..., None] = ...
    lookup_by_name_finish: typing.Callable[
        [Resolver, AsyncResult], list[InetAddress]
    ] = ...
    lookup_by_address: typing.Callable[
        [Resolver, InetAddress, typing.Optional[Cancellable]], str
    ] = ...
    lookup_by_address_async: typing.Callable[..., None] = ...
    lookup_by_address_finish: typing.Callable[[Resolver, AsyncResult], str] = ...
    lookup_service: None = ...
    lookup_service_async: typing.Callable[..., None] = ...
    lookup_service_finish: typing.Callable[
        [Resolver, AsyncResult], list[SrvTarget]
    ] = ...
    lookup_records: typing.Callable[
        [Resolver, str, ResolverRecordType, typing.Optional[Cancellable]],
        list[GLib.Variant],
    ] = ...
    lookup_records_async: typing.Callable[..., None] = ...
    lookup_records_finish: typing.Callable[
        [Resolver, AsyncResult], list[GLib.Variant]
    ] = ...
    lookup_by_name_with_flags_async: typing.Callable[..., None] = ...
    lookup_by_name_with_flags_finish: typing.Callable[
        [Resolver, AsyncResult], list[InetAddress]
    ] = ...
    lookup_by_name_with_flags: typing.Callable[
        [Resolver, str, ResolverNameLookupFlags, typing.Optional[Cancellable]],
        list[InetAddress],
    ] = ...

class ResolverPrivate(GObject.GPointer): ...

class Resource(GObject.GBoxed):
    """
    :Constructors:

    ::

        new_from_data(data:GLib.Bytes) -> Gio.Resource
    """
    def enumerate_children(
        self, path: str, lookup_flags: ResourceLookupFlags
    ) -> list[str]: ...
    def get_info(
        self, path: str, lookup_flags: ResourceLookupFlags
    ) -> typing.Tuple[bool, int, int]: ...
    def has_children(self, path: str) -> bool: ...
    @staticmethod
    def load(filename: str) -> Resource: ...
    def lookup_data(
        self, path: str, lookup_flags: ResourceLookupFlags
    ) -> GLib.Bytes: ...
    @classmethod
    def new_from_data(cls, data: GLib.Bytes) -> Resource: ...
    def open_stream(
        self, path: str, lookup_flags: ResourceLookupFlags
    ) -> InputStream: ...
    def ref(self) -> Resource: ...
    def unref(self) -> None: ...

class Seekable(GObject.GInterface):
    """
    Interface GSeekable

    Signals from GObject:
      notify (GParam)
    """
    def can_seek(self) -> bool: ...
    def can_truncate(self) -> bool: ...
    def seek(
        self,
        offset: int,
        type: GLib.SeekType,
        cancellable: typing.Optional[Cancellable] = None,
    ) -> bool: ...
    def tell(self) -> int: ...
    def truncate(
        self, offset: int, cancellable: typing.Optional[Cancellable] = None
    ) -> bool: ...

class SeekableIface(GObject.GPointer):
    """
    :Constructors:

    ::

        SeekableIface()
    """

    g_iface: GObject.TypeInterface = ...
    tell: typing.Callable[[Seekable], int] = ...
    can_seek: typing.Callable[[Seekable], bool] = ...
    seek: typing.Callable[
        [Seekable, int, GLib.SeekType, typing.Optional[Cancellable]], bool
    ] = ...
    can_truncate: typing.Callable[[Seekable], bool] = ...
    truncate_fn: typing.Callable[
        [Seekable, int, typing.Optional[Cancellable]], bool
    ] = ...

class Settings(GObject.Object):
    """
    Provide dictionary-like access to GLib.Settings.

    Object GSettings

    Provide dictionary-like access to GLib.Settings.

    Signals from GSettings:
      changed (gchararray)
      change-event (gpointer, gint) -> gboolean
      writable-changed (gchararray)
      writable-change-event (guint) -> gboolean

    Properties from GSettings:
      settings-schema -> GSettingsSchema: settings-schema
      schema -> gchararray: schema
      schema-id -> gchararray: schema-id
      backend -> GSettingsBackend: backend
      path -> gchararray: path
      has-unapplied -> gboolean: has-unapplied
      delay-apply -> gboolean: delay-apply

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        backend: SettingsBackend
        delay_apply: bool
        has_unapplied: bool
        path: str
        schema: str
        schema_id: str
        settings_schema: SettingsSchema

    props: Props = ...
    parent_instance: GObject.Object = ...
    priv: SettingsPrivate = ...
    def __init__(
        self,
        *,
        backend: SettingsBackend = ...,
        path: str = ...,
        schema: str = ...,
        schema_id: str = ...,
        settings_schema: SettingsSchema = ...,
    ) -> None: ...
    def __bool__(self): ...  # FIXME: Override is missing typing annotation
    def __getitem__(self, key): ...  # FIXME: Override is missing typing annotation
    def __iter__(self): ...  # FIXME: Override is missing typing annotation
    def __len__(self): ...  # FIXME: Override is missing typing annotation
    def __setitem__(
        self, key, value
    ): ...  # FIXME: Override is missing typing annotation
    def apply(self) -> None: ...
    def bind(
        self, key: str, object: GObject.Object, property: str, flags: SettingsBindFlags
    ) -> None: ...
    def bind_with_mapping(
        self,
        key: str,
        object: GObject.Object,
        property: str,
        flags: SettingsBindFlags,
        get_mapping: typing.Optional[typing.Callable[..., typing.Any]] = None,
        set_mapping: typing.Optional[typing.Callable[..., typing.Any]] = None,
    ) -> None: ...
    def bind_writable(
        self, key: str, object: GObject.Object, property: str, inverted: bool
    ) -> None: ...
    def create_action(self, key: str) -> Action: ...
    def delay(self) -> None: ...
    def do_change_event(self, keys: int, n_keys: int) -> bool: ...
    def do_changed(self, key: str) -> None: ...
    def do_writable_change_event(self, key: int) -> bool: ...
    def do_writable_changed(self, key: str) -> None: ...
    def get_boolean(self, key: str) -> bool: ...
    def get_child(self, name: str) -> Settings: ...
    def get_default_value(self, key: str) -> typing.Optional[GLib.Variant]: ...
    def get_double(self, key: str) -> float: ...
    def get_enum(self, key: str) -> int: ...
    def get_flags(self, key: str) -> int: ...
    def get_has_unapplied(self) -> bool: ...
    def get_int(self, key: str) -> int: ...
    def get_int64(self, key: str) -> int: ...
    def get_mapped(
        self,
        key: str,
        mapping: typing.Callable[..., typing.Tuple[bool, None]],
        *user_data: typing.Any,
    ) -> None: ...
    def get_range(self, key: str) -> GLib.Variant: ...
    def get_string(self, key: str) -> str: ...
    def get_strv(self, key: str) -> list[str]: ...
    def get_uint(self, key: str) -> int: ...
    def get_uint64(self, key: str) -> int: ...
    def get_user_value(self, key: str) -> typing.Optional[GLib.Variant]: ...
    def get_value(self, key: str) -> GLib.Variant: ...
    def is_writable(self, name: str) -> bool: ...
    def keys(self): ...  # FIXME: Override is missing typing annotation
    def list_children(self) -> list[str]: ...
    def list_keys(self) -> list[str]: ...
    @staticmethod
    def list_relocatable_schemas() -> list[str]: ...
    @staticmethod
    def list_schemas() -> list[str]: ...
    @classmethod
    def new(cls, schema_id: str) -> Settings: ...
    @classmethod
    def new_full(
        cls,
        schema: SettingsSchema,
        backend: typing.Optional[SettingsBackend] = None,
        path: typing.Optional[str] = None,
    ) -> Settings: ...
    @classmethod
    def new_with_backend(cls, schema_id: str, backend: SettingsBackend) -> Settings: ...
    @classmethod
    def new_with_backend_and_path(
        cls, schema_id: str, backend: SettingsBackend, path: str
    ) -> Settings: ...
    @classmethod
    def new_with_path(cls, schema_id: str, path: str) -> Settings: ...
    def range_check(self, key: str, value: GLib.Variant) -> bool: ...
    def reset(self, key: str) -> None: ...
    def revert(self) -> None: ...
    def set_boolean(self, key: str, value: bool) -> bool: ...
    def set_double(self, key: str, value: float) -> bool: ...
    def set_enum(self, key: str, value: int) -> bool: ...
    def set_flags(self, key: str, value: int) -> bool: ...
    def set_int(self, key: str, value: int) -> bool: ...
    def set_int64(self, key: str, value: int) -> bool: ...
    def set_string(self, key: str, value: str) -> bool: ...
    def set_strv(
        self, key: str, value: typing.Optional[typing.Sequence[str]] = None
    ) -> bool: ...
    def set_uint(self, key: str, value: int) -> bool: ...
    def set_uint64(self, key: str, value: int) -> bool: ...
    def set_value(self, key: str, value: GLib.Variant) -> bool: ...
    @staticmethod
    def sync() -> None: ...
    @staticmethod
    def unbind(object: GObject.Object, property: str) -> None: ...

class SettingsBackend(GObject.Object):
    """
    :Constructors:

    ::

        SettingsBackend(**properties)

    Object GSettingsBackend

    Signals from GObject:
      notify (GParam)
    """

    parent_instance: GObject.Object = ...
    priv: SettingsBackendPrivate = ...
    def changed(self, key: str, origin_tag: None) -> None: ...
    def changed_tree(self, tree: GLib.Tree, origin_tag: None) -> None: ...
    def do_get_writable(self, key: str) -> bool: ...
    def do_read(
        self, key: str, expected_type: GLib.VariantType, default_value: bool
    ) -> GLib.Variant: ...
    def do_read_user_value(
        self, key: str, expected_type: GLib.VariantType
    ) -> GLib.Variant: ...
    def do_reset(self, key: str, origin_tag: None) -> None: ...
    def do_subscribe(self, name: str) -> None: ...
    def do_sync(self) -> None: ...
    def do_unsubscribe(self, name: str) -> None: ...
    def do_write(self, key: str, value: GLib.Variant, origin_tag: None) -> bool: ...
    def do_write_tree(self, tree: GLib.Tree, origin_tag: None) -> bool: ...
    @staticmethod
    def flatten_tree(
        tree: GLib.Tree,
    ) -> typing.Tuple[str, list[str], list[GLib.Variant]]: ...
    @staticmethod
    def get_default() -> SettingsBackend: ...
    def keys_changed(
        self, path: str, items: typing.Sequence[str], origin_tag: None
    ) -> None: ...
    def path_changed(self, path: str, origin_tag: None) -> None: ...
    def path_writable_changed(self, path: str) -> None: ...
    def writable_changed(self, key: str) -> None: ...

class SettingsBackendClass(GObject.GPointer):
    """
    :Constructors:

    ::

        SettingsBackendClass()
    """

    parent_class: GObject.ObjectClass = ...
    read: typing.Callable[
        [SettingsBackend, str, GLib.VariantType, bool], GLib.Variant
    ] = ...
    get_writable: typing.Callable[[SettingsBackend, str], bool] = ...
    write: typing.Callable[[SettingsBackend, str, GLib.Variant, None], bool] = ...
    write_tree: typing.Callable[[SettingsBackend, GLib.Tree, None], bool] = ...
    reset: typing.Callable[[SettingsBackend, str, None], None] = ...
    subscribe: typing.Callable[[SettingsBackend, str], None] = ...
    unsubscribe: typing.Callable[[SettingsBackend, str], None] = ...
    sync: typing.Callable[[SettingsBackend], None] = ...
    get_permission: None = ...
    read_user_value: typing.Callable[
        [SettingsBackend, str, GLib.VariantType], GLib.Variant
    ] = ...
    padding: list[None] = ...

class SettingsBackendPrivate(GObject.GPointer): ...

class SettingsClass(GObject.GPointer):
    """
    :Constructors:

    ::

        SettingsClass()
    """

    parent_class: GObject.ObjectClass = ...
    writable_changed: typing.Callable[[Settings, str], None] = ...
    changed: typing.Callable[[Settings, str], None] = ...
    writable_change_event: typing.Callable[[Settings, int], bool] = ...
    change_event: typing.Callable[[Settings, int, int], bool] = ...
    padding: list[None] = ...

class SettingsPrivate(GObject.GPointer): ...

class SettingsSchema(GObject.GBoxed):
    def get_id(self) -> str: ...
    def get_key(self, name: str) -> SettingsSchemaKey: ...
    def get_path(self) -> typing.Optional[str]: ...
    def has_key(self, name: str) -> bool: ...
    def list_children(self) -> list[str]: ...
    def list_keys(self) -> list[str]: ...
    def ref(self) -> SettingsSchema: ...
    def unref(self) -> None: ...

class SettingsSchemaKey(GObject.GBoxed):
    def get_default_value(self) -> GLib.Variant: ...
    def get_description(self) -> typing.Optional[str]: ...
    def get_name(self) -> str: ...
    def get_range(self) -> GLib.Variant: ...
    def get_summary(self) -> typing.Optional[str]: ...
    def get_value_type(self) -> GLib.VariantType: ...
    def range_check(self, value: GLib.Variant) -> bool: ...
    def ref(self) -> SettingsSchemaKey: ...
    def unref(self) -> None: ...

class SettingsSchemaSource(GObject.GBoxed):
    """
    :Constructors:

    ::

        new_from_directory(directory:str, parent:Gio.SettingsSchemaSource=None, trusted:bool) -> Gio.SettingsSchemaSource
    """
    @staticmethod
    def get_default() -> typing.Optional[SettingsSchemaSource]: ...
    def list_schemas(self, recursive: bool) -> typing.Tuple[list[str], list[str]]: ...
    def lookup(
        self, schema_id: str, recursive: bool
    ) -> typing.Optional[SettingsSchema]: ...
    @classmethod
    def new_from_directory(
        cls,
        directory: str,
        parent: typing.Optional[SettingsSchemaSource],
        trusted: bool,
    ) -> SettingsSchemaSource: ...
    def ref(self) -> SettingsSchemaSource: ...
    def unref(self) -> None: ...

class SimpleAction(GObject.Object, Action):
    """
    :Constructors:

    ::

        SimpleAction(**properties)
        new(name:str, parameter_type:GLib.VariantType=None) -> Gio.SimpleAction
        new_stateful(name:str, parameter_type:GLib.VariantType=None, state:GLib.Variant) -> Gio.SimpleAction

    Object GSimpleAction

    Signals from GSimpleAction:
      activate (GVariant)
      change-state (GVariant)

    Properties from GSimpleAction:
      name -> gchararray: name
      parameter-type -> GVariantType: parameter-type
      enabled -> gboolean: enabled
      state-type -> GVariantType: state-type
      state -> GVariant: state

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        enabled: bool
        name: str
        parameter_type: GLib.VariantType
        state: GLib.Variant
        state_type: GLib.VariantType

    props: Props = ...
    def __init__(
        self,
        *,
        enabled: bool = ...,
        name: str = ...,
        parameter_type: GLib.VariantType = ...,
        state: GLib.Variant = ...,
    ) -> None: ...
    @classmethod
    def new(
        cls, name: str, parameter_type: typing.Optional[GLib.VariantType] = None
    ) -> SimpleAction: ...
    @classmethod
    def new_stateful(
        cls,
        name: str,
        parameter_type: typing.Optional[GLib.VariantType],
        state: GLib.Variant,
    ) -> SimpleAction: ...
    def set_enabled(self, enabled: bool) -> None: ...
    def set_state(self, value: GLib.Variant) -> None: ...
    def set_state_hint(
        self, state_hint: typing.Optional[GLib.Variant] = None
    ) -> None: ...

class SimpleActionGroup(GObject.Object, ActionGroup, ActionMap):
    """
    :Constructors:

    ::

        SimpleActionGroup(**properties)
        new() -> Gio.SimpleActionGroup

    Object GSimpleActionGroup

    Signals from GActionGroup:
      action-added (gchararray)
      action-removed (gchararray)
      action-enabled-changed (gchararray, gboolean)
      action-state-changed (gchararray, GVariant)

    Signals from GObject:
      notify (GParam)
    """

    parent_instance: GObject.Object = ...
    priv: SimpleActionGroupPrivate = ...
    def add_entries(
        self, entries: typing.Sequence[ActionEntry], user_data: None
    ) -> None: ...
    def insert(self, action: Action) -> None: ...
    def lookup(self, action_name: str) -> Action: ...
    @classmethod
    def new(cls) -> SimpleActionGroup: ...
    def remove(self, action_name: str) -> None: ...

class SimpleActionGroupClass(GObject.GPointer):
    """
    :Constructors:

    ::

        SimpleActionGroupClass()
    """

    parent_class: GObject.ObjectClass = ...
    padding: list[None] = ...

class SimpleActionGroupPrivate(GObject.GPointer): ...

class SimpleAsyncResult(GObject.Object, AsyncResult):
    """
    :Constructors:

    ::

        SimpleAsyncResult(**properties)
        new(source_object:GObject.Object=None, callback:Gio.AsyncReadyCallback=None, user_data=None, source_tag=None) -> Gio.SimpleAsyncResult
        new_from_error(source_object:GObject.Object=None, callback:Gio.AsyncReadyCallback=None, user_data=None, error:error) -> Gio.SimpleAsyncResult

    Object GSimpleAsyncResult

    Signals from GObject:
      notify (GParam)
    """
    def complete(self) -> None: ...
    def complete_in_idle(self) -> None: ...
    def get_op_res_gboolean(self) -> bool: ...
    def get_op_res_gssize(self) -> int: ...
    @staticmethod
    def is_valid(
        result: AsyncResult, source: typing.Optional[GObject.Object], source_tag: None
    ) -> bool: ...
    @classmethod
    def new(
        cls,
        source_object: typing.Optional[GObject.Object],
        callback: typing.Optional[typing.Callable[..., None]],
        source_tag: None,
        *user_data: typing.Any,
    ) -> SimpleAsyncResult: ...
    @classmethod
    def new_from_error(
        cls,
        source_object: typing.Optional[GObject.Object],
        callback: typing.Optional[typing.Callable[..., None]],
        error: GLib.Error,
        *user_data: typing.Any,
    ) -> SimpleAsyncResult: ...
    def propagate_error(self) -> bool: ...
    def set_check_cancellable(
        self, check_cancellable: typing.Optional[Cancellable] = None
    ) -> None: ...
    def set_from_error(self, error: GLib.Error) -> None: ...
    def set_handle_cancellation(self, handle_cancellation: bool) -> None: ...
    def set_op_res_gboolean(self, op_res: bool) -> None: ...
    def set_op_res_gssize(self, op_res: int) -> None: ...

class SimpleAsyncResultClass(GObject.GPointer): ...

class SimpleIOStream(IOStream):
    """
    :Constructors:

    ::

        SimpleIOStream(**properties)
        new(input_stream:Gio.InputStream, output_stream:Gio.OutputStream) -> Gio.IOStream

    Object GSimpleIOStream

    Properties from GSimpleIOStream:
      input-stream -> GInputStream: input-stream
      output-stream -> GOutputStream: output-stream

    Properties from GIOStream:
      input-stream -> GInputStream: input-stream
      output-stream -> GOutputStream: output-stream
      closed -> gboolean: closed

    Signals from GObject:
      notify (GParam)
    """
    class Props(IOStream.Props):
        input_stream: InputStream
        output_stream: OutputStream
        closed: bool

    props: Props = ...
    def __init__(
        self, *, input_stream: InputStream = ..., output_stream: OutputStream = ...
    ) -> None: ...
    @classmethod
    def new(
        cls, input_stream: InputStream, output_stream: OutputStream
    ) -> SimpleIOStream: ...

class SimplePermission(Permission):
    """
    :Constructors:

    ::

        SimplePermission(**properties)
        new(allowed:bool) -> Gio.Permission

    Object GSimplePermission

    Properties from GPermission:
      allowed -> gboolean: allowed
      can-acquire -> gboolean: can-acquire
      can-release -> gboolean: can-release

    Signals from GObject:
      notify (GParam)
    """
    class Props(Permission.Props):
        allowed: bool
        can_acquire: bool
        can_release: bool

    props: Props = ...
    @classmethod
    def new(cls, allowed: bool) -> SimplePermission: ...

class SimpleProxyResolver(GObject.Object, ProxyResolver):
    """
    :Constructors:

    ::

        SimpleProxyResolver(**properties)

    Object GSimpleProxyResolver

    Properties from GSimpleProxyResolver:
      default-proxy -> gchararray: default-proxy
      ignore-hosts -> GStrv: ignore-hosts

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        default_proxy: typing.Optional[str]
        ignore_hosts: list[str]

    props: Props = ...
    parent_instance: GObject.Object = ...
    priv: SimpleProxyResolverPrivate = ...
    def __init__(
        self,
        *,
        default_proxy: typing.Optional[str] = ...,
        ignore_hosts: typing.Sequence[str] = ...,
    ) -> None: ...
    @staticmethod
    def new(
        default_proxy: typing.Optional[str] = None,
        ignore_hosts: typing.Optional[typing.Sequence[str]] = None,
    ) -> ProxyResolver: ...
    def set_default_proxy(self, default_proxy: typing.Optional[str] = None) -> None: ...
    def set_ignore_hosts(self, ignore_hosts: typing.Sequence[str]) -> None: ...
    def set_uri_proxy(self, uri_scheme: str, proxy: str) -> None: ...

class SimpleProxyResolverClass(GObject.GPointer):
    """
    :Constructors:

    ::

        SimpleProxyResolverClass()
    """

    parent_class: GObject.ObjectClass = ...

class SimpleProxyResolverPrivate(GObject.GPointer): ...

class Socket(GObject.Object, DatagramBased, Initable):
    """
    :Constructors:

    ::

        Socket(**properties)
        new(family:Gio.SocketFamily, type:Gio.SocketType, protocol:Gio.SocketProtocol) -> Gio.Socket
        new_from_fd(fd:int) -> Gio.Socket

    Object GSocket

    Properties from GSocket:
      family -> GSocketFamily: family
      type -> GSocketType: type
      protocol -> GSocketProtocol: protocol
      fd -> gint: fd
      blocking -> gboolean: blocking
      listen-backlog -> gint: listen-backlog
      keepalive -> gboolean: keepalive
      local-address -> GSocketAddress: local-address
      remote-address -> GSocketAddress: remote-address
      timeout -> guint: timeout
      ttl -> guint: ttl
      broadcast -> gboolean: broadcast
      multicast-loopback -> gboolean: multicast-loopback
      multicast-ttl -> guint: multicast-ttl

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        blocking: bool
        broadcast: bool
        family: SocketFamily
        fd: int
        keepalive: bool
        listen_backlog: int
        local_address: SocketAddress
        multicast_loopback: bool
        multicast_ttl: int
        protocol: SocketProtocol
        remote_address: SocketAddress
        timeout: int
        ttl: int
        type: SocketType

    props: Props = ...
    parent_instance: GObject.Object = ...
    priv: SocketPrivate = ...
    def __init__(
        self,
        *,
        blocking: bool = ...,
        broadcast: bool = ...,
        family: SocketFamily = ...,
        fd: int = ...,
        keepalive: bool = ...,
        listen_backlog: int = ...,
        multicast_loopback: bool = ...,
        multicast_ttl: int = ...,
        protocol: SocketProtocol = ...,
        timeout: int = ...,
        ttl: int = ...,
        type: SocketType = ...,
    ) -> None: ...
    def accept(self, cancellable: typing.Optional[Cancellable] = None) -> Socket: ...
    def bind(self, address: SocketAddress, allow_reuse: bool) -> bool: ...
    def check_connect_result(self) -> bool: ...
    def close(self) -> bool: ...
    def condition_check(self, condition: GLib.IOCondition) -> GLib.IOCondition: ...
    def condition_timed_wait(
        self,
        condition: GLib.IOCondition,
        timeout_us: int,
        cancellable: typing.Optional[Cancellable] = None,
    ) -> bool: ...
    def condition_wait(
        self,
        condition: GLib.IOCondition,
        cancellable: typing.Optional[Cancellable] = None,
    ) -> bool: ...
    def connect(
        self, address: SocketAddress, cancellable: typing.Optional[Cancellable] = None
    ) -> bool: ...
    def connection_factory_create_connection(self) -> SocketConnection: ...
    def get_available_bytes(self) -> int: ...
    def get_blocking(self) -> bool: ...
    def get_broadcast(self) -> bool: ...
    def get_credentials(self) -> Credentials: ...
    def get_family(self) -> SocketFamily: ...
    def get_fd(self) -> int: ...
    def get_keepalive(self) -> bool: ...
    def get_listen_backlog(self) -> int: ...
    def get_local_address(self) -> SocketAddress: ...
    def get_multicast_loopback(self) -> bool: ...
    def get_multicast_ttl(self) -> int: ...
    def get_option(self, level: int, optname: int) -> typing.Tuple[bool, int]: ...
    def get_protocol(self) -> SocketProtocol: ...
    def get_remote_address(self) -> SocketAddress: ...
    def get_socket_type(self) -> SocketType: ...
    def get_timeout(self) -> int: ...
    def get_ttl(self) -> int: ...
    def is_closed(self) -> bool: ...
    def is_connected(self) -> bool: ...
    def join_multicast_group(
        self,
        group: InetAddress,
        source_specific: bool,
        iface: typing.Optional[str] = None,
    ) -> bool: ...
    def join_multicast_group_ssm(
        self,
        group: InetAddress,
        source_specific: typing.Optional[InetAddress] = None,
        iface: typing.Optional[str] = None,
    ) -> bool: ...
    def leave_multicast_group(
        self,
        group: InetAddress,
        source_specific: bool,
        iface: typing.Optional[str] = None,
    ) -> bool: ...
    def leave_multicast_group_ssm(
        self,
        group: InetAddress,
        source_specific: typing.Optional[InetAddress] = None,
        iface: typing.Optional[str] = None,
    ) -> bool: ...
    def listen(self) -> bool: ...
    @classmethod
    def new(
        cls, family: SocketFamily, type: SocketType, protocol: SocketProtocol
    ) -> Socket: ...
    @classmethod
    def new_from_fd(cls, fd: int) -> Socket: ...
    def receive(
        self, cancellable: typing.Optional[Cancellable] = None
    ) -> typing.Tuple[int, bytes]: ...
    def receive_bytes(
        self,
        size: int,
        timeout_us: int,
        cancellable: typing.Optional[Cancellable] = None,
    ) -> GLib.Bytes: ...
    def receive_bytes_from(
        self,
        size: int,
        timeout_us: int,
        cancellable: typing.Optional[Cancellable] = None,
    ) -> typing.Tuple[GLib.Bytes, SocketAddress]: ...
    def receive_from(
        self, cancellable: typing.Optional[Cancellable] = None
    ) -> typing.Tuple[int, SocketAddress, bytes]: ...
    def receive_message(
        self,
        vectors: typing.Sequence[InputVector],
        cancellable: typing.Optional[Cancellable] = None,
    ) -> typing.Tuple[int, SocketAddress, list[SocketControlMessage], int]: ...
    def receive_messages(
        self,
        messages: typing.Sequence[InputMessage],
        flags: int,
        cancellable: typing.Optional[Cancellable] = None,
    ) -> int: ...
    def receive_with_blocking(
        self, blocking: bool, cancellable: typing.Optional[Cancellable] = None
    ) -> typing.Tuple[int, bytes]: ...
    def send(
        self,
        buffer: typing.Sequence[int],
        cancellable: typing.Optional[Cancellable] = None,
    ) -> int: ...
    def send_message(
        self,
        address: typing.Optional[SocketAddress],
        vectors: typing.Sequence[OutputVector],
        messages: typing.Optional[typing.Sequence[SocketControlMessage]],
        flags: int,
        cancellable: typing.Optional[Cancellable] = None,
    ) -> int: ...
    def send_message_with_timeout(
        self,
        address: typing.Optional[SocketAddress],
        vectors: typing.Sequence[OutputVector],
        messages: typing.Optional[typing.Sequence[SocketControlMessage]],
        flags: int,
        timeout_us: int,
        cancellable: typing.Optional[Cancellable] = None,
    ) -> typing.Tuple[PollableReturn, int]: ...
    def send_messages(
        self,
        messages: typing.Sequence[OutputMessage],
        flags: int,
        cancellable: typing.Optional[Cancellable] = None,
    ) -> int: ...
    def send_to(
        self,
        address: typing.Optional[SocketAddress],
        buffer: typing.Sequence[int],
        cancellable: typing.Optional[Cancellable] = None,
    ) -> int: ...
    def send_with_blocking(
        self,
        buffer: typing.Sequence[int],
        blocking: bool,
        cancellable: typing.Optional[Cancellable] = None,
    ) -> int: ...
    def set_blocking(self, blocking: bool) -> None: ...
    def set_broadcast(self, broadcast: bool) -> None: ...
    def set_keepalive(self, keepalive: bool) -> None: ...
    def set_listen_backlog(self, backlog: int) -> None: ...
    def set_multicast_loopback(self, loopback: bool) -> None: ...
    def set_multicast_ttl(self, ttl: int) -> None: ...
    def set_option(self, level: int, optname: int, value: int) -> bool: ...
    def set_timeout(self, timeout: int) -> None: ...
    def set_ttl(self, ttl: int) -> None: ...
    def shutdown(self, shutdown_read: bool, shutdown_write: bool) -> bool: ...
    def speaks_ipv4(self) -> bool: ...

class SocketAddress(GObject.Object, SocketConnectable):
    """
    :Constructors:

    ::

        SocketAddress(**properties)
        new_from_native(native, len:int) -> Gio.SocketAddress

    Object GSocketAddress

    Properties from GSocketAddress:
      family -> GSocketFamily: family

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        family: SocketFamily

    props: Props = ...
    parent_instance: GObject.Object = ...
    def do_get_family(self) -> SocketFamily: ...
    def do_get_native_size(self) -> int: ...
    def do_to_native(self, dest: None, destlen: int) -> bool: ...
    def get_family(self) -> SocketFamily: ...
    def get_native_size(self) -> int: ...
    @classmethod
    def new_from_native(cls, native: None, len: int) -> SocketAddress: ...
    def to_native(self, dest: None, destlen: int) -> bool: ...

class SocketAddressClass(GObject.GPointer):
    """
    :Constructors:

    ::

        SocketAddressClass()
    """

    parent_class: GObject.ObjectClass = ...
    get_family: typing.Callable[[SocketAddress], SocketFamily] = ...
    get_native_size: typing.Callable[[SocketAddress], int] = ...
    to_native: typing.Callable[[SocketAddress, None, int], bool] = ...

class SocketAddressEnumerator(GObject.Object):
    """
    :Constructors:

    ::

        SocketAddressEnumerator(**properties)

    Object GSocketAddressEnumerator

    Signals from GObject:
      notify (GParam)
    """

    parent_instance: GObject.Object = ...
    def do_next(
        self, cancellable: typing.Optional[Cancellable] = None
    ) -> typing.Optional[SocketAddress]: ...
    def do_next_async(
        self,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def do_next_finish(self, result: AsyncResult) -> typing.Optional[SocketAddress]: ...
    def next(
        self, cancellable: typing.Optional[Cancellable] = None
    ) -> typing.Optional[SocketAddress]: ...
    def next_async(
        self,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def next_finish(self, result: AsyncResult) -> typing.Optional[SocketAddress]: ...

class SocketAddressEnumeratorClass(GObject.GPointer):
    """
    :Constructors:

    ::

        SocketAddressEnumeratorClass()
    """

    parent_class: GObject.ObjectClass = ...
    next: typing.Callable[
        [SocketAddressEnumerator, typing.Optional[Cancellable]],
        typing.Optional[SocketAddress],
    ] = ...
    next_async: typing.Callable[..., None] = ...
    next_finish: typing.Callable[
        [SocketAddressEnumerator, AsyncResult], typing.Optional[SocketAddress]
    ] = ...

class SocketClass(GObject.GPointer):
    """
    :Constructors:

    ::

        SocketClass()
    """

    parent_class: GObject.ObjectClass = ...

class SocketClient(GObject.Object):
    """
    :Constructors:

    ::

        SocketClient(**properties)
        new() -> Gio.SocketClient

    Object GSocketClient

    Signals from GSocketClient:
      event (GSocketClientEvent, GSocketConnectable, GIOStream)

    Properties from GSocketClient:
      family -> GSocketFamily: family
      type -> GSocketType: type
      protocol -> GSocketProtocol: protocol
      local-address -> GSocketAddress: local-address
      timeout -> guint: timeout
      enable-proxy -> gboolean: enable-proxy
      tls -> gboolean: tls
      tls-validation-flags -> GTlsCertificateFlags: tls-validation-flags
      proxy-resolver -> GProxyResolver: proxy-resolver

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        enable_proxy: bool
        family: SocketFamily
        local_address: typing.Optional[SocketAddress]
        protocol: SocketProtocol
        proxy_resolver: ProxyResolver
        timeout: int
        tls: bool
        tls_validation_flags: TlsCertificateFlags
        type: SocketType

    props: Props = ...
    parent_instance: GObject.Object = ...
    priv: SocketClientPrivate = ...
    def __init__(
        self,
        *,
        enable_proxy: bool = ...,
        family: SocketFamily = ...,
        local_address: typing.Optional[SocketAddress] = ...,
        protocol: SocketProtocol = ...,
        proxy_resolver: typing.Optional[ProxyResolver] = ...,
        timeout: int = ...,
        tls: bool = ...,
        tls_validation_flags: TlsCertificateFlags = ...,
        type: SocketType = ...,
    ) -> None: ...
    def add_application_proxy(self, protocol: str) -> None: ...
    def connect(
        self,
        connectable: SocketConnectable,
        cancellable: typing.Optional[Cancellable] = None,
    ) -> SocketConnection: ...
    def connect_async(
        self,
        connectable: SocketConnectable,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def connect_finish(self, result: AsyncResult) -> SocketConnection: ...
    def connect_to_host(
        self,
        host_and_port: str,
        default_port: int,
        cancellable: typing.Optional[Cancellable] = None,
    ) -> SocketConnection: ...
    def connect_to_host_async(
        self,
        host_and_port: str,
        default_port: int,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def connect_to_host_finish(self, result: AsyncResult) -> SocketConnection: ...
    def connect_to_service(
        self,
        domain: str,
        service: str,
        cancellable: typing.Optional[Cancellable] = None,
    ) -> SocketConnection: ...
    def connect_to_service_async(
        self,
        domain: str,
        service: str,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def connect_to_service_finish(self, result: AsyncResult) -> SocketConnection: ...
    def connect_to_uri(
        self,
        uri: str,
        default_port: int,
        cancellable: typing.Optional[Cancellable] = None,
    ) -> SocketConnection: ...
    def connect_to_uri_async(
        self,
        uri: str,
        default_port: int,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def connect_to_uri_finish(self, result: AsyncResult) -> SocketConnection: ...
    def do_event(
        self,
        event: SocketClientEvent,
        connectable: SocketConnectable,
        connection: IOStream,
    ) -> None: ...
    def get_enable_proxy(self) -> bool: ...
    def get_family(self) -> SocketFamily: ...
    def get_local_address(self) -> typing.Optional[SocketAddress]: ...
    def get_protocol(self) -> SocketProtocol: ...
    def get_proxy_resolver(self) -> ProxyResolver: ...
    def get_socket_type(self) -> SocketType: ...
    def get_timeout(self) -> int: ...
    def get_tls(self) -> bool: ...
    def get_tls_validation_flags(self) -> TlsCertificateFlags: ...
    @classmethod
    def new(cls) -> SocketClient: ...
    def set_enable_proxy(self, enable: bool) -> None: ...
    def set_family(self, family: SocketFamily) -> None: ...
    def set_local_address(
        self, address: typing.Optional[SocketAddress] = None
    ) -> None: ...
    def set_protocol(self, protocol: SocketProtocol) -> None: ...
    def set_proxy_resolver(
        self, proxy_resolver: typing.Optional[ProxyResolver] = None
    ) -> None: ...
    def set_socket_type(self, type: SocketType) -> None: ...
    def set_timeout(self, timeout: int) -> None: ...
    def set_tls(self, tls: bool) -> None: ...
    def set_tls_validation_flags(self, flags: TlsCertificateFlags) -> None: ...

class SocketClientClass(GObject.GPointer):
    """
    :Constructors:

    ::

        SocketClientClass()
    """

    parent_class: GObject.ObjectClass = ...
    event: typing.Callable[
        [SocketClient, SocketClientEvent, SocketConnectable, IOStream], None
    ] = ...

class SocketClientPrivate(GObject.GPointer): ...

class SocketConnectable(GObject.GInterface):
    """
    Interface GSocketConnectable

    Signals from GObject:
      notify (GParam)
    """
    def enumerate(self) -> SocketAddressEnumerator: ...
    def proxy_enumerate(self) -> SocketAddressEnumerator: ...
    def to_string(self) -> str: ...

class SocketConnectableIface(GObject.GPointer):
    """
    :Constructors:

    ::

        SocketConnectableIface()
    """

    g_iface: GObject.TypeInterface = ...
    enumerate: typing.Callable[[SocketConnectable], SocketAddressEnumerator] = ...
    proxy_enumerate: typing.Callable[[SocketConnectable], SocketAddressEnumerator] = ...
    to_string: typing.Callable[[SocketConnectable], str] = ...

class SocketConnection(IOStream):
    """
    :Constructors:

    ::

        SocketConnection(**properties)

    Object GSocketConnection

    Properties from GSocketConnection:
      socket -> GSocket: socket

    Properties from GIOStream:
      input-stream -> GInputStream: input-stream
      output-stream -> GOutputStream: output-stream
      closed -> gboolean: closed

    Signals from GObject:
      notify (GParam)
    """
    class Props(IOStream.Props):
        socket: Socket
        closed: bool
        input_stream: InputStream
        output_stream: OutputStream

    props: Props = ...
    parent_instance: IOStream = ...
    priv: SocketConnectionPrivate = ...
    def __init__(self, *, socket: Socket = ...) -> None: ...
    def connect(
        self, address: SocketAddress, cancellable: typing.Optional[Cancellable] = None
    ) -> bool: ...
    def connect_async(
        self,
        address: SocketAddress,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def connect_finish(self, result: AsyncResult) -> bool: ...
    @staticmethod
    def factory_lookup_type(
        family: SocketFamily, type: SocketType, protocol_id: int
    ) -> typing.Type[typing.Any]: ...
    @staticmethod
    def factory_register_type(
        g_type: typing.Type[typing.Any],
        family: SocketFamily,
        type: SocketType,
        protocol: int,
    ) -> None: ...
    def get_local_address(self) -> SocketAddress: ...
    def get_remote_address(self) -> SocketAddress: ...
    def get_socket(self) -> Socket: ...
    def is_connected(self) -> bool: ...

class SocketConnectionClass(GObject.GPointer):
    """
    :Constructors:

    ::

        SocketConnectionClass()
    """

    parent_class: IOStreamClass = ...

class SocketConnectionPrivate(GObject.GPointer): ...

class SocketControlMessage(GObject.Object):
    """
    :Constructors:

    ::

        SocketControlMessage(**properties)

    Object GSocketControlMessage

    Signals from GObject:
      notify (GParam)
    """

    parent_instance: GObject.Object = ...
    priv: SocketControlMessagePrivate = ...
    @staticmethod
    def deserialize(
        level: int, type: int, data: typing.Sequence[int]
    ) -> typing.Optional[SocketControlMessage]: ...
    def do_get_level(self) -> int: ...
    def do_get_size(self) -> int: ...
    def do_get_type(self) -> int: ...
    def do_serialize(self, data: None) -> None: ...
    def get_level(self) -> int: ...
    def get_msg_type(self) -> int: ...
    def get_size(self) -> int: ...
    def serialize(self, data: None) -> None: ...

class SocketControlMessageClass(GObject.GPointer):
    """
    :Constructors:

    ::

        SocketControlMessageClass()
    """

    parent_class: GObject.ObjectClass = ...
    get_size: typing.Callable[[SocketControlMessage], int] = ...
    get_level: typing.Callable[[SocketControlMessage], int] = ...
    get_type: typing.Callable[[SocketControlMessage], int] = ...
    serialize: typing.Callable[[SocketControlMessage, None], None] = ...
    deserialize: None = ...

class SocketControlMessagePrivate(GObject.GPointer): ...

class SocketListener(GObject.Object):
    """
    :Constructors:

    ::

        SocketListener(**properties)
        new() -> Gio.SocketListener

    Object GSocketListener

    Signals from GSocketListener:
      event (GSocketListenerEvent, GSocket)

    Properties from GSocketListener:
      listen-backlog -> gint: listen-backlog

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        listen_backlog: int

    props: Props = ...
    parent_instance: GObject.Object = ...
    priv: SocketListenerPrivate = ...
    def __init__(self, *, listen_backlog: int = ...) -> None: ...
    def accept(
        self, cancellable: typing.Optional[Cancellable] = None
    ) -> typing.Tuple[SocketConnection, GObject.Object]: ...
    def accept_async(
        self,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def accept_finish(
        self, result: AsyncResult
    ) -> typing.Tuple[SocketConnection, GObject.Object]: ...
    def accept_socket(
        self, cancellable: typing.Optional[Cancellable] = None
    ) -> typing.Tuple[Socket, GObject.Object]: ...
    def accept_socket_async(
        self,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def accept_socket_finish(
        self, result: AsyncResult
    ) -> typing.Tuple[Socket, GObject.Object]: ...
    def add_address(
        self,
        address: SocketAddress,
        type: SocketType,
        protocol: SocketProtocol,
        source_object: typing.Optional[GObject.Object] = None,
    ) -> typing.Tuple[bool, SocketAddress]: ...
    def add_any_inet_port(
        self, source_object: typing.Optional[GObject.Object] = None
    ) -> int: ...
    def add_inet_port(
        self, port: int, source_object: typing.Optional[GObject.Object] = None
    ) -> bool: ...
    def add_socket(
        self, socket: Socket, source_object: typing.Optional[GObject.Object] = None
    ) -> bool: ...
    def close(self) -> None: ...
    def do_changed(self) -> None: ...
    def do_event(self, event: SocketListenerEvent, socket: Socket) -> None: ...
    @classmethod
    def new(cls) -> SocketListener: ...
    def set_backlog(self, listen_backlog: int) -> None: ...

class SocketListenerClass(GObject.GPointer):
    """
    :Constructors:

    ::

        SocketListenerClass()
    """

    parent_class: GObject.ObjectClass = ...
    changed: typing.Callable[[SocketListener], None] = ...
    event: typing.Callable[[SocketListener, SocketListenerEvent, Socket], None] = ...

class SocketListenerPrivate(GObject.GPointer): ...
class SocketPrivate(GObject.GPointer): ...

class SocketService(SocketListener):
    """
    :Constructors:

    ::

        SocketService(**properties)
        new() -> Gio.SocketService

    Object GSocketService

    Signals from GSocketService:
      incoming (GSocketConnection, GObject) -> gboolean

    Properties from GSocketService:
      active -> gboolean: active

    Signals from GSocketListener:
      event (GSocketListenerEvent, GSocket)

    Properties from GSocketListener:
      listen-backlog -> gint: listen-backlog

    Signals from GObject:
      notify (GParam)
    """
    class Props(SocketListener.Props):
        active: bool
        listen_backlog: int

    props: Props = ...
    parent_instance: SocketListener = ...
    priv: SocketServicePrivate = ...
    def __init__(self, *, active: bool = ..., listen_backlog: int = ...) -> None: ...
    def do_incoming(
        self, connection: SocketConnection, source_object: GObject.Object
    ) -> bool: ...
    def is_active(self) -> bool: ...
    @classmethod
    def new(cls) -> SocketService: ...
    def start(self) -> None: ...
    def stop(self) -> None: ...

class SocketServiceClass(GObject.GPointer):
    """
    :Constructors:

    ::

        SocketServiceClass()
    """

    parent_class: SocketListenerClass = ...
    incoming: typing.Callable[
        [SocketService, SocketConnection, GObject.Object], bool
    ] = ...

class SocketServicePrivate(GObject.GPointer): ...

class SrvTarget(GObject.GBoxed):
    """
    :Constructors:

    ::

        new(hostname:str, port:int, priority:int, weight:int) -> Gio.SrvTarget
    """
    @staticmethod
    def __new__(
        cls: type[Self], hostname: str, port: int, priority: int, weight: int
    ) -> Self: ...
    def copy(self) -> SrvTarget: ...
    def free(self) -> None: ...
    def get_hostname(self) -> str: ...
    def get_port(self) -> int: ...
    def get_priority(self) -> int: ...
    def get_weight(self) -> int: ...
    @classmethod
    def new(cls, hostname: str, port: int, priority: int, weight: int) -> SrvTarget: ...

class StaticResource(GObject.GPointer):
    """
    :Constructors:

    ::

        StaticResource()
    """

    data: int = ...
    data_len: int = ...
    resource: Resource = ...
    next: StaticResource = ...
    padding: None = ...
    def fini(self) -> None: ...
    def get_resource(self) -> Resource: ...
    def init(self) -> None: ...

class Subprocess(GObject.Object, Initable):
    """
    :Constructors:

    ::

        Subprocess(**properties)
        new(argv:list, flags:Gio.SubprocessFlags) -> Gio.Subprocess

    Object GSubprocess

    Properties from GSubprocess:
      flags -> GSubprocessFlags: flags
      argv -> GStrv: argv

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        argv: list[str]
        flags: SubprocessFlags

    props: Props = ...
    def __init__(
        self, *, argv: typing.Sequence[str] = ..., flags: SubprocessFlags = ...
    ) -> None: ...
    def communicate(
        self,
        stdin_buf: typing.Optional[GLib.Bytes] = None,
        cancellable: typing.Optional[Cancellable] = None,
    ) -> typing.Tuple[bool, GLib.Bytes, GLib.Bytes]: ...
    def communicate_async(
        self,
        stdin_buf: typing.Optional[GLib.Bytes] = None,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def communicate_finish(
        self, result: AsyncResult
    ) -> typing.Tuple[bool, GLib.Bytes, GLib.Bytes]: ...
    def communicate_utf8(
        self,
        stdin_buf: typing.Optional[str] = None,
        cancellable: typing.Optional[Cancellable] = None,
    ) -> typing.Tuple[bool, str, str]: ...
    def communicate_utf8_async(
        self,
        stdin_buf: typing.Optional[str] = None,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def communicate_utf8_finish(
        self, result: AsyncResult
    ) -> typing.Tuple[bool, str, str]: ...
    def force_exit(self) -> None: ...
    def get_exit_status(self) -> int: ...
    def get_identifier(self) -> typing.Optional[str]: ...
    def get_if_exited(self) -> bool: ...
    def get_if_signaled(self) -> bool: ...
    def get_status(self) -> int: ...
    def get_stderr_pipe(self) -> typing.Optional[InputStream]: ...
    def get_stdin_pipe(self) -> typing.Optional[OutputStream]: ...
    def get_stdout_pipe(self) -> typing.Optional[InputStream]: ...
    def get_successful(self) -> bool: ...
    def get_term_sig(self) -> int: ...
    @classmethod
    def new(cls, argv: typing.Sequence[str], flags: SubprocessFlags) -> Subprocess: ...
    def send_signal(self, signal_num: int) -> None: ...
    def wait(self, cancellable: typing.Optional[Cancellable] = None) -> bool: ...
    def wait_async(
        self,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def wait_check(self, cancellable: typing.Optional[Cancellable] = None) -> bool: ...
    def wait_check_async(
        self,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def wait_check_finish(self, result: AsyncResult) -> bool: ...
    def wait_finish(self, result: AsyncResult) -> bool: ...

class SubprocessLauncher(GObject.Object):
    """
    :Constructors:

    ::

        SubprocessLauncher(**properties)
        new(flags:Gio.SubprocessFlags) -> Gio.SubprocessLauncher

    Object GSubprocessLauncher

    Properties from GSubprocessLauncher:
      flags -> GSubprocessFlags: flags

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        flags: SubprocessFlags

    props: Props = ...
    def __init__(self, *, flags: SubprocessFlags = ...) -> None: ...
    def close(self) -> None: ...
    def getenv(self, variable: str) -> typing.Optional[str]: ...
    @classmethod
    def new(cls, flags: SubprocessFlags) -> SubprocessLauncher: ...
    def set_cwd(self, cwd: str) -> None: ...
    def set_environ(self, env: typing.Sequence[str]) -> None: ...
    def set_flags(self, flags: SubprocessFlags) -> None: ...
    def set_stderr_file_path(self, path: typing.Optional[str] = None) -> None: ...
    def set_stdin_file_path(self, path: typing.Optional[str] = None) -> None: ...
    def set_stdout_file_path(self, path: typing.Optional[str] = None) -> None: ...
    def setenv(self, variable: str, value: str, overwrite: bool) -> None: ...
    def spawnv(self, argv: typing.Sequence[str]) -> Subprocess: ...
    def take_fd(self, source_fd: int, target_fd: int) -> None: ...
    def take_stderr_fd(self, fd: int) -> None: ...
    def take_stdin_fd(self, fd: int) -> None: ...
    def take_stdout_fd(self, fd: int) -> None: ...
    def unsetenv(self, variable: str) -> None: ...

class Task(GObject.Object, AsyncResult):
    """
    :Constructors:

    ::

        Task(**properties)
        new(source_object:GObject.Object=None, cancellable:Gio.Cancellable=None, callback:Gio.AsyncReadyCallback=None, callback_data=None) -> Gio.Task

    Object GTask

    Properties from GTask:
      completed -> gboolean: completed

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        completed: bool

    props: Props = ...
    def get_cancellable(self) -> typing.Optional[Cancellable]: ...
    def get_check_cancellable(self) -> bool: ...
    def get_completed(self) -> bool: ...
    def get_context(self) -> GLib.MainContext: ...
    def get_name(self) -> typing.Optional[str]: ...
    def get_priority(self) -> int: ...
    def get_return_on_cancel(self) -> bool: ...
    def get_source_object(self) -> typing.Optional[GObject.Object]: ...
    def get_source_tag(self) -> None: ...
    def get_task_data(self) -> None: ...
    def had_error(self) -> bool: ...
    @staticmethod
    def is_valid(
        result: AsyncResult, source_object: typing.Optional[GObject.Object] = None
    ) -> bool: ...
    @classmethod
    def new(
        cls,
        source_object: typing.Optional[GObject.Object] = None,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *callback_data: typing.Any,
    ) -> Task: ...
    def propagate_boolean(self) -> bool: ...
    def propagate_int(self) -> int: ...
    def propagate_pointer(self) -> None: ...
    def propagate_value(self) -> typing.Tuple[bool, typing.Any]: ...
    @staticmethod
    def report_error(
        source_object: typing.Optional[GObject.Object],
        callback: typing.Optional[typing.Callable[..., None]],
        source_tag: None,
        error: GLib.Error,
        *callback_data: typing.Any,
    ) -> None: ...
    def return_boolean(self, result: bool) -> None: ...
    def return_error(self, error: GLib.Error) -> None: ...
    def return_error_if_cancelled(self) -> bool: ...
    def return_int(self, result: int) -> None: ...
    def return_new_error_literal(
        self, domain: int, code: int, message: str
    ) -> None: ...
    def return_pointer(
        self,
        result: None,
        result_destroy: typing.Optional[typing.Callable[[None], None]] = None,
    ) -> None: ...
    def return_value(self, result: typing.Optional[typing.Any] = None) -> None: ...
    def run_in_thread(
        self,
        task_func: typing.Callable[
            [Task, GObject.Object, None, typing.Optional[Cancellable]], None
        ],
    ) -> None: ...
    def run_in_thread_sync(
        self,
        task_func: typing.Callable[
            [Task, GObject.Object, None, typing.Optional[Cancellable]], None
        ],
    ) -> None: ...
    def set_check_cancellable(self, check_cancellable: bool) -> None: ...
    def set_name(self, name: typing.Optional[str] = None) -> None: ...
    def set_priority(self, priority: int) -> None: ...
    def set_return_on_cancel(self, return_on_cancel: bool) -> bool: ...
    def set_source_tag(self, source_tag: None) -> None: ...
    def set_static_name(self, name: typing.Optional[str] = None) -> None: ...
    def set_task_data(
        self,
        task_data: None,
        task_data_destroy: typing.Optional[typing.Callable[[None], None]] = None,
    ) -> None: ...

class TaskClass(GObject.GPointer): ...

class TcpConnection(SocketConnection):
    """
    :Constructors:

    ::

        TcpConnection(**properties)

    Object GTcpConnection

    Properties from GTcpConnection:
      graceful-disconnect -> gboolean: graceful-disconnect

    Properties from GSocketConnection:
      socket -> GSocket: socket

    Properties from GIOStream:
      input-stream -> GInputStream: input-stream
      output-stream -> GOutputStream: output-stream
      closed -> gboolean: closed

    Signals from GObject:
      notify (GParam)
    """
    class Props(SocketConnection.Props):
        graceful_disconnect: bool
        socket: Socket
        closed: bool
        input_stream: InputStream
        output_stream: OutputStream

    props: Props = ...
    parent_instance: SocketConnection = ...
    priv: TcpConnectionPrivate = ...
    def __init__(
        self, *, graceful_disconnect: bool = ..., socket: Socket = ...
    ) -> None: ...
    def get_graceful_disconnect(self) -> bool: ...
    def set_graceful_disconnect(self, graceful_disconnect: bool) -> None: ...

class TcpConnectionClass(GObject.GPointer):
    """
    :Constructors:

    ::

        TcpConnectionClass()
    """

    parent_class: SocketConnectionClass = ...

class TcpConnectionPrivate(GObject.GPointer): ...

class TcpWrapperConnection(TcpConnection):
    """
    :Constructors:

    ::

        TcpWrapperConnection(**properties)
        new(base_io_stream:Gio.IOStream, socket:Gio.Socket) -> Gio.SocketConnection

    Object GTcpWrapperConnection

    Properties from GTcpWrapperConnection:
      base-io-stream -> GIOStream: base-io-stream

    Properties from GTcpConnection:
      graceful-disconnect -> gboolean: graceful-disconnect

    Properties from GSocketConnection:
      socket -> GSocket: socket

    Properties from GIOStream:
      input-stream -> GInputStream: input-stream
      output-stream -> GOutputStream: output-stream
      closed -> gboolean: closed

    Signals from GObject:
      notify (GParam)
    """
    class Props(TcpConnection.Props):
        base_io_stream: IOStream
        graceful_disconnect: bool
        socket: Socket
        closed: bool
        input_stream: InputStream
        output_stream: OutputStream

    props: Props = ...
    parent_instance: TcpConnection = ...
    priv: TcpWrapperConnectionPrivate = ...
    def __init__(
        self,
        *,
        base_io_stream: IOStream = ...,
        graceful_disconnect: bool = ...,
        socket: Socket = ...,
    ) -> None: ...
    def get_base_io_stream(self) -> IOStream: ...
    @classmethod
    def new(cls, base_io_stream: IOStream, socket: Socket) -> TcpWrapperConnection: ...

class TcpWrapperConnectionClass(GObject.GPointer):
    """
    :Constructors:

    ::

        TcpWrapperConnectionClass()
    """

    parent_class: TcpConnectionClass = ...

class TcpWrapperConnectionPrivate(GObject.GPointer): ...

class TestDBus(GObject.Object):
    """
    :Constructors:

    ::

        TestDBus(**properties)
        new(flags:Gio.TestDBusFlags) -> Gio.TestDBus

    Object GTestDBus

    Properties from GTestDBus:
      flags -> GTestDBusFlags: flags

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        flags: TestDBusFlags

    props: Props = ...
    def __init__(self, *, flags: TestDBusFlags = ...) -> None: ...
    def add_service_dir(self, path: str) -> None: ...
    def down(self) -> None: ...
    def get_bus_address(self) -> typing.Optional[str]: ...
    def get_flags(self) -> TestDBusFlags: ...
    @classmethod
    def new(cls, flags: TestDBusFlags) -> TestDBus: ...
    def stop(self) -> None: ...
    @staticmethod
    def unset() -> None: ...
    def up(self) -> None: ...

class ThemedIcon(GObject.Object, Icon):
    """
    :Constructors:

    ::

        ThemedIcon(**properties)
        new(iconname:str) -> Gio.ThemedIcon
        new_from_names(iconnames:list) -> Gio.ThemedIcon
        new_with_default_fallbacks(iconname:str) -> Gio.ThemedIcon

    Object GThemedIcon

    Properties from GThemedIcon:
      name -> gchararray: name
      names -> GStrv: names
      use-default-fallbacks -> gboolean: use-default-fallbacks

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        names: list[str]
        use_default_fallbacks: bool
        name: str

    props: Props = ...
    # override
    def __init__(
        self,
        *,
        name: str = ...,
        names: typing.Sequence[str] = ...,
        use_default_fallbacks: bool = ...,
    ) -> None: ...
    def append_name(self, iconname: str) -> None: ...
    def get_names(self) -> list[str]: ...
    @classmethod
    def new(cls, iconname: str) -> ThemedIcon: ...
    @classmethod
    def new_from_names(cls, iconnames: typing.Sequence[str]) -> ThemedIcon: ...
    @classmethod
    def new_with_default_fallbacks(cls, iconname: str) -> ThemedIcon: ...
    def prepend_name(self, iconname: str) -> None: ...

class ThemedIconClass(GObject.GPointer): ...

class ThreadedResolver(Resolver):
    """
    :Constructors:

    ::

        ThreadedResolver(**properties)

    Object GThreadedResolver

    Signals from GResolver:
      reload ()

    Properties from GResolver:
      timeout -> guint: timeout

    Signals from GObject:
      notify (GParam)
    """
    class Props(Resolver.Props):
        timeout: int

    props: Props = ...
    def __init__(self, *, timeout: int = ...) -> None: ...

class ThreadedResolverClass(GObject.GPointer):
    """
    :Constructors:

    ::

        ThreadedResolverClass()
    """

    parent_class: ResolverClass = ...

class ThreadedSocketService(SocketService):
    """
    :Constructors:

    ::

        ThreadedSocketService(**properties)
        new(max_threads:int) -> Gio.SocketService

    Object GThreadedSocketService

    Signals from GThreadedSocketService:
      run (GSocketConnection, GObject) -> gboolean

    Properties from GThreadedSocketService:
      max-threads -> gint: max-threads

    Signals from GSocketService:
      incoming (GSocketConnection, GObject) -> gboolean

    Properties from GSocketService:
      active -> gboolean: active

    Signals from GSocketListener:
      event (GSocketListenerEvent, GSocket)

    Properties from GSocketListener:
      listen-backlog -> gint: listen-backlog

    Signals from GObject:
      notify (GParam)
    """
    class Props(SocketService.Props):
        max_threads: int
        active: bool
        listen_backlog: int

    props: Props = ...
    parent_instance: SocketService = ...
    priv: ThreadedSocketServicePrivate = ...
    def __init__(
        self, *, max_threads: int = ..., active: bool = ..., listen_backlog: int = ...
    ) -> None: ...
    def do_run(
        self, connection: SocketConnection, source_object: GObject.Object
    ) -> bool: ...
    @classmethod
    def new(cls, max_threads: int) -> ThreadedSocketService: ...

class ThreadedSocketServiceClass(GObject.GPointer):
    """
    :Constructors:

    ::

        ThreadedSocketServiceClass()
    """

    parent_class: SocketServiceClass = ...
    run: typing.Callable[
        [ThreadedSocketService, SocketConnection, GObject.Object], bool
    ] = ...

class ThreadedSocketServicePrivate(GObject.GPointer): ...

class TlsBackend(GObject.GInterface):
    """
    Interface GTlsBackend

    Signals from GObject:
      notify (GParam)
    """
    def get_certificate_type(self) -> typing.Type[typing.Any]: ...
    def get_client_connection_type(self) -> typing.Type[typing.Any]: ...
    @staticmethod
    def get_default() -> TlsBackend: ...
    def get_default_database(self) -> TlsDatabase: ...
    def get_dtls_client_connection_type(self) -> typing.Type[typing.Any]: ...
    def get_dtls_server_connection_type(self) -> typing.Type[typing.Any]: ...
    def get_file_database_type(self) -> typing.Type[typing.Any]: ...
    def get_server_connection_type(self) -> typing.Type[typing.Any]: ...
    def set_default_database(
        self, database: typing.Optional[TlsDatabase] = None
    ) -> None: ...
    def supports_dtls(self) -> bool: ...
    def supports_tls(self) -> bool: ...

class TlsBackendInterface(GObject.GPointer):
    """
    :Constructors:

    ::

        TlsBackendInterface()
    """

    g_iface: GObject.TypeInterface = ...
    supports_tls: typing.Callable[[TlsBackend], bool] = ...
    get_certificate_type: typing.Callable[[], typing.Type[typing.Any]] = ...
    get_client_connection_type: typing.Callable[[], typing.Type[typing.Any]] = ...
    get_server_connection_type: typing.Callable[[], typing.Type[typing.Any]] = ...
    get_file_database_type: typing.Callable[[], typing.Type[typing.Any]] = ...
    get_default_database: typing.Callable[[TlsBackend], TlsDatabase] = ...
    supports_dtls: typing.Callable[[TlsBackend], bool] = ...
    get_dtls_client_connection_type: typing.Callable[[], typing.Type[typing.Any]] = ...
    get_dtls_server_connection_type: typing.Callable[[], typing.Type[typing.Any]] = ...

class TlsCertificate(GObject.Object):
    """
    :Constructors:

    ::

        TlsCertificate(**properties)
        new_from_file(file:str) -> Gio.TlsCertificate
        new_from_file_with_password(file:str, password:str) -> Gio.TlsCertificate
        new_from_files(cert_file:str, key_file:str) -> Gio.TlsCertificate
        new_from_pem(data:str, length:int) -> Gio.TlsCertificate
        new_from_pkcs11_uris(pkcs11_uri:str, private_key_pkcs11_uri:str=None) -> Gio.TlsCertificate
        new_from_pkcs12(data:list, password:str=None) -> Gio.TlsCertificate

    Object GTlsCertificate

    Properties from GTlsCertificate:
      certificate -> GByteArray: certificate
      certificate-pem -> gchararray: certificate-pem
      private-key -> GByteArray: private-key
      private-key-pem -> gchararray: private-key-pem
      issuer -> GTlsCertificate: issuer
      pkcs11-uri -> gchararray: pkcs11-uri
      private-key-pkcs11-uri -> gchararray: private-key-pkcs11-uri
      not-valid-before -> GDateTime: not-valid-before
      not-valid-after -> GDateTime: not-valid-after
      subject-name -> gchararray: subject-name
      issuer-name -> gchararray: issuer-name
      dns-names -> GPtrArray: dns-names
      ip-addresses -> GPtrArray: ip-addresses
      pkcs12-data -> GByteArray: pkcs12-data
      password -> gchararray: password

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        certificate: bytes
        certificate_pem: str
        dns_names: typing.Optional[list[None]]
        ip_addresses: typing.Optional[list[None]]
        issuer: typing.Optional[TlsCertificate]
        issuer_name: typing.Optional[str]
        not_valid_after: typing.Optional[GLib.DateTime]
        not_valid_before: typing.Optional[GLib.DateTime]
        pkcs11_uri: str
        private_key: bytes
        private_key_pem: str
        private_key_pkcs11_uri: str
        subject_name: typing.Optional[str]
        password: str
        pkcs12_data: bytes

    props: Props = ...
    parent_instance: GObject.Object = ...
    priv: TlsCertificatePrivate = ...
    def __init__(
        self,
        *,
        certificate: typing.Sequence[int] = ...,
        certificate_pem: str = ...,
        issuer: TlsCertificate = ...,
        password: str = ...,
        pkcs11_uri: str = ...,
        pkcs12_data: typing.Sequence[int] = ...,
        private_key: typing.Sequence[int] = ...,
        private_key_pem: str = ...,
        private_key_pkcs11_uri: str = ...,
    ) -> None: ...
    def do_verify(
        self,
        identity: typing.Optional[SocketConnectable] = None,
        trusted_ca: typing.Optional[TlsCertificate] = None,
    ) -> TlsCertificateFlags: ...
    def get_dns_names(self) -> typing.Optional[list[GLib.Bytes]]: ...
    def get_ip_addresses(self) -> typing.Optional[list[InetAddress]]: ...
    def get_issuer(self) -> typing.Optional[TlsCertificate]: ...
    def get_issuer_name(self) -> typing.Optional[str]: ...
    def get_not_valid_after(self) -> typing.Optional[GLib.DateTime]: ...
    def get_not_valid_before(self) -> typing.Optional[GLib.DateTime]: ...
    def get_subject_name(self) -> typing.Optional[str]: ...
    def is_same(self, cert_two: TlsCertificate) -> bool: ...
    @staticmethod
    def list_new_from_file(file: str) -> list[TlsCertificate]: ...
    @classmethod
    def new_from_file(cls, file: str) -> TlsCertificate: ...
    @classmethod
    def new_from_file_with_password(
        cls, file: str, password: str
    ) -> TlsCertificate: ...
    @classmethod
    def new_from_files(cls, cert_file: str, key_file: str) -> TlsCertificate: ...
    @classmethod
    def new_from_pem(cls, data: str, length: int) -> TlsCertificate: ...
    @classmethod
    def new_from_pkcs11_uris(
        cls, pkcs11_uri: str, private_key_pkcs11_uri: typing.Optional[str] = None
    ) -> TlsCertificate: ...
    @classmethod
    def new_from_pkcs12(
        cls, data: typing.Sequence[int], password: typing.Optional[str] = None
    ) -> TlsCertificate: ...
    def verify(
        self,
        identity: typing.Optional[SocketConnectable] = None,
        trusted_ca: typing.Optional[TlsCertificate] = None,
    ) -> TlsCertificateFlags: ...

class TlsCertificateClass(GObject.GPointer):
    """
    :Constructors:

    ::

        TlsCertificateClass()
    """

    parent_class: GObject.ObjectClass = ...
    verify: typing.Callable[
        [
            TlsCertificate,
            typing.Optional[SocketConnectable],
            typing.Optional[TlsCertificate],
        ],
        TlsCertificateFlags,
    ] = ...
    padding: list[None] = ...

class TlsCertificatePrivate(GObject.GPointer): ...

class TlsClientConnection(GObject.GInterface):
    """
    Interface GTlsClientConnection

    Signals from GObject:
      notify (GParam)
    """
    def copy_session_state(self, source: TlsClientConnection) -> None: ...
    def get_accepted_cas(self) -> list[typing.Sequence[int]]: ...
    def get_server_identity(self) -> typing.Optional[SocketConnectable]: ...
    def get_use_ssl3(self) -> bool: ...
    def get_validation_flags(self) -> TlsCertificateFlags: ...
    @staticmethod
    def new(
        base_io_stream: IOStream,
        server_identity: typing.Optional[SocketConnectable] = None,
    ) -> TlsClientConnection: ...
    def set_server_identity(self, identity: SocketConnectable) -> None: ...
    def set_use_ssl3(self, use_ssl3: bool) -> None: ...
    def set_validation_flags(self, flags: TlsCertificateFlags) -> None: ...

class TlsClientConnectionInterface(GObject.GPointer):
    """
    :Constructors:

    ::

        TlsClientConnectionInterface()
    """

    g_iface: GObject.TypeInterface = ...
    copy_session_state: typing.Callable[
        [TlsClientConnection, TlsClientConnection], None
    ] = ...

class TlsConnection(IOStream):
    """
    :Constructors:

    ::

        TlsConnection(**properties)

    Object GTlsConnection

    Signals from GTlsConnection:
      accept-certificate (GTlsCertificate, GTlsCertificateFlags) -> gboolean

    Properties from GTlsConnection:
      base-io-stream -> GIOStream: base-io-stream
      require-close-notify -> gboolean: require-close-notify
      rehandshake-mode -> GTlsRehandshakeMode: rehandshake-mode
      use-system-certdb -> gboolean: use-system-certdb
      database -> GTlsDatabase: database
      interaction -> GTlsInteraction: interaction
      certificate -> GTlsCertificate: certificate
      peer-certificate -> GTlsCertificate: peer-certificate
      peer-certificate-errors -> GTlsCertificateFlags: peer-certificate-errors
      advertised-protocols -> GStrv: advertised-protocols
      negotiated-protocol -> gchararray: negotiated-protocol
      protocol-version -> GTlsProtocolVersion: protocol-version
      ciphersuite-name -> gchararray: ciphersuite-name

    Properties from GIOStream:
      input-stream -> GInputStream: input-stream
      output-stream -> GOutputStream: output-stream
      closed -> gboolean: closed

    Signals from GObject:
      notify (GParam)
    """
    class Props(IOStream.Props):
        advertised_protocols: typing.Optional[list[str]]
        base_io_stream: IOStream
        certificate: typing.Optional[TlsCertificate]
        ciphersuite_name: typing.Optional[str]
        database: typing.Optional[TlsDatabase]
        interaction: typing.Optional[TlsInteraction]
        negotiated_protocol: typing.Optional[str]
        peer_certificate: typing.Optional[TlsCertificate]
        peer_certificate_errors: TlsCertificateFlags
        protocol_version: TlsProtocolVersion
        rehandshake_mode: TlsRehandshakeMode
        require_close_notify: bool
        use_system_certdb: bool
        closed: bool
        input_stream: InputStream
        output_stream: OutputStream

    props: Props = ...
    parent_instance: IOStream = ...
    priv: TlsConnectionPrivate = ...
    def __init__(
        self,
        *,
        advertised_protocols: typing.Optional[typing.Sequence[str]] = ...,
        base_io_stream: IOStream = ...,
        certificate: TlsCertificate = ...,
        database: typing.Optional[TlsDatabase] = ...,
        interaction: typing.Optional[TlsInteraction] = ...,
        rehandshake_mode: TlsRehandshakeMode = ...,
        require_close_notify: bool = ...,
        use_system_certdb: bool = ...,
    ) -> None: ...
    def do_accept_certificate(
        self, peer_cert: TlsCertificate, errors: TlsCertificateFlags
    ) -> bool: ...
    def do_get_binding_data(
        self, type: TlsChannelBindingType, data: typing.Sequence[int]
    ) -> bool: ...
    def do_get_negotiated_protocol(self) -> typing.Optional[str]: ...
    def do_handshake(
        self, cancellable: typing.Optional[Cancellable] = None
    ) -> bool: ...
    def do_handshake_async(
        self,
        io_priority: int,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def do_handshake_finish(self, result: AsyncResult) -> bool: ...
    def emit_accept_certificate(
        self, peer_cert: TlsCertificate, errors: TlsCertificateFlags
    ) -> bool: ...
    def get_certificate(self) -> typing.Optional[TlsCertificate]: ...
    def get_channel_binding_data(
        self, type: TlsChannelBindingType
    ) -> typing.Tuple[bool, bytes]: ...
    def get_ciphersuite_name(self) -> typing.Optional[str]: ...
    def get_database(self) -> typing.Optional[TlsDatabase]: ...
    def get_interaction(self) -> typing.Optional[TlsInteraction]: ...
    def get_negotiated_protocol(self) -> typing.Optional[str]: ...
    def get_peer_certificate(self) -> typing.Optional[TlsCertificate]: ...
    def get_peer_certificate_errors(self) -> TlsCertificateFlags: ...
    def get_protocol_version(self) -> TlsProtocolVersion: ...
    def get_rehandshake_mode(self) -> TlsRehandshakeMode: ...
    def get_require_close_notify(self) -> bool: ...
    def get_use_system_certdb(self) -> bool: ...
    def handshake(self, cancellable: typing.Optional[Cancellable] = None) -> bool: ...
    def handshake_async(
        self,
        io_priority: int,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def handshake_finish(self, result: AsyncResult) -> bool: ...
    def set_advertised_protocols(
        self, protocols: typing.Optional[typing.Sequence[str]] = None
    ) -> None: ...
    def set_certificate(self, certificate: TlsCertificate) -> None: ...
    def set_database(self, database: typing.Optional[TlsDatabase] = None) -> None: ...
    def set_interaction(
        self, interaction: typing.Optional[TlsInteraction] = None
    ) -> None: ...
    def set_rehandshake_mode(self, mode: TlsRehandshakeMode) -> None: ...
    def set_require_close_notify(self, require_close_notify: bool) -> None: ...
    def set_use_system_certdb(self, use_system_certdb: bool) -> None: ...

class TlsConnectionClass(GObject.GPointer):
    """
    :Constructors:

    ::

        TlsConnectionClass()
    """

    parent_class: IOStreamClass = ...
    accept_certificate: typing.Callable[
        [TlsConnection, TlsCertificate, TlsCertificateFlags], bool
    ] = ...
    handshake: typing.Callable[
        [TlsConnection, typing.Optional[Cancellable]], bool
    ] = ...
    handshake_async: typing.Callable[..., None] = ...
    handshake_finish: typing.Callable[[TlsConnection, AsyncResult], bool] = ...
    get_binding_data: typing.Callable[
        [TlsConnection, TlsChannelBindingType, typing.Sequence[int]], bool
    ] = ...
    get_negotiated_protocol: typing.Callable[
        [TlsConnection], typing.Optional[str]
    ] = ...
    padding: list[None] = ...

class TlsConnectionPrivate(GObject.GPointer): ...

class TlsDatabase(GObject.Object):
    """
    :Constructors:

    ::

        TlsDatabase(**properties)

    Object GTlsDatabase

    Signals from GObject:
      notify (GParam)
    """

    parent_instance: GObject.Object = ...
    priv: TlsDatabasePrivate = ...
    def create_certificate_handle(
        self, certificate: TlsCertificate
    ) -> typing.Optional[str]: ...
    def do_create_certificate_handle(
        self, certificate: TlsCertificate
    ) -> typing.Optional[str]: ...
    def do_lookup_certificate_for_handle(
        self,
        handle: str,
        interaction: typing.Optional[TlsInteraction],
        flags: TlsDatabaseLookupFlags,
        cancellable: typing.Optional[Cancellable] = None,
    ) -> typing.Optional[TlsCertificate]: ...
    def do_lookup_certificate_for_handle_async(
        self,
        handle: str,
        interaction: typing.Optional[TlsInteraction],
        flags: TlsDatabaseLookupFlags,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def do_lookup_certificate_for_handle_finish(
        self, result: AsyncResult
    ) -> TlsCertificate: ...
    def do_lookup_certificate_issuer(
        self,
        certificate: TlsCertificate,
        interaction: typing.Optional[TlsInteraction],
        flags: TlsDatabaseLookupFlags,
        cancellable: typing.Optional[Cancellable] = None,
    ) -> TlsCertificate: ...
    def do_lookup_certificate_issuer_async(
        self,
        certificate: TlsCertificate,
        interaction: typing.Optional[TlsInteraction],
        flags: TlsDatabaseLookupFlags,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def do_lookup_certificate_issuer_finish(
        self, result: AsyncResult
    ) -> TlsCertificate: ...
    def do_lookup_certificates_issued_by(
        self,
        issuer_raw_dn: typing.Sequence[int],
        interaction: typing.Optional[TlsInteraction],
        flags: TlsDatabaseLookupFlags,
        cancellable: typing.Optional[Cancellable] = None,
    ) -> list[TlsCertificate]: ...
    def do_lookup_certificates_issued_by_async(
        self,
        issuer_raw_dn: typing.Sequence[int],
        interaction: typing.Optional[TlsInteraction],
        flags: TlsDatabaseLookupFlags,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def do_lookup_certificates_issued_by_finish(
        self, result: AsyncResult
    ) -> list[TlsCertificate]: ...
    def do_verify_chain(
        self,
        chain: TlsCertificate,
        purpose: str,
        identity: typing.Optional[SocketConnectable],
        interaction: typing.Optional[TlsInteraction],
        flags: TlsDatabaseVerifyFlags,
        cancellable: typing.Optional[Cancellable] = None,
    ) -> TlsCertificateFlags: ...
    def do_verify_chain_async(
        self,
        chain: TlsCertificate,
        purpose: str,
        identity: typing.Optional[SocketConnectable],
        interaction: typing.Optional[TlsInteraction],
        flags: TlsDatabaseVerifyFlags,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def do_verify_chain_finish(self, result: AsyncResult) -> TlsCertificateFlags: ...
    def lookup_certificate_for_handle(
        self,
        handle: str,
        interaction: typing.Optional[TlsInteraction],
        flags: TlsDatabaseLookupFlags,
        cancellable: typing.Optional[Cancellable] = None,
    ) -> typing.Optional[TlsCertificate]: ...
    def lookup_certificate_for_handle_async(
        self,
        handle: str,
        interaction: typing.Optional[TlsInteraction],
        flags: TlsDatabaseLookupFlags,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def lookup_certificate_for_handle_finish(
        self, result: AsyncResult
    ) -> TlsCertificate: ...
    def lookup_certificate_issuer(
        self,
        certificate: TlsCertificate,
        interaction: typing.Optional[TlsInteraction],
        flags: TlsDatabaseLookupFlags,
        cancellable: typing.Optional[Cancellable] = None,
    ) -> TlsCertificate: ...
    def lookup_certificate_issuer_async(
        self,
        certificate: TlsCertificate,
        interaction: typing.Optional[TlsInteraction],
        flags: TlsDatabaseLookupFlags,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def lookup_certificate_issuer_finish(
        self, result: AsyncResult
    ) -> TlsCertificate: ...
    def lookup_certificates_issued_by(
        self,
        issuer_raw_dn: typing.Sequence[int],
        interaction: typing.Optional[TlsInteraction],
        flags: TlsDatabaseLookupFlags,
        cancellable: typing.Optional[Cancellable] = None,
    ) -> list[TlsCertificate]: ...
    def lookup_certificates_issued_by_async(
        self,
        issuer_raw_dn: typing.Sequence[int],
        interaction: typing.Optional[TlsInteraction],
        flags: TlsDatabaseLookupFlags,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def lookup_certificates_issued_by_finish(
        self, result: AsyncResult
    ) -> list[TlsCertificate]: ...
    def verify_chain(
        self,
        chain: TlsCertificate,
        purpose: str,
        identity: typing.Optional[SocketConnectable],
        interaction: typing.Optional[TlsInteraction],
        flags: TlsDatabaseVerifyFlags,
        cancellable: typing.Optional[Cancellable] = None,
    ) -> TlsCertificateFlags: ...
    def verify_chain_async(
        self,
        chain: TlsCertificate,
        purpose: str,
        identity: typing.Optional[SocketConnectable],
        interaction: typing.Optional[TlsInteraction],
        flags: TlsDatabaseVerifyFlags,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def verify_chain_finish(self, result: AsyncResult) -> TlsCertificateFlags: ...

class TlsDatabaseClass(GObject.GPointer):
    """
    :Constructors:

    ::

        TlsDatabaseClass()
    """

    parent_class: GObject.ObjectClass = ...
    verify_chain: typing.Callable[
        [
            TlsDatabase,
            TlsCertificate,
            str,
            typing.Optional[SocketConnectable],
            typing.Optional[TlsInteraction],
            TlsDatabaseVerifyFlags,
            typing.Optional[Cancellable],
        ],
        TlsCertificateFlags,
    ] = ...
    verify_chain_async: typing.Callable[..., None] = ...
    verify_chain_finish: typing.Callable[
        [TlsDatabase, AsyncResult], TlsCertificateFlags
    ] = ...
    create_certificate_handle: typing.Callable[
        [TlsDatabase, TlsCertificate], typing.Optional[str]
    ] = ...
    lookup_certificate_for_handle: typing.Callable[
        [
            TlsDatabase,
            str,
            typing.Optional[TlsInteraction],
            TlsDatabaseLookupFlags,
            typing.Optional[Cancellable],
        ],
        typing.Optional[TlsCertificate],
    ] = ...
    lookup_certificate_for_handle_async: typing.Callable[..., None] = ...
    lookup_certificate_for_handle_finish: typing.Callable[
        [TlsDatabase, AsyncResult], TlsCertificate
    ] = ...
    lookup_certificate_issuer: typing.Callable[
        [
            TlsDatabase,
            TlsCertificate,
            typing.Optional[TlsInteraction],
            TlsDatabaseLookupFlags,
            typing.Optional[Cancellable],
        ],
        TlsCertificate,
    ] = ...
    lookup_certificate_issuer_async: typing.Callable[..., None] = ...
    lookup_certificate_issuer_finish: typing.Callable[
        [TlsDatabase, AsyncResult], TlsCertificate
    ] = ...
    lookup_certificates_issued_by: typing.Callable[
        [
            TlsDatabase,
            typing.Sequence[int],
            typing.Optional[TlsInteraction],
            TlsDatabaseLookupFlags,
            typing.Optional[Cancellable],
        ],
        list[TlsCertificate],
    ] = ...
    lookup_certificates_issued_by_async: typing.Callable[..., None] = ...
    lookup_certificates_issued_by_finish: typing.Callable[
        [TlsDatabase, AsyncResult], list[TlsCertificate]
    ] = ...
    padding: list[None] = ...

class TlsDatabasePrivate(GObject.GPointer): ...

class TlsFileDatabase(GObject.GInterface):
    """
    Interface GTlsFileDatabase

    Signals from GObject:
      notify (GParam)
    """
    @staticmethod
    def new(anchors: str) -> TlsFileDatabase: ...

class TlsFileDatabaseInterface(GObject.GPointer):
    """
    :Constructors:

    ::

        TlsFileDatabaseInterface()
    """

    g_iface: GObject.TypeInterface = ...
    padding: list[None] = ...

class TlsInteraction(GObject.Object):
    """
    :Constructors:

    ::

        TlsInteraction(**properties)

    Object GTlsInteraction

    Signals from GObject:
      notify (GParam)
    """

    parent_instance: GObject.Object = ...
    priv: TlsInteractionPrivate = ...
    def ask_password(
        self, password: TlsPassword, cancellable: typing.Optional[Cancellable] = None
    ) -> TlsInteractionResult: ...
    def ask_password_async(
        self,
        password: TlsPassword,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def ask_password_finish(self, result: AsyncResult) -> TlsInteractionResult: ...
    def do_ask_password(
        self, password: TlsPassword, cancellable: typing.Optional[Cancellable] = None
    ) -> TlsInteractionResult: ...
    def do_ask_password_async(
        self,
        password: TlsPassword,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def do_ask_password_finish(self, result: AsyncResult) -> TlsInteractionResult: ...
    def do_request_certificate(
        self,
        connection: TlsConnection,
        flags: TlsCertificateRequestFlags,
        cancellable: typing.Optional[Cancellable] = None,
    ) -> TlsInteractionResult: ...
    def do_request_certificate_async(
        self,
        connection: TlsConnection,
        flags: TlsCertificateRequestFlags,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def do_request_certificate_finish(
        self, result: AsyncResult
    ) -> TlsInteractionResult: ...
    def invoke_ask_password(
        self, password: TlsPassword, cancellable: typing.Optional[Cancellable] = None
    ) -> TlsInteractionResult: ...
    def invoke_request_certificate(
        self,
        connection: TlsConnection,
        flags: TlsCertificateRequestFlags,
        cancellable: typing.Optional[Cancellable] = None,
    ) -> TlsInteractionResult: ...
    def request_certificate(
        self,
        connection: TlsConnection,
        flags: TlsCertificateRequestFlags,
        cancellable: typing.Optional[Cancellable] = None,
    ) -> TlsInteractionResult: ...
    def request_certificate_async(
        self,
        connection: TlsConnection,
        flags: TlsCertificateRequestFlags,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def request_certificate_finish(
        self, result: AsyncResult
    ) -> TlsInteractionResult: ...

class TlsInteractionClass(GObject.GPointer):
    """
    :Constructors:

    ::

        TlsInteractionClass()
    """

    parent_class: GObject.ObjectClass = ...
    ask_password: typing.Callable[
        [TlsInteraction, TlsPassword, typing.Optional[Cancellable]],
        TlsInteractionResult,
    ] = ...
    ask_password_async: typing.Callable[..., None] = ...
    ask_password_finish: typing.Callable[
        [TlsInteraction, AsyncResult], TlsInteractionResult
    ] = ...
    request_certificate: typing.Callable[
        [
            TlsInteraction,
            TlsConnection,
            TlsCertificateRequestFlags,
            typing.Optional[Cancellable],
        ],
        TlsInteractionResult,
    ] = ...
    request_certificate_async: typing.Callable[..., None] = ...
    request_certificate_finish: typing.Callable[
        [TlsInteraction, AsyncResult], TlsInteractionResult
    ] = ...
    padding: list[None] = ...

class TlsInteractionPrivate(GObject.GPointer): ...

class TlsPassword(GObject.Object):
    """
    :Constructors:

    ::

        TlsPassword(**properties)
        new(flags:Gio.TlsPasswordFlags, description:str) -> Gio.TlsPassword

    Object GTlsPassword

    Properties from GTlsPassword:
      flags -> GTlsPasswordFlags: flags
      description -> gchararray: description
      warning -> gchararray: warning

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        description: str
        flags: TlsPasswordFlags
        warning: str

    props: Props = ...
    parent_instance: GObject.Object = ...
    priv: TlsPasswordPrivate = ...
    def __init__(
        self,
        *,
        description: str = ...,
        flags: TlsPasswordFlags = ...,
        warning: str = ...,
    ) -> None: ...
    def do_get_default_warning(self) -> str: ...
    def do_get_value(self) -> bytes: ...
    def do_set_value(
        self,
        value: typing.Sequence[int],
        destroy: typing.Optional[typing.Callable[[None], None]] = None,
    ) -> None: ...
    def get_description(self) -> str: ...
    def get_flags(self) -> TlsPasswordFlags: ...
    def get_value(self) -> bytes: ...
    def get_warning(self) -> str: ...
    @classmethod
    def new(cls, flags: TlsPasswordFlags, description: str) -> TlsPassword: ...
    def set_description(self, description: str) -> None: ...
    def set_flags(self, flags: TlsPasswordFlags) -> None: ...
    def set_value(self, value: typing.Sequence[int]) -> None: ...
    def set_value_full(
        self,
        value: typing.Sequence[int],
        destroy: typing.Optional[typing.Callable[[None], None]] = None,
    ) -> None: ...
    def set_warning(self, warning: str) -> None: ...

class TlsPasswordClass(GObject.GPointer):
    """
    :Constructors:

    ::

        TlsPasswordClass()
    """

    parent_class: GObject.ObjectClass = ...
    get_value: typing.Callable[[TlsPassword], bytes] = ...
    set_value: typing.Callable[
        [
            TlsPassword,
            typing.Sequence[int],
            typing.Optional[typing.Callable[[None], None]],
        ],
        None,
    ] = ...
    get_default_warning: typing.Callable[[TlsPassword], str] = ...
    padding: list[None] = ...

class TlsPasswordPrivate(GObject.GPointer): ...

class TlsServerConnection(GObject.GInterface):
    """
    Interface GTlsServerConnection

    Signals from GObject:
      notify (GParam)
    """
    @staticmethod
    def new(
        base_io_stream: IOStream, certificate: typing.Optional[TlsCertificate] = None
    ) -> TlsServerConnection: ...

class TlsServerConnectionInterface(GObject.GPointer):
    """
    :Constructors:

    ::

        TlsServerConnectionInterface()
    """

    g_iface: GObject.TypeInterface = ...

class UnixConnection(SocketConnection):
    """
    :Constructors:

    ::

        UnixConnection(**properties)

    Object GUnixConnection

    Properties from GSocketConnection:
      socket -> GSocket: socket

    Properties from GIOStream:
      input-stream -> GInputStream: input-stream
      output-stream -> GOutputStream: output-stream
      closed -> gboolean: closed

    Signals from GObject:
      notify (GParam)
    """
    class Props(SocketConnection.Props):
        socket: Socket
        closed: bool
        input_stream: InputStream
        output_stream: OutputStream

    props: Props = ...
    parent_instance: SocketConnection = ...
    priv: UnixConnectionPrivate = ...
    def __init__(self, *, socket: Socket = ...) -> None: ...
    def receive_credentials(
        self, cancellable: typing.Optional[Cancellable] = None
    ) -> Credentials: ...
    def receive_credentials_async(
        self,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def receive_credentials_finish(self, result: AsyncResult) -> Credentials: ...
    def receive_fd(self, cancellable: typing.Optional[Cancellable] = None) -> int: ...
    def send_credentials(
        self, cancellable: typing.Optional[Cancellable] = None
    ) -> bool: ...
    def send_credentials_async(
        self,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def send_credentials_finish(self, result: AsyncResult) -> bool: ...
    def send_fd(
        self, fd: int, cancellable: typing.Optional[Cancellable] = None
    ) -> bool: ...

class UnixConnectionClass(GObject.GPointer):
    """
    :Constructors:

    ::

        UnixConnectionClass()
    """

    parent_class: SocketConnectionClass = ...

class UnixConnectionPrivate(GObject.GPointer): ...

class UnixCredentialsMessage(SocketControlMessage):
    """
    :Constructors:

    ::

        UnixCredentialsMessage(**properties)
        new() -> Gio.SocketControlMessage
        new_with_credentials(credentials:Gio.Credentials) -> Gio.SocketControlMessage

    Object GUnixCredentialsMessage

    Properties from GUnixCredentialsMessage:
      credentials -> GCredentials: credentials

    Signals from GObject:
      notify (GParam)
    """
    class Props(SocketControlMessage.Props):
        credentials: Credentials

    props: Props = ...
    parent_instance: SocketControlMessage = ...
    priv: UnixCredentialsMessagePrivate = ...
    def __init__(self, *, credentials: Credentials = ...) -> None: ...
    def get_credentials(self) -> Credentials: ...
    @staticmethod
    def is_supported() -> bool: ...
    @classmethod
    def new(cls) -> UnixCredentialsMessage: ...
    @classmethod
    def new_with_credentials(
        cls, credentials: Credentials
    ) -> UnixCredentialsMessage: ...

class UnixCredentialsMessageClass(GObject.GPointer):
    """
    :Constructors:

    ::

        UnixCredentialsMessageClass()
    """

    parent_class: SocketControlMessageClass = ...

class UnixCredentialsMessagePrivate(GObject.GPointer): ...

class UnixDesktopAppInfoClass(GObject.GPointer):
    """
    :Constructors:

    ::

        DesktopAppInfoClass()
    """

    parent_class: GObject.ObjectClass = ...

class UnixDesktopAppInfoLookupIface(GObject.GPointer):
    """
    :Constructors:

    ::

        DesktopAppInfoLookupIface()
    """

    g_iface: GObject.TypeInterface = ...
    get_default_for_uri_scheme: typing.Callable[
        [GioUnix.DesktopAppInfoLookup, str], typing.Optional[AppInfo]
    ] = ...

class UnixFDList(GObject.Object):
    """
    :Constructors:

    ::

        UnixFDList(**properties)
        new() -> Gio.UnixFDList
        new_from_array(fds:list) -> Gio.UnixFDList

    Object GUnixFDList

    Signals from GObject:
      notify (GParam)
    """

    parent_instance: GObject.Object = ...
    priv: UnixFDListPrivate = ...
    def append(self, fd: int) -> int: ...
    def get(self, index_: int) -> int: ...
    def get_length(self) -> int: ...
    @classmethod
    def new(cls) -> UnixFDList: ...
    @classmethod
    def new_from_array(cls, fds: typing.Sequence[int]) -> UnixFDList: ...
    def peek_fds(self) -> list[int]: ...
    def steal_fds(self) -> list[int]: ...

class UnixFDListClass(GObject.GPointer):
    """
    :Constructors:

    ::

        UnixFDListClass()
    """

    parent_class: GObject.ObjectClass = ...

class UnixFDListPrivate(GObject.GPointer): ...

class UnixFDMessage(SocketControlMessage):
    """
    :Constructors:

    ::

        FDMessage(**properties)
        new() -> Gio.SocketControlMessage
        new_with_fd_list(fd_list:Gio.UnixFDList) -> Gio.SocketControlMessage

    Object GUnixFDMessage

    Properties from GUnixFDMessage:
      fd-list -> GUnixFDList: fd-list

    Signals from GObject:
      notify (GParam)
    """
    class Props(SocketControlMessage.Props):
        fd_list: UnixFDList

    props: Props = ...
    parent_instance: SocketControlMessage = ...
    priv: GioUnix.FDMessagePrivate = ...
    def __init__(self, *, fd_list: UnixFDList = ...) -> None: ...
    def append_fd(self, fd: int) -> bool: ...
    def get_fd_list(self) -> UnixFDList: ...
    @classmethod
    def new(cls) -> FDMessage: ...
    @classmethod
    def new_with_fd_list(cls, fd_list: UnixFDList) -> FDMessage: ...
    def steal_fds(self) -> list[int]: ...

class UnixFDMessageClass(GObject.GPointer):
    """
    :Constructors:

    ::

        FDMessageClass()
    """

    parent_class: SocketControlMessageClass = ...

class UnixFDMessagePrivate(GObject.GPointer): ...

class UnixFileDescriptorBasedIface(GObject.GPointer):
    """
    :Constructors:

    ::

        FileDescriptorBasedIface()
    """

    g_iface: GObject.TypeInterface = ...
    get_fd: typing.Callable[[GioUnix.FileDescriptorBased], int] = ...

class UnixInputStream(InputStream, PollableInputStream, GioUnix.FileDescriptorBased):
    """
    :Constructors:

    ::

        InputStream(**properties)
        new(fd:int, close_fd:bool) -> Gio.InputStream

    Object GUnixInputStream

    Properties from GUnixInputStream:
      fd -> gint: fd
      close-fd -> gboolean: close-fd

    Signals from GObject:
      notify (GParam)
    """
    class Props(InputStream.Props):
        close_fd: bool
        fd: int

    props: Props = ...
    parent_instance: InputStream = ...
    priv: GioUnix.InputStreamPrivate = ...
    def __init__(self, *, close_fd: bool = ..., fd: int = ...) -> None: ...
    def get_close_fd(self) -> bool: ...
    def get_fd(self) -> int: ...
    @classmethod
    def new(cls, fd: int, close_fd: bool) -> InputStream: ...
    def set_close_fd(self, close_fd: bool) -> None: ...

class UnixInputStreamClass(GObject.GPointer):
    """
    :Constructors:

    ::

        InputStreamClass()
    """

    parent_class: InputStreamClass = ...

class UnixInputStreamPrivate(GObject.GPointer): ...

class UnixMountEntry(GObject.GBoxed):
    @staticmethod
    def at(
        mount_path: str,
    ) -> typing.Tuple[typing.Optional[GioUnix.MountEntry], int]: ...
    def compare(self, mount2: GioUnix.MountEntry) -> int: ...
    def copy(self) -> GioUnix.MountEntry: ...
    @staticmethod
    def for_(
        file_path: str,
    ) -> typing.Tuple[typing.Optional[GioUnix.MountEntry], int]: ...
    def free(self) -> None: ...
    def get_device_path(self) -> str: ...
    def get_fs_type(self) -> str: ...
    def get_mount_path(self) -> str: ...
    def get_options(self) -> typing.Optional[str]: ...
    def get_root_path(self) -> typing.Optional[str]: ...
    def guess_can_eject(self) -> bool: ...
    def guess_icon(self) -> Icon: ...
    def guess_name(self) -> str: ...
    def guess_should_display(self) -> bool: ...
    def guess_symbolic_icon(self) -> Icon: ...
    def is_readonly(self) -> bool: ...
    def is_system_internal(self) -> bool: ...

class UnixMountMonitor(GObject.Object):
    """
    :Constructors:

    ::

        MountMonitor(**properties)
        new() -> GioUnix.MountMonitor

    Object GUnixMountMonitor

    Signals from GUnixMountMonitor:
      mounts-changed ()
      mountpoints-changed ()

    Signals from GObject:
      notify (GParam)
    """
    @staticmethod
    def get() -> GioUnix.MountMonitor: ...
    @classmethod
    def new(cls) -> MountMonitor: ...
    def set_rate_limit(self, limit_msec: int) -> None: ...

class UnixMountMonitorClass(GObject.GPointer): ...

class UnixMountPoint(GObject.GBoxed):
    @staticmethod
    def at(
        mount_path: str,
    ) -> typing.Tuple[typing.Optional[GioUnix.MountPoint], int]: ...
    def compare(self, mount2: GioUnix.MountPoint) -> int: ...
    def copy(self) -> GioUnix.MountPoint: ...
    def free(self) -> None: ...
    def get_device_path(self) -> str: ...
    def get_fs_type(self) -> str: ...
    def get_mount_path(self) -> str: ...
    def get_options(self) -> typing.Optional[str]: ...
    def guess_can_eject(self) -> bool: ...
    def guess_icon(self) -> Icon: ...
    def guess_name(self) -> str: ...
    def guess_symbolic_icon(self) -> Icon: ...
    def is_loopback(self) -> bool: ...
    def is_readonly(self) -> bool: ...
    def is_user_mountable(self) -> bool: ...

class UnixOutputStream(OutputStream, PollableOutputStream, GioUnix.FileDescriptorBased):
    """
    :Constructors:

    ::

        OutputStream(**properties)
        new(fd:int, close_fd:bool) -> Gio.OutputStream

    Object GUnixOutputStream

    Properties from GUnixOutputStream:
      fd -> gint: fd
      close-fd -> gboolean: close-fd

    Signals from GObject:
      notify (GParam)
    """
    class Props(OutputStream.Props):
        close_fd: bool
        fd: int

    props: Props = ...
    parent_instance: OutputStream = ...
    priv: GioUnix.OutputStreamPrivate = ...
    def __init__(self, *, close_fd: bool = ..., fd: int = ...) -> None: ...
    def get_close_fd(self) -> bool: ...
    def get_fd(self) -> int: ...
    @classmethod
    def new(cls, fd: int, close_fd: bool) -> OutputStream: ...
    def set_close_fd(self, close_fd: bool) -> None: ...

class UnixOutputStreamClass(GObject.GPointer):
    """
    :Constructors:

    ::

        OutputStreamClass()
    """

    parent_class: OutputStreamClass = ...

class UnixOutputStreamPrivate(GObject.GPointer): ...

class UnixSocketAddress(SocketAddress, SocketConnectable):
    """
    :Constructors:

    ::

        UnixSocketAddress(**properties)
        new(path:str) -> Gio.SocketAddress
        new_abstract(path:list) -> Gio.SocketAddress
        new_with_type(path:list, type:Gio.UnixSocketAddressType) -> Gio.SocketAddress

    Object GUnixSocketAddress

    Properties from GUnixSocketAddress:
      path -> gchararray: path
      path-as-array -> GByteArray: path-as-array
      abstract -> gboolean: abstract
      address-type -> GUnixSocketAddressType: address-type

    Properties from GSocketAddress:
      family -> GSocketFamily: family

    Signals from GObject:
      notify (GParam)
    """
    class Props(SocketAddress.Props):
        abstract: bool
        address_type: UnixSocketAddressType
        path: str
        path_as_array: bytes
        family: SocketFamily

    props: Props = ...
    parent_instance: SocketAddress = ...
    priv: UnixSocketAddressPrivate = ...
    def __init__(
        self,
        *,
        abstract: bool = ...,
        address_type: UnixSocketAddressType = ...,
        path: str = ...,
        path_as_array: typing.Sequence[int] = ...,
    ) -> None: ...
    @staticmethod
    def abstract_names_supported() -> bool: ...
    def get_address_type(self) -> UnixSocketAddressType: ...
    def get_is_abstract(self) -> bool: ...
    def get_path(self) -> str: ...
    def get_path_len(self) -> int: ...
    @classmethod
    def new(cls, path: str) -> UnixSocketAddress: ...
    @classmethod
    def new_abstract(cls, path: typing.Sequence[int]) -> UnixSocketAddress: ...
    @classmethod
    def new_with_type(
        cls, path: typing.Sequence[int], type: UnixSocketAddressType
    ) -> UnixSocketAddress: ...

class UnixSocketAddressClass(GObject.GPointer):
    """
    :Constructors:

    ::

        UnixSocketAddressClass()
    """

    parent_class: SocketAddressClass = ...

class UnixSocketAddressPrivate(GObject.GPointer): ...

class Vfs(GObject.Object):
    """
    :Constructors:

    ::

        Vfs(**properties)

    Object GVfs

    Signals from GObject:
      notify (GParam)
    """

    parent_instance: GObject.Object = ...
    def do_add_writable_namespaces(self, list: FileAttributeInfoList) -> None: ...
    def do_get_file_for_path(self, path: str) -> File: ...
    def do_get_file_for_uri(self, uri: str) -> File: ...
    def do_get_supported_uri_schemes(self) -> list[str]: ...
    def do_is_active(self) -> bool: ...
    def do_local_file_add_info(
        self,
        filename: str,
        device: int,
        attribute_matcher: FileAttributeMatcher,
        info: FileInfo,
        cancellable: typing.Optional[Cancellable],
        extra_data: None,
        free_extra_data: typing.Callable[[None], None],
    ) -> None: ...
    def do_local_file_moved(self, source: str, dest: str) -> None: ...
    def do_local_file_removed(self, filename: str) -> None: ...
    def do_local_file_set_attributes(
        self,
        filename: str,
        info: FileInfo,
        flags: FileQueryInfoFlags,
        cancellable: typing.Optional[Cancellable] = None,
    ) -> bool: ...
    def do_parse_name(self, parse_name: str) -> File: ...
    @staticmethod
    def get_default() -> Vfs: ...
    def get_file_for_path(self, path: str) -> File: ...
    def get_file_for_uri(self, uri: str) -> File: ...
    @staticmethod
    def get_local() -> Vfs: ...
    def get_supported_uri_schemes(self) -> list[str]: ...
    def is_active(self) -> bool: ...
    def parse_name(self, parse_name: str) -> File: ...
    def register_uri_scheme(
        self,
        scheme: str,
        uri_func: typing.Optional[typing.Callable[..., typing.Optional[File]]] = None,
        parse_name_func: typing.Optional[
            typing.Callable[..., typing.Optional[File]]
        ] = None,
        *parse_name_data: typing.Any,
    ) -> bool: ...
    def unregister_uri_scheme(self, scheme: str) -> bool: ...

class VfsClass(GObject.GPointer):
    """
    :Constructors:

    ::

        VfsClass()
    """

    parent_class: GObject.ObjectClass = ...
    is_active: typing.Callable[[Vfs], bool] = ...
    get_file_for_path: typing.Callable[[Vfs, str], File] = ...
    get_file_for_uri: typing.Callable[[Vfs, str], File] = ...
    get_supported_uri_schemes: typing.Callable[[Vfs], list[str]] = ...
    parse_name: typing.Callable[[Vfs, str], File] = ...
    local_file_add_info: typing.Callable[
        [
            Vfs,
            str,
            int,
            FileAttributeMatcher,
            FileInfo,
            typing.Optional[Cancellable],
            None,
            typing.Callable[[None], None],
        ],
        None,
    ] = ...
    add_writable_namespaces: typing.Callable[[Vfs, FileAttributeInfoList], None] = ...
    local_file_set_attributes: typing.Callable[
        [Vfs, str, FileInfo, FileQueryInfoFlags, typing.Optional[Cancellable]], bool
    ] = ...
    local_file_removed: typing.Callable[[Vfs, str], None] = ...
    local_file_moved: typing.Callable[[Vfs, str, str], None] = ...
    deserialize_icon: None = ...

class Volume(GObject.GInterface):
    """
    Interface GVolume

    Signals from GObject:
      notify (GParam)
    """
    def can_eject(self) -> bool: ...
    def can_mount(self) -> bool: ...
    def eject(
        self,
        flags: MountUnmountFlags,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def eject_finish(self, result: AsyncResult) -> bool: ...
    def eject_with_operation(
        self,
        flags: MountUnmountFlags,
        mount_operation: typing.Optional[MountOperation] = None,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def eject_with_operation_finish(self, result: AsyncResult) -> bool: ...
    def enumerate_identifiers(self) -> list[str]: ...
    def get_activation_root(self) -> typing.Optional[File]: ...
    def get_drive(self) -> typing.Optional[Drive]: ...
    def get_icon(self) -> Icon: ...
    def get_identifier(self, kind: str) -> typing.Optional[str]: ...
    def get_mount(self) -> typing.Optional[Mount]: ...
    def get_name(self) -> str: ...
    def get_sort_key(self) -> typing.Optional[str]: ...
    def get_symbolic_icon(self) -> Icon: ...
    def get_uuid(self) -> typing.Optional[str]: ...
    def mount(
        self,
        flags: MountMountFlags,
        mount_operation: typing.Optional[MountOperation] = None,
        cancellable: typing.Optional[Cancellable] = None,
        callback: typing.Optional[typing.Callable[..., None]] = None,
        *user_data: typing.Any,
    ) -> None: ...
    def mount_finish(self, result: AsyncResult) -> bool: ...
    def should_automount(self) -> bool: ...

class VolumeIface(GObject.GPointer):
    """
    :Constructors:

    ::

        VolumeIface()
    """

    g_iface: GObject.TypeInterface = ...
    changed: typing.Callable[[Volume], None] = ...
    removed: typing.Callable[[Volume], None] = ...
    get_name: typing.Callable[[Volume], str] = ...
    get_icon: typing.Callable[[Volume], Icon] = ...
    get_uuid: typing.Callable[[Volume], typing.Optional[str]] = ...
    get_drive: typing.Callable[[Volume], typing.Optional[Drive]] = ...
    get_mount: typing.Callable[[Volume], typing.Optional[Mount]] = ...
    can_mount: typing.Callable[[Volume], bool] = ...
    can_eject: typing.Callable[[Volume], bool] = ...
    mount_fn: typing.Callable[..., None] = ...
    mount_finish: typing.Callable[[Volume, AsyncResult], bool] = ...
    eject: typing.Callable[..., None] = ...
    eject_finish: typing.Callable[[Volume, AsyncResult], bool] = ...
    get_identifier: typing.Callable[[Volume, str], typing.Optional[str]] = ...
    enumerate_identifiers: typing.Callable[[Volume], list[str]] = ...
    should_automount: typing.Callable[[Volume], bool] = ...
    get_activation_root: typing.Callable[[Volume], typing.Optional[File]] = ...
    eject_with_operation: typing.Callable[..., None] = ...
    eject_with_operation_finish: typing.Callable[[Volume, AsyncResult], bool] = ...
    get_sort_key: typing.Callable[[Volume], typing.Optional[str]] = ...
    get_symbolic_icon: typing.Callable[[Volume], Icon] = ...

class VolumeMonitor(GObject.Object):
    """
    :Constructors:

    ::

        VolumeMonitor(**properties)

    Object GVolumeMonitor

    Signals from GVolumeMonitor:
      volume-added (GVolume)
      volume-removed (GVolume)
      volume-changed (GVolume)
      mount-added (GMount)
      mount-removed (GMount)
      mount-pre-unmount (GMount)
      mount-changed (GMount)
      drive-connected (GDrive)
      drive-disconnected (GDrive)
      drive-changed (GDrive)
      drive-eject-button (GDrive)
      drive-stop-button (GDrive)

    Signals from GObject:
      notify (GParam)
    """

    parent_instance: GObject.Object = ...
    priv: None = ...
    @staticmethod
    def adopt_orphan_mount(mount: Mount) -> Volume: ...
    def do_drive_changed(self, drive: Drive) -> None: ...
    def do_drive_connected(self, drive: Drive) -> None: ...
    def do_drive_disconnected(self, drive: Drive) -> None: ...
    def do_drive_eject_button(self, drive: Drive) -> None: ...
    def do_drive_stop_button(self, drive: Drive) -> None: ...
    def do_get_connected_drives(self) -> list[Drive]: ...
    def do_get_mount_for_uuid(self, uuid: str) -> typing.Optional[Mount]: ...
    def do_get_mounts(self) -> list[Mount]: ...
    def do_get_volume_for_uuid(self, uuid: str) -> typing.Optional[Volume]: ...
    def do_get_volumes(self) -> list[Volume]: ...
    def do_mount_added(self, mount: Mount) -> None: ...
    def do_mount_changed(self, mount: Mount) -> None: ...
    def do_mount_pre_unmount(self, mount: Mount) -> None: ...
    def do_mount_removed(self, mount: Mount) -> None: ...
    def do_volume_added(self, volume: Volume) -> None: ...
    def do_volume_changed(self, volume: Volume) -> None: ...
    def do_volume_removed(self, volume: Volume) -> None: ...
    @staticmethod
    def get() -> VolumeMonitor: ...
    def get_connected_drives(self) -> list[Drive]: ...
    def get_mount_for_uuid(self, uuid: str) -> typing.Optional[Mount]: ...
    def get_mounts(self) -> list[Mount]: ...
    def get_volume_for_uuid(self, uuid: str) -> typing.Optional[Volume]: ...
    def get_volumes(self) -> list[Volume]: ...

class VolumeMonitorClass(GObject.GPointer):
    """
    :Constructors:

    ::

        VolumeMonitorClass()
    """

    parent_class: GObject.ObjectClass = ...
    volume_added: typing.Callable[[VolumeMonitor, Volume], None] = ...
    volume_removed: typing.Callable[[VolumeMonitor, Volume], None] = ...
    volume_changed: typing.Callable[[VolumeMonitor, Volume], None] = ...
    mount_added: typing.Callable[[VolumeMonitor, Mount], None] = ...
    mount_removed: typing.Callable[[VolumeMonitor, Mount], None] = ...
    mount_pre_unmount: typing.Callable[[VolumeMonitor, Mount], None] = ...
    mount_changed: typing.Callable[[VolumeMonitor, Mount], None] = ...
    drive_connected: typing.Callable[[VolumeMonitor, Drive], None] = ...
    drive_disconnected: typing.Callable[[VolumeMonitor, Drive], None] = ...
    drive_changed: typing.Callable[[VolumeMonitor, Drive], None] = ...
    is_supported: typing.Callable[[], bool] = ...
    get_connected_drives: typing.Callable[[VolumeMonitor], list[Drive]] = ...
    get_volumes: typing.Callable[[VolumeMonitor], list[Volume]] = ...
    get_mounts: typing.Callable[[VolumeMonitor], list[Mount]] = ...
    get_volume_for_uuid: typing.Callable[
        [VolumeMonitor, str], typing.Optional[Volume]
    ] = ...
    get_mount_for_uuid: typing.Callable[
        [VolumeMonitor, str], typing.Optional[Mount]
    ] = ...
    adopt_orphan_mount: None = ...
    drive_eject_button: typing.Callable[[VolumeMonitor, Drive], None] = ...
    drive_stop_button: typing.Callable[[VolumeMonitor, Drive], None] = ...

class ZlibCompressor(GObject.Object, Converter):
    """
    :Constructors:

    ::

        ZlibCompressor(**properties)
        new(format:Gio.ZlibCompressorFormat, level:int) -> Gio.ZlibCompressor

    Object GZlibCompressor

    Properties from GZlibCompressor:
      format -> GZlibCompressorFormat: format
      level -> gint: level
      file-info -> GFileInfo: file-info
      os -> gint: os

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        file_info: typing.Optional[FileInfo]
        format: ZlibCompressorFormat
        level: int
        os: int

    props: Props = ...
    def __init__(
        self,
        *,
        file_info: typing.Optional[FileInfo] = ...,
        format: ZlibCompressorFormat = ...,
        level: int = ...,
        os: int = ...,
    ) -> None: ...
    def get_file_info(self) -> typing.Optional[FileInfo]: ...
    def get_os(self) -> int: ...
    @classmethod
    def new(cls, format: ZlibCompressorFormat, level: int) -> ZlibCompressor: ...
    def set_file_info(self, file_info: typing.Optional[FileInfo] = None) -> None: ...
    def set_os(self, os: int) -> None: ...

class ZlibCompressorClass(GObject.GPointer):
    """
    :Constructors:

    ::

        ZlibCompressorClass()
    """

    parent_class: GObject.ObjectClass = ...

class ZlibDecompressor(GObject.Object, Converter):
    """
    :Constructors:

    ::

        ZlibDecompressor(**properties)
        new(format:Gio.ZlibCompressorFormat) -> Gio.ZlibDecompressor

    Object GZlibDecompressor

    Properties from GZlibDecompressor:
      format -> GZlibCompressorFormat: format
      file-info -> GFileInfo: file-info

    Signals from GObject:
      notify (GParam)
    """
    class Props(GObject.Object.Props):
        file_info: typing.Optional[FileInfo]
        format: ZlibCompressorFormat

    props: Props = ...
    def __init__(self, *, format: ZlibCompressorFormat = ...) -> None: ...
    def get_file_info(self) -> typing.Optional[FileInfo]: ...
    @classmethod
    def new(cls, format: ZlibCompressorFormat) -> ZlibDecompressor: ...

class ZlibDecompressorClass(GObject.GPointer):
    """
    :Constructors:

    ::

        ZlibDecompressorClass()
    """

    parent_class: GObject.ObjectClass = ...

class AppInfoCreateFlags(GObject.GFlags):
    NEEDS_TERMINAL = 1
    NONE = 0
    SUPPORTS_STARTUP_NOTIFICATION = 4
    SUPPORTS_URIS = 2

class ApplicationFlags(GObject.GFlags):
    ALLOW_REPLACEMENT = 128
    CAN_OVERRIDE_APP_ID = 64
    DEFAULT_FLAGS = 0
    FLAGS_NONE = 0
    HANDLES_COMMAND_LINE = 8
    HANDLES_OPEN = 4
    IS_LAUNCHER = 2
    IS_SERVICE = 1
    NON_UNIQUE = 32
    REPLACE = 256
    SEND_ENVIRONMENT = 16

class AskPasswordFlags(GObject.GFlags):
    ANONYMOUS_SUPPORTED = 16
    NEED_DOMAIN = 4
    NEED_PASSWORD = 1
    NEED_USERNAME = 2
    SAVING_SUPPORTED = 8
    TCRYPT = 32

class BusNameOwnerFlags(GObject.GFlags):
    ALLOW_REPLACEMENT = 1
    DO_NOT_QUEUE = 4
    NONE = 0
    REPLACE = 2

class BusNameWatcherFlags(GObject.GFlags):
    AUTO_START = 1
    NONE = 0

class ConverterFlags(GObject.GFlags):
    FLUSH = 2
    INPUT_AT_END = 1
    NONE = 0

class DBusCallFlags(GObject.GFlags):
    ALLOW_INTERACTIVE_AUTHORIZATION = 2
    NONE = 0
    NO_AUTO_START = 1

class DBusCapabilityFlags(GObject.GFlags):
    NONE = 0
    UNIX_FD_PASSING = 1

class DBusConnectionFlags(GObject.GFlags):
    AUTHENTICATION_ALLOW_ANONYMOUS = 4
    AUTHENTICATION_CLIENT = 1
    AUTHENTICATION_REQUIRE_SAME_USER = 32
    AUTHENTICATION_SERVER = 2
    CROSS_NAMESPACE = 64
    DELAY_MESSAGE_PROCESSING = 16
    MESSAGE_BUS_CONNECTION = 8
    NONE = 0

class DBusInterfaceSkeletonFlags(GObject.GFlags):
    HANDLE_METHOD_INVOCATIONS_IN_THREAD = 1
    NONE = 0

class DBusMessageFlags(GObject.GFlags):
    ALLOW_INTERACTIVE_AUTHORIZATION = 4
    NONE = 0
    NO_AUTO_START = 2
    NO_REPLY_EXPECTED = 1

class DBusObjectManagerClientFlags(GObject.GFlags):
    DO_NOT_AUTO_START = 1
    NONE = 0

class DBusPropertyInfoFlags(GObject.GFlags):
    NONE = 0
    READABLE = 1
    WRITABLE = 2

class DBusProxyFlags(GObject.GFlags):
    DO_NOT_AUTO_START = 4
    DO_NOT_AUTO_START_AT_CONSTRUCTION = 16
    DO_NOT_CONNECT_SIGNALS = 2
    DO_NOT_LOAD_PROPERTIES = 1
    GET_INVALIDATED_PROPERTIES = 8
    NONE = 0
    NO_MATCH_RULE = 32

class DBusSendMessageFlags(GObject.GFlags):
    NONE = 0
    PRESERVE_SERIAL = 1

class DBusServerFlags(GObject.GFlags):
    AUTHENTICATION_ALLOW_ANONYMOUS = 2
    AUTHENTICATION_REQUIRE_SAME_USER = 4
    NONE = 0
    RUN_IN_THREAD = 1

class DBusSignalFlags(GObject.GFlags):
    MATCH_ARG0_NAMESPACE = 2
    MATCH_ARG0_PATH = 4
    NONE = 0
    NO_MATCH_RULE = 1

class DBusSubtreeFlags(GObject.GFlags):
    DISPATCH_TO_UNENUMERATED_NODES = 1
    NONE = 0

class DriveStartFlags(GObject.GFlags):
    NONE = 0

class FileAttributeInfoFlags(GObject.GFlags):
    COPY_WHEN_MOVED = 2
    COPY_WITH_FILE = 1
    NONE = 0

class FileCopyFlags(GObject.GFlags):
    ALL_METADATA = 8
    BACKUP = 2
    NOFOLLOW_SYMLINKS = 4
    NONE = 0
    NO_FALLBACK_FOR_MOVE = 16
    OVERWRITE = 1
    TARGET_DEFAULT_MODIFIED_TIME = 64
    TARGET_DEFAULT_PERMS = 32

class FileCreateFlags(GObject.GFlags):
    NONE = 0
    PRIVATE = 1
    REPLACE_DESTINATION = 2

class FileMeasureFlags(GObject.GFlags):
    APPARENT_SIZE = 4
    NONE = 0
    NO_XDEV = 8
    REPORT_ANY_ERROR = 2

class FileMonitorFlags(GObject.GFlags):
    NONE = 0
    SEND_MOVED = 2
    WATCH_HARD_LINKS = 4
    WATCH_MOUNTS = 1
    WATCH_MOVES = 8

class FileQueryInfoFlags(GObject.GFlags):
    NOFOLLOW_SYMLINKS = 1
    NONE = 0

class IOStreamSpliceFlags(GObject.GFlags):
    CLOSE_STREAM1 = 1
    CLOSE_STREAM2 = 2
    NONE = 0
    WAIT_FOR_BOTH = 4

class MountMountFlags(GObject.GFlags):
    NONE = 0

class MountUnmountFlags(GObject.GFlags):
    FORCE = 1
    NONE = 0

class OutputStreamSpliceFlags(GObject.GFlags):
    CLOSE_SOURCE = 1
    CLOSE_TARGET = 2
    NONE = 0

class ResolverNameLookupFlags(GObject.GFlags):
    DEFAULT = 0
    IPV4_ONLY = 1
    IPV6_ONLY = 2

class ResourceFlags(GObject.GFlags):
    COMPRESSED = 1
    NONE = 0

class ResourceLookupFlags(GObject.GFlags):
    NONE = 0

class SettingsBindFlags(GObject.GFlags):
    DEFAULT = 0
    GET = 1
    GET_NO_CHANGES = 8
    INVERT_BOOLEAN = 16
    NO_SENSITIVITY = 4
    SET = 2

class SocketMsgFlags(GObject.GFlags):
    DONTROUTE = 4
    NONE = 0
    OOB = 1
    PEEK = 2

class SubprocessFlags(GObject.GFlags):
    INHERIT_FDS = 128
    NONE = 0
    SEARCH_PATH_FROM_ENVP = 256
    STDERR_MERGE = 64
    STDERR_PIPE = 16
    STDERR_SILENCE = 32
    STDIN_INHERIT = 2
    STDIN_PIPE = 1
    STDOUT_PIPE = 4
    STDOUT_SILENCE = 8

class TestDBusFlags(GObject.GFlags):
    NONE = 0

class TlsCertificateFlags(GObject.GFlags):
    BAD_IDENTITY = 2
    EXPIRED = 8
    GENERIC_ERROR = 64
    INSECURE = 32
    NOT_ACTIVATED = 4
    NO_FLAGS = 0
    REVOKED = 16
    UNKNOWN_CA = 1
    VALIDATE_ALL = 127

class TlsDatabaseVerifyFlags(GObject.GFlags):
    NONE = 0

class TlsPasswordFlags(GObject.GFlags):
    FINAL_TRY = 8
    MANY_TRIES = 4
    NONE = 0
    PKCS11_CONTEXT_SPECIFIC = 64
    PKCS11_SECURITY_OFFICER = 32
    PKCS11_USER = 16
    RETRY = 2

class BusType(GObject.GEnum):
    NONE = 0
    SESSION = 2
    STARTER = -1
    SYSTEM = 1

class ConverterResult(GObject.GEnum):
    CONVERTED = 1
    ERROR = 0
    FINISHED = 2
    FLUSHED = 3

class CredentialsType(GObject.GEnum):
    APPLE_XUCRED = 6
    FREEBSD_CMSGCRED = 2
    INVALID = 0
    LINUX_UCRED = 1
    NETBSD_UNPCBID = 5
    OPENBSD_SOCKPEERCRED = 3
    SOLARIS_UCRED = 4
    WIN32_PID = 7

class DBusError(GObject.GEnum):
    ACCESS_DENIED = 9
    ADDRESS_IN_USE = 14
    ADT_AUDIT_DATA_UNKNOWN = 39
    AUTH_FAILED = 10
    BAD_ADDRESS = 6
    DISCONNECTED = 15
    FAILED = 0
    FILE_EXISTS = 18
    FILE_NOT_FOUND = 17
    INVALID_ARGS = 16
    INVALID_FILE_CONTENT = 37
    INVALID_SIGNATURE = 36
    IO_ERROR = 5
    LIMITS_EXCEEDED = 8
    MATCH_RULE_INVALID = 22
    MATCH_RULE_NOT_FOUND = 21
    NAME_HAS_NO_OWNER = 3
    NOT_SUPPORTED = 7
    NO_MEMORY = 1
    NO_NETWORK = 13
    NO_REPLY = 4
    NO_SERVER = 11
    OBJECT_PATH_IN_USE = 40
    PROPERTY_READ_ONLY = 44
    SELINUX_SECURITY_CONTEXT_UNKNOWN = 38
    SERVICE_UNKNOWN = 2
    SPAWN_CHILD_EXITED = 25
    SPAWN_CHILD_SIGNALED = 26
    SPAWN_CONFIG_INVALID = 29
    SPAWN_EXEC_FAILED = 23
    SPAWN_FAILED = 27
    SPAWN_FILE_INVALID = 33
    SPAWN_FORK_FAILED = 24
    SPAWN_NO_MEMORY = 34
    SPAWN_PERMISSIONS_INVALID = 32
    SPAWN_SERVICE_INVALID = 30
    SPAWN_SERVICE_NOT_FOUND = 31
    SPAWN_SETUP_FAILED = 28
    TIMED_OUT = 20
    TIMEOUT = 12
    UNIX_PROCESS_ID_UNKNOWN = 35
    UNKNOWN_INTERFACE = 42
    UNKNOWN_METHOD = 19
    UNKNOWN_OBJECT = 41
    UNKNOWN_PROPERTY = 43
    @staticmethod
    def encode_gerror(error: GLib.Error) -> str: ...
    @staticmethod
    def get_remote_error(error: GLib.Error) -> typing.Optional[str]: ...
    @staticmethod
    def is_remote_error(error: GLib.Error) -> bool: ...
    @staticmethod
    def new_for_dbus_error(
        dbus_error_name: str, dbus_error_message: str
    ) -> GLib.Error: ...
    @staticmethod
    def quark() -> int: ...
    @staticmethod
    def register_error(
        error_domain: int, error_code: int, dbus_error_name: str
    ) -> bool: ...
    @staticmethod
    def register_error_domain(
        error_domain_quark_name: str,
        quark_volatile: int,
        entries: typing.Sequence[DBusErrorEntry],
    ) -> None: ...
    @staticmethod
    def strip_remote_error(error: GLib.Error) -> bool: ...
    @staticmethod
    def unregister_error(
        error_domain: int, error_code: int, dbus_error_name: str
    ) -> bool: ...

class DBusMessageByteOrder(GObject.GEnum):
    BIG_ENDIAN = 66
    LITTLE_ENDIAN = 108

class DBusMessageHeaderField(GObject.GEnum):
    DESTINATION = 6
    ERROR_NAME = 4
    INTERFACE = 2
    INVALID = 0
    MEMBER = 3
    NUM_UNIX_FDS = 9
    PATH = 1
    REPLY_SERIAL = 5
    SENDER = 7
    SIGNATURE = 8

class DBusMessageType(GObject.GEnum):
    ERROR = 3
    INVALID = 0
    METHOD_CALL = 1
    METHOD_RETURN = 2
    SIGNAL = 4

class DataStreamByteOrder(GObject.GEnum):
    BIG_ENDIAN = 0
    HOST_ENDIAN = 2
    LITTLE_ENDIAN = 1

class DataStreamNewlineType(GObject.GEnum):
    ANY = 3
    CR = 1
    CR_LF = 2
    LF = 0

class DriveStartStopType(GObject.GEnum):
    MULTIDISK = 3
    NETWORK = 2
    PASSWORD = 4
    SHUTDOWN = 1
    UNKNOWN = 0

class EmblemOrigin(GObject.GEnum):
    DEVICE = 1
    LIVEMETADATA = 2
    TAG = 3
    UNKNOWN = 0

class FileAttributeStatus(GObject.GEnum):
    ERROR_SETTING = 2
    SET = 1
    UNSET = 0

class FileAttributeType(GObject.GEnum):
    BOOLEAN = 3
    BYTE_STRING = 2
    INT32 = 5
    INT64 = 7
    INVALID = 0
    OBJECT = 8
    STRING = 1
    STRINGV = 9
    UINT32 = 4
    UINT64 = 6

class FileMonitorEvent(GObject.GEnum):
    ATTRIBUTE_CHANGED = 4
    CHANGED = 0
    CHANGES_DONE_HINT = 1
    CREATED = 3
    DELETED = 2
    MOVED = 7
    MOVED_IN = 9
    MOVED_OUT = 10
    PRE_UNMOUNT = 5
    RENAMED = 8
    UNMOUNTED = 6

class FileType(GObject.GEnum):
    DIRECTORY = 2
    MOUNTABLE = 6
    REGULAR = 1
    SHORTCUT = 5
    SPECIAL = 4
    SYMBOLIC_LINK = 3
    UNKNOWN = 0

class FilesystemPreviewType(GObject.GEnum):
    IF_ALWAYS = 0
    IF_LOCAL = 1
    NEVER = 2

class IOErrorEnum(GObject.GEnum):
    ADDRESS_IN_USE = 33
    ALREADY_MOUNTED = 17
    BROKEN_PIPE = 44
    BUSY = 26
    CANCELLED = 19
    CANT_CREATE_BACKUP = 22
    CLOSED = 18
    CONNECTION_CLOSED = 44
    CONNECTION_REFUSED = 39
    DBUS_ERROR = 36
    DESTINATION_UNSET = 48
    EXISTS = 2
    FAILED = 0
    FAILED_HANDLED = 30
    FILENAME_TOO_LONG = 9
    HOST_NOT_FOUND = 28
    HOST_UNREACHABLE = 37
    INVALID_ARGUMENT = 13
    INVALID_DATA = 35
    INVALID_FILENAME = 10
    IS_DIRECTORY = 3
    MESSAGE_TOO_LARGE = 46
    NETWORK_UNREACHABLE = 38
    NOT_CONNECTED = 45
    NOT_DIRECTORY = 4
    NOT_EMPTY = 5
    NOT_FOUND = 1
    NOT_INITIALIZED = 32
    NOT_MOUNTABLE_FILE = 8
    NOT_MOUNTED = 16
    NOT_REGULAR_FILE = 6
    NOT_SUPPORTED = 15
    NOT_SYMBOLIC_LINK = 7
    NO_SPACE = 12
    NO_SUCH_DEVICE = 47
    PARTIAL_INPUT = 34
    PENDING = 20
    PERMISSION_DENIED = 14
    PROXY_AUTH_FAILED = 41
    PROXY_FAILED = 40
    PROXY_NEED_AUTH = 42
    PROXY_NOT_ALLOWED = 43
    READ_ONLY = 21
    TIMED_OUT = 24
    TOO_MANY_LINKS = 11
    TOO_MANY_OPEN_FILES = 31
    WOULD_BLOCK = 27
    WOULD_MERGE = 29
    WOULD_RECURSE = 25
    WRONG_ETAG = 23

class IOModuleScopeFlags(GObject.GEnum):
    BLOCK_DUPLICATES = 1
    NONE = 0

class MemoryMonitorWarningLevel(GObject.GEnum):
    CRITICAL = 255
    LOW = 50
    MEDIUM = 100

class MountOperationResult(GObject.GEnum):
    ABORTED = 1
    HANDLED = 0
    UNHANDLED = 2

class NetworkConnectivity(GObject.GEnum):
    FULL = 4
    LIMITED = 2
    LOCAL = 1
    PORTAL = 3

class NotificationPriority(GObject.GEnum):
    HIGH = 2
    LOW = 1
    NORMAL = 0
    URGENT = 3

class PasswordSave(GObject.GEnum):
    FOR_SESSION = 1
    NEVER = 0
    PERMANENTLY = 2

class PollableReturn(GObject.GEnum):
    FAILED = 0
    OK = 1
    WOULD_BLOCK = -27

class ResolverError(GObject.GEnum):
    INTERNAL = 2
    NOT_FOUND = 0
    TEMPORARY_FAILURE = 1
    @staticmethod
    def quark() -> int: ...

class ResolverRecordType(GObject.GEnum):
    MX = 2
    NS = 5
    SOA = 4
    SRV = 1
    TXT = 3

class ResourceError(GObject.GEnum):
    INTERNAL = 1
    NOT_FOUND = 0
    @staticmethod
    def quark() -> int: ...

class SocketClientEvent(GObject.GEnum):
    COMPLETE = 8
    CONNECTED = 3
    CONNECTING = 2
    PROXY_NEGOTIATED = 5
    PROXY_NEGOTIATING = 4
    RESOLVED = 1
    RESOLVING = 0
    TLS_HANDSHAKED = 7
    TLS_HANDSHAKING = 6

class SocketFamily(GObject.GEnum):
    INVALID = 0
    IPV4 = 2
    IPV6 = 10
    UNIX = 1

class SocketListenerEvent(GObject.GEnum):
    BINDING = 0
    BOUND = 1
    LISTENED = 3
    LISTENING = 2

class SocketProtocol(GObject.GEnum):
    DEFAULT = 0
    SCTP = 132
    TCP = 6
    UDP = 17
    UNKNOWN = -1

class SocketType(GObject.GEnum):
    DATAGRAM = 2
    INVALID = 0
    SEQPACKET = 3
    STREAM = 1

class TlsAuthenticationMode(GObject.GEnum):
    NONE = 0
    REQUESTED = 1
    REQUIRED = 2

class TlsCertificateRequestFlags(GObject.GEnum):
    NONE = 0

class TlsChannelBindingError(GObject.GEnum):
    GENERAL_ERROR = 4
    INVALID_STATE = 1
    NOT_AVAILABLE = 2
    NOT_IMPLEMENTED = 0
    NOT_SUPPORTED = 3
    @staticmethod
    def quark() -> int: ...

class TlsChannelBindingType(GObject.GEnum):
    EXPORTER = 2
    SERVER_END_POINT = 1
    UNIQUE = 0

class TlsDatabaseLookupFlags(GObject.GEnum):
    KEYPAIR = 1
    NONE = 0

class TlsError(GObject.GEnum):
    BAD_CERTIFICATE = 2
    BAD_CERTIFICATE_PASSWORD = 8
    CERTIFICATE_REQUIRED = 5
    EOF = 6
    HANDSHAKE = 4
    INAPPROPRIATE_FALLBACK = 7
    MISC = 1
    NOT_TLS = 3
    UNAVAILABLE = 0
    @staticmethod
    def quark() -> int: ...

class TlsInteractionResult(GObject.GEnum):
    FAILED = 2
    HANDLED = 1
    UNHANDLED = 0

class TlsProtocolVersion(GObject.GEnum):
    DTLS_1_0 = 201
    DTLS_1_2 = 202
    SSL_3_0 = 1
    TLS_1_0 = 2
    TLS_1_1 = 3
    TLS_1_2 = 4
    TLS_1_3 = 5
    UNKNOWN = 0

class TlsRehandshakeMode(GObject.GEnum):
    NEVER = 0
    SAFELY = 1
    UNSAFELY = 2

class UnixSocketAddressType(GObject.GEnum):
    ABSTRACT = 3
    ABSTRACT_PADDED = 4
    ANONYMOUS = 1
    INVALID = 0
    PATH = 2

class ZlibCompressorFormat(GObject.GEnum):
    GZIP = 1
    RAW = 2
    ZLIB = 0
