/// <reference path="./libvirtglib-1.0.d.ts" />
/// <reference path="./glib-2.0.d.ts" />
/// <reference path="./libvirtgconfig-1.0.d.ts" />
/// <reference path="./libxml2-2.0.d.ts" />
/// <reference path="./gobject-2.0.d.ts" />
/// <reference path="./gio-2.0.d.ts" />
/// <reference path="./gmodule-2.0.d.ts" />

/**
 * Type Definitions for Gjs (https://gjs.guide/)
 *
 * These type definitions are automatically generated, do not edit them by hand.
 * If you found a bug fix it in `ts-for-gir` or create a bug report on https://github.com/gjsify/ts-for-gir
 *
 * The based EJS template file is used for the generated .d.ts file of each GIR module like Gtk-4.0, GObject-2.0, ...
 */

declare module 'gi://LibvirtGObject?version=1.0' {
    // Module dependencies
    import type LibvirtGLib from 'gi://LibvirtGLib?version=1.0';
    import type GLib from 'gi://GLib?version=2.0';
    import type LibvirtGConfig from 'gi://LibvirtGConfig?version=1.0';
    import type libxml2 from 'gi://libxml2?version=2.0';
    import type GObject from 'gi://GObject?version=2.0';
    import type Gio from 'gi://Gio?version=2.0';
    import type GModule from 'gi://GModule?version=2.0';

    export namespace LibvirtGObject {
        /**
         * LibvirtGObject-1.0
         */

        export namespace DomainDeleteFlags {
            export const $gtype: GObject.GType<DomainDeleteFlags>;
        }

        enum DomainDeleteFlags {
            /**
             * No flags
             */
            NONE,
            /**
             * Also remove associated saved state (if present).
             */
            SAVED_STATE,
            /**
             * If last use of domain, then also
             *                                         remove any snapshot metadata.
             */
            SNAPSHOTS_METADATA,
            REMOVE_NVRAM,
            KEEP_NVRAM,
        }

        export namespace DomainRebootFlags {
            export const $gtype: GObject.GType<DomainRebootFlags>;
        }

        enum DomainRebootFlags {
            /**
             * No flags, hypervisor choice
             */
            NONE,
            /**
             * Send ACPI event
             */
            ACPI_POWER_BTN,
            /**
             * Use guest agent
             */
            GUEST_AGENT,
        }

        export namespace DomainShutdownFlags {
            export const $gtype: GObject.GType<DomainShutdownFlags>;
        }

        enum DomainShutdownFlags {
            /**
             * No flags, hypervisor choice
             */
            NONE,
            /**
             * Send ACPI event
             */
            ACPI_POWER_BTN,
            /**
             * Use guest agent
             */
            GUEST_AGENT,
        }

        export namespace DomainSnapshotCreateFlags {
            export const $gtype: GObject.GType<DomainSnapshotCreateFlags>;
        }

        enum DomainSnapshotCreateFlags {
            /**
             * No flags
             */
            NONE,
            /**
             * Restore or alter metadata
             */
            REDEFINE,
            /**
             * With redefine, make snapshot current
             */
            CURRENT,
            /**
             * Make snapshot without remembering it
             */
            NO_METADATA,
            /**
             * Stop running guest after snapshot
             */
            HALT,
            /**
             * Disk snapshot, not system checkpoint
             */
            DISK_ONLY,
            /**
             * Reuse any existing external files
             */
            REUSE_EXT,
            /**
             * Use guest agent to quiesce all mounter
             *                                file systems within the domain
             */
            QUIESCE,
            /**
             * Atomically avoid partial changes
             */
            ATOMIC,
        }

        export namespace DomainSnapshotDeleteFlags {
            export const $gtype: GObject.GType<DomainSnapshotDeleteFlags>;
        }

        enum DomainSnapshotDeleteFlags {
            /**
             * Also delete children
             */
            CHILDREN,
            /**
             * Delete just metadata
             */
            METADATA_ONLY,
            /**
             * Delete just children
             */
            CHILDREN_ONLY,
        }

        export namespace DomainSnapshotListFlags {
            export const $gtype: GObject.GType<DomainSnapshotListFlags>;
        }

        enum DomainSnapshotListFlags {
            /**
             * List all snapshots
             */
            ALL,
            /**
             * List all descendants, not just
             *                                         children, when listing a snapshot.
             *                                         For historical reasons, groups do not use contiguous bits.
             */
            DESCENDANTS,
            /**
             * Filter by snapshots with no parents, when listing a domain
             */
            ROOTS,
            /**
             * Filter by snapshots which have metadata
             */
            METADATA,
            /**
             * Filter by snapshots with no children
             */
            LEAVES,
            /**
             * Filter by snapshots that have children
             */
            NO_LEAVES,
            /**
             * Filter by snapshots with no metadata
             */
            NO_METADATA,
            /**
             * Filter by snapshots taken while guest was shut off
             */
            INACTIVE,
            /**
             * Filter by snapshots taken while guest was active, and with memory state
             */
            ACTIVE,
            /**
             * Filter by snapshots taken while guest was active, but without memory state
             */
            DISK_ONLY,
            /**
             * Filter by snapshots stored internal to disk images
             */
            INTERNAL,
            /**
             * Filter by snapshots that use files external to disk images
             */
            EXTERNAL,
        }

        export namespace DomainSnapshotRevertFlags {
            export const $gtype: GObject.GType<DomainSnapshotRevertFlags>;
        }

        enum DomainSnapshotRevertFlags {
            /**
             * Run after revert
             */
            RUNNING,
            /**
             * Pause after revert
             */
            PAUSED,
            /**
             * Allow risky reverts
             */
            FORCE,
        }

        export namespace DomainState {
            export const $gtype: GObject.GType<DomainState>;
        }

        enum DomainState {
            NONE,
            RUNNING,
            BLOCKED,
            PAUSED,
            SHUTDOWN,
            SHUTOFF,
            CRASHED,
            PMSUSPENDED,
        }

        export namespace DomainUpdateDeviceFlags {
            export const $gtype: GObject.GType<DomainUpdateDeviceFlags>;
        }

        enum DomainUpdateDeviceFlags {
            /**
             * Update current domain state
             */
            CURRENT,
            /**
             * Update state for only active domains
             */
            LIVE,
            /**
             * Update state for persistent state only
             */
            CONFIG,
        }

        export namespace DomainXMLFlags {
            export const $gtype: GObject.GType<DomainXMLFlags>;
        }

        enum DomainXMLFlags {
            /**
             * No flags
             */
            NONE,
            /**
             * Dump security sensitive information too
             */
            SECURE,
            /**
             * Dump inactive domain information
             */
            INACTIVE,
            /**
             * Update guest CPU requirements according to host CPU
             */
            UPDATE_CPU,
        }

        export namespace IPAddrType {
            export const $gtype: GObject.GType<IPAddrType>;
        }

        enum IPAddrType {
            /**
             * IPv4 Address.
             */
            IPV4,
            /**
             * IPv6 Address.
             */
            IPV6,
        }

        export namespace StoragePoolState {
            export const $gtype: GObject.GType<StoragePoolState>;
        }

        enum StoragePoolState {
            INACTIVE,
            BUILDING,
            RUNNING,
            DEGRADED,
            INACCESSIBLE,
        }

        export namespace StorageVolResizeFlags {
            export const $gtype: GObject.GType<StorageVolResizeFlags>;
        }

        enum StorageVolResizeFlags {
            /**
             * No flags
             */
            NONE,
            /**
             * force allocation of new size
             */
            ALLOCATE,
            /**
             * size is relative to current
             */
            DELTA,
            /**
             * allow decrease in capacity. This combined
             * with #GVIR_STORAGE_VOL_RESIZE_DELTA, implies a negative delta.
             */
            SHRINK,
        }

        export namespace StorageVolType {
            export const $gtype: GObject.GType<StorageVolType>;
        }

        enum StorageVolType {
            FILE,
            BLOCK,
            DIR,
        }
        function init_object(argv?: string[] | null): string[] | null;
        function init_object_check(argv?: string[] | null): [boolean, string[] | null];
        interface StreamIOFunc {
            (stream: Stream, cond: StreamIOCondition, opaque?: any | null): boolean;
        }
        interface StreamSinkFunc {
            (stream: Stream): number;
        }
        interface StreamSourceFunc {
            (stream: Stream): number;
        }
        type ConnectionHandle = object | null;
        type DomainHandle = object | null;
        type DomainSnapshotHandle = object | null;
        type InterfaceHandle = object | null;
        type NetworkFilterHandle = object | null;
        type NetworkHandle = object | null;
        type NodeDeviceHandle = object | null;
        type SecretHandle = object | null;
        type StoragePoolHandle = object | null;
        type StorageVolHandle = object | null;
        type StreamHandle = object | null;

        export namespace DomainStartFlags {
            export const $gtype: GObject.GType<DomainStartFlags>;
        }

        enum DomainStartFlags {
            NONE,
            PAUSED,
            AUTODESTROY,
            BYPASS_CACHE,
            FORCE_BOOT,
        }

        export namespace StreamIOCondition {
            export const $gtype: GObject.GType<StreamIOCondition>;
        }

        enum StreamIOCondition {
            READABLE,
            WRITABLE,
            HANGUP,
            ERROR,
        }
        module Connection {
            // Signal callback interfaces

            interface ConnectionClosed {
                (): void;
            }

            interface ConnectionOpened {
                (): void;
            }

            interface DomainAdded {
                (object: Domain): void;
            }

            interface DomainRemoved {
                (object: Domain): void;
            }

            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {
                handle: ConnectionHandle;
                uri: string;
            }
        }

        class Connection extends GObject.Object {
            static $gtype: GObject.GType<Connection>;

            // Properties

            get handle(): ConnectionHandle;
            get uri(): string;

            // Constructors

            constructor(properties?: Partial<Connection.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            static ['new'](uri: string): Connection;

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'connection-closed', callback: (_source: this) => void): number;
            connect_after(signal: 'connection-closed', callback: (_source: this) => void): number;
            emit(signal: 'connection-closed'): void;
            connect(signal: 'connection-opened', callback: (_source: this) => void): number;
            connect_after(signal: 'connection-opened', callback: (_source: this) => void): number;
            emit(signal: 'connection-opened'): void;
            connect(signal: 'domain-added', callback: (_source: this, object: Domain) => void): number;
            connect_after(signal: 'domain-added', callback: (_source: this, object: Domain) => void): number;
            emit(signal: 'domain-added', object: Domain): void;
            connect(signal: 'domain-removed', callback: (_source: this, object: Domain) => void): number;
            connect_after(signal: 'domain-removed', callback: (_source: this, object: Domain) => void): number;
            emit(signal: 'domain-removed', object: Domain): void;

            // Virtual methods

            vfunc_connection_closed(): void;
            vfunc_connection_opened(): void;
            vfunc_domain_added(dom: Domain): void;
            vfunc_domain_removed(dom: Domain): void;

            // Methods

            close(): void;
            /**
             * Create the configuration file for a new persistent domain.
             * The returned domain will initially be in the shutoff state.
             * @param conf the configuration for the new domain
             * @returns the newly created domain, or NULL if an error occurred. The returned object should be unreffed with g_object_unref() when no longer needed.
             */
            create_domain(conf: LibvirtGConfig.Domain): Domain;
            create_storage_pool(conf: LibvirtGConfig.StoragePool, flags: number): StoragePool;
            /**
             * Use this method to fetch all domains managed by connection
             * `conn`. Use e.g. #gvir_connection_find_domain_by_id or
             * #gvir_connection_get_domain afterwards to query the fetched
             * domains.
             * @param cancellable cancellation object
             */
            fetch_domains(cancellable?: Gio.Cancellable | null): boolean;
            fetch_domains_async(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            fetch_domains_async(
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            fetch_domains_async(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            fetch_domains_finish(result: Gio.AsyncResult): boolean;
            /**
             * Use this method to fetch information on all network interfaces
             * managed by connection `conn` on host machine. Use
             * #gvir_connection_get_interfaces or #gvir_connection_get_interface afterwards
             * to query the fetched interfaces.
             * @param cancellable cancellation object
             * @returns %TRUE on success, %FALSE otherwise and @err is set.
             */
            fetch_interfaces(cancellable?: Gio.Cancellable | null): boolean;
            fetch_interfaces_async(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            fetch_interfaces_async(
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            fetch_interfaces_async(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            fetch_interfaces_finish(result: Gio.AsyncResult): boolean;
            /**
             * Use this method to fetch all networks managed by connection
             * `conn`. Use e.g. #gvir_connection_find_network_by_name or
             * #gvir_connection_get_networks afterwards to query the fetched
             * domains.
             * @param cancellable cancellation object
             */
            fetch_networks(cancellable?: Gio.Cancellable | null): boolean;
            fetch_networks_async(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            fetch_networks_async(
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            fetch_networks_async(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            fetch_networks_finish(result: Gio.AsyncResult): boolean;
            /**
             * Use this method to fetch all storage pools managed by connection
             * `conn`. Use e.g. #gvir_connection_find_storage_pool_by_name or
             * #gvir_connection_get_storage_pools afterwards to query the fetched
             * pools.
             * @param cancellable cancellation object
             */
            fetch_storage_pools(cancellable?: Gio.Cancellable | null): boolean;
            fetch_storage_pools_async(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            fetch_storage_pools_async(
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            fetch_storage_pools_async(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            fetch_storage_pools_finish(result: Gio.AsyncResult): boolean;
            find_domain_by_id(id: number): Domain;
            find_domain_by_name(name: string): Domain;
            /**
             * Get a particular interface which has MAC address `mac`.
             * @param macaddr MAC address to lookup
             * @returns A new reference to a #GVirInterface, or NULL if no interface exists with MAC address @mac. The returned object must be unreffed using g_object_unref() once used.
             */
            find_interface_by_mac(macaddr: string): Interface;
            /**
             * Get a particular network which has name `name`.
             * @param name name of the network to search for
             * @returns A new reference to a #GVirNetwork, or NULL if no network exists with name @name. The returned object must be unreffed using g_object_unref() once used.
             */
            find_network_by_name(name: string): Network;
            find_storage_pool_by_name(name: string): StoragePool;
            get_capabilities(): LibvirtGConfig.Capabilities;
            get_capabilities_async(cancellable?: Gio.Cancellable | null): Promise<LibvirtGConfig.Capabilities>;
            get_capabilities_async(
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            get_capabilities_async(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<LibvirtGConfig.Capabilities> | void;
            get_capabilities_finish(result: Gio.AsyncResult): LibvirtGConfig.Capabilities;
            get_domain(uuid: string): Domain;
            get_domain_capabilities(
                emulatorbin: string | null,
                arch: string | null,
                machine: string | null,
                virttype: string | null,
                flags: number,
            ): LibvirtGConfig.DomainCapabilities;
            get_domain_capabilities_async(
                emulatorbin: string | null,
                arch: string | null,
                machine: string | null,
                virttype: string | null,
                flags: number,
                cancellable?: Gio.Cancellable | null,
            ): Promise<LibvirtGConfig.DomainCapabilities>;
            get_domain_capabilities_async(
                emulatorbin: string | null,
                arch: string | null,
                machine: string | null,
                virttype: string | null,
                flags: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            get_domain_capabilities_async(
                emulatorbin: string | null,
                arch: string | null,
                machine: string | null,
                virttype: string | null,
                flags: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<LibvirtGConfig.DomainCapabilities> | void;
            get_domain_capabilities_finish(result: Gio.AsyncResult): LibvirtGConfig.DomainCapabilities;
            /**
             * Gets a list of the domains available through `conn`.
             * @returns List of #GVirDomain. The returned list should be freed with g_list_free(), after its elements have been unreffed with g_object_unref().
             */
            get_domains(): Domain[];
            /**
             * Get name of current hypervisor used.
             * @returns new string that should be freed when no longer needed, or NULL upon error.
             */
            get_hypervisor_name(): string;
            /**
             * Get a particular interface which has name `name`.
             * @param name interface name to lookup
             * @returns A new reference to a #GVirInterface, or NULL if no interface exists with name @name. The returned object must be unreffed using g_object_unref() once used.
             */
            get_interface(name: string): Interface;
            /**
             * Get a list of all the network interfaces managed by connection `conn` on
             * host machine.
             * @returns List of #GVirInterface. The returned list should be freed with g_list_free(), after its elements have been unreffed with g_object_unref().
             */
            get_interfaces(): Interface[];
            /**
             * Get a particular network which has UUID `uuid`.
             * @param uuid UUID of the network to lookup
             * @returns A new reference to a #GVirNetwork, or NULL if no network exists with UUID @uuid. The returned object must be unreffed using g_object_unref() once used.
             */
            get_network(uuid: string): Network;
            /**
             * Get a list of all the network networks available through `conn`.
             * @returns List of #GVirNetwork. The returned list should be freed with g_list_free(), after its elements have been unreffed with g_object_unref().
             */
            get_networks(): Network[];
            get_node_info(): NodeInfo;
            get_storage_pool(uuid: string): StoragePool;
            /**
             * Gets a list of the storage pools available through `conn`.
             * @returns List of #GVirStoragePool. The returned list should be freed with g_list_free(), after its elements have been unreffed with g_object_unref().
             */
            get_storage_pools(): StoragePool[];
            get_stream(flags: number): Stream;
            get_uri(): string;
            /**
             * Get version of current hypervisor used.
             * @returns version on success, 0 otherwise and @err set.
             */
            get_version(): number;
            is_open(): boolean;
            is_read_only(): boolean;
            open(cancellable?: Gio.Cancellable | null): boolean;
            open_async(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            open_async(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            open_async(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            open_finish(result: Gio.AsyncResult): boolean;
            open_read_only(cancellable?: Gio.Cancellable | null): boolean;
            open_read_only_async(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            open_read_only_async(
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            open_read_only_async(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            open_read_only_finish(result: Gio.AsyncResult): boolean;
            /**
             * Restores the domain saved with #gvir_domain_save_to_file
             * @param filename path to input file
             * @param custom_conf configuration for domain or NULL
             * @param flags the flags
             * @returns TRUE on success, FALSE otherwise
             */
            restore_domain_from_file(
                filename: string,
                custom_conf: LibvirtGConfig.Domain | null,
                flags: number,
            ): boolean;
            /**
             * Asynchronous variant of #gvir_connection_restore_domain_from_file
             * @param filename path to input file
             * @param custom_conf configuration for domain
             * @param flags the flags
             * @param cancellable cancellation object
             */
            restore_domain_from_file_async(
                filename: string,
                custom_conf: LibvirtGConfig.Domain | null,
                flags: number,
                cancellable?: Gio.Cancellable | null,
            ): Promise<boolean>;
            /**
             * Asynchronous variant of #gvir_connection_restore_domain_from_file
             * @param filename path to input file
             * @param custom_conf configuration for domain
             * @param flags the flags
             * @param cancellable cancellation object
             * @param callback completion callback
             */
            restore_domain_from_file_async(
                filename: string,
                custom_conf: LibvirtGConfig.Domain | null,
                flags: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronous variant of #gvir_connection_restore_domain_from_file
             * @param filename path to input file
             * @param custom_conf configuration for domain
             * @param flags the flags
             * @param cancellable cancellation object
             * @param callback completion callback
             */
            restore_domain_from_file_async(
                filename: string,
                custom_conf: LibvirtGConfig.Domain | null,
                flags: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes the operation started by #gvir_restore_domain_from_file_async.
             * @param result async method result
             * @returns TRUE if domain was restored successfully, FALSE otherwise.
             */
            restore_domain_from_file_finish(result: Gio.AsyncResult): boolean;
            /**
             * Start a new transient domain without persistent configuration.
             * The returned domain will initially be running.
             * @param conf the configuration for the new domain
             * @param flags
             * @returns the newly created domain, or NULL if an error occurred. The returned object should be unreffed with g_object_unref() when no longer needed.
             */
            start_domain(conf: LibvirtGConfig.Domain, flags: number): Domain;
        }

        module Domain {
            // Signal callback interfaces

            interface Pmsuspended {
                (): void;
            }

            interface Resumed {
                (): void;
            }

            interface Started {
                (): void;
            }

            interface Stopped {
                (): void;
            }

            interface Suspended {
                (): void;
            }

            interface Updated {
                (): void;
            }

            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {
                handle: DomainHandle;
                persistent: boolean;
            }
        }

        class Domain extends GObject.Object {
            static $gtype: GObject.GType<Domain>;

            // Properties

            get handle(): DomainHandle;
            get persistent(): boolean;

            // Constructors

            constructor(properties?: Partial<Domain.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'pmsuspended', callback: (_source: this) => void): number;
            connect_after(signal: 'pmsuspended', callback: (_source: this) => void): number;
            emit(signal: 'pmsuspended'): void;
            connect(signal: 'resumed', callback: (_source: this) => void): number;
            connect_after(signal: 'resumed', callback: (_source: this) => void): number;
            emit(signal: 'resumed'): void;
            connect(signal: 'started', callback: (_source: this) => void): number;
            connect_after(signal: 'started', callback: (_source: this) => void): number;
            emit(signal: 'started'): void;
            connect(signal: 'stopped', callback: (_source: this) => void): number;
            connect_after(signal: 'stopped', callback: (_source: this) => void): number;
            emit(signal: 'stopped'): void;
            connect(signal: 'suspended', callback: (_source: this) => void): number;
            connect_after(signal: 'suspended', callback: (_source: this) => void): number;
            emit(signal: 'suspended'): void;
            connect(signal: 'updated', callback: (_source: this) => void): number;
            connect_after(signal: 'updated', callback: (_source: this) => void): number;
            emit(signal: 'updated'): void;

            // Virtual methods

            vfunc_pmsuspended(): void;
            vfunc_resumed(): void;
            vfunc_started(): void;
            vfunc_stopped(): void;
            vfunc_suspended(): void;
            vfunc_updated(): void;

            // Methods

            create_snapshot(custom_conf: LibvirtGConfig.DomainSnapshot | null, flags: number): DomainSnapshot;
            create_snapshot_async(
                custom_conf: LibvirtGConfig.DomainSnapshot | null,
                flags: number,
                cancellable?: Gio.Cancellable | null,
            ): Promise<DomainSnapshot>;
            create_snapshot_async(
                custom_conf: LibvirtGConfig.DomainSnapshot | null,
                flags: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            create_snapshot_async(
                custom_conf: LibvirtGConfig.DomainSnapshot | null,
                flags: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<DomainSnapshot> | void;
            create_snapshot_finish(result: Gio.AsyncResult): DomainSnapshot;
            ['delete'](flags: number): boolean;
            fetch_snapshots(list_flags: number, cancellable?: Gio.Cancellable | null): boolean;
            fetch_snapshots_async(list_flags: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            fetch_snapshots_async(
                list_flags: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            fetch_snapshots_async(
                list_flags: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            fetch_snapshots_finish(res: Gio.AsyncResult): boolean;
            get_config(flags: number): LibvirtGConfig.Domain;
            /**
             * Gets the list of devices attached to `domain`. The returned list should
             * be freed with g_list_free(), after its elements have been unreffed with
             * g_object_unref().
             * @returns a newly allocated #GList of #GVirDomainDevice.
             */
            get_devices(): DomainDevice[];
            get_has_current_snapshot(flags: number): [boolean, boolean];
            get_id(): number;
            get_info(): DomainInfo;
            /**
             * Asynchronous variant of #gvir_domain_get_info.
             * @param cancellable cancellation object
             */
            get_info_async(cancellable?: Gio.Cancellable | null): Promise<DomainInfo>;
            /**
             * Asynchronous variant of #gvir_domain_get_info.
             * @param cancellable cancellation object
             * @param callback completion callback
             */
            get_info_async(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronous variant of #gvir_domain_get_info.
             * @param cancellable cancellation object
             * @param callback completion callback
             */
            get_info_async(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<DomainInfo> | void;
            /**
             * Finishes the operation started by #gvir_domain_get_info_async.
             * @param result async method result
             * @returns the info. The returned object should be unreffed with g_object_unref() when no longer needed.
             */
            get_info_finish(result: Gio.AsyncResult): DomainInfo;
            get_name(): string;
            get_persistent(): boolean;
            get_saved(): boolean;
            get_snapshots(): DomainSnapshot[];
            get_uuid(): string;
            /**
             * Open a text console for the domain `dom,` connecting it to the
             * stream `stream`. If `devname` is NULL, the default console will
             * be opened, otherwise `devname` can be used to specify a non-default
             * console device.
             * @param stream stream to use as output
             * @param devname the device name
             * @param flags extra flags, currently unused
             * @returns TRUE if the console was opened, FALSE otherwise.
             */
            open_console(stream: Stream, devname: string | null, flags: number): boolean;
            /**
             * Open a connection to the local graphics display, connecting it to the
             * socket pair file descriptor passed in as `fd`.
             * @param idx the graphics index
             * @param fd pre-opened socket pair
             * @param flags extra flags, currently unused
             * @returns TRUE if the graphics connection was opened, FALSE otherwise.
             */
            open_graphics(idx: number, fd: number, flags: number): boolean;
            /**
             * This will create a socket pair connected to the graphics backend of `dom`. One
             * end of the socket will be returned on success, and the other end is handed to
             * the hypervisor. If `dom` has multiple graphics backends configured, then `idx`
             * will determine which one is opened, starting from `idx` 0.
             * @param idx the graphics index
             * @param flags extra flags, currently unused
             * @returns An fd on success, -1 on failure.
             */
            open_graphics_fd(idx: number, flags: number): number;
            reboot(flags: number): boolean;
            resume(): boolean;
            /**
             * Asynchronous variant of #gvir_domain_resume.
             * @param cancellable cancellation object
             */
            resume_async(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronous variant of #gvir_domain_resume.
             * @param cancellable cancellation object
             * @param callback completion callback
             */
            resume_async(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronous variant of #gvir_domain_resume.
             * @param cancellable cancellation object
             * @param callback completion callback
             */
            resume_async(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            resume_finish(result: Gio.AsyncResult): boolean;
            /**
             * Saves the state of the domain on disk and stops it. Use #gvir_domain_start
             * to restore the saved state of the domain. A saved domain can be restored
             * even after shutdown/reboot of host machine.
             * @param flags extra flags, currently unused
             * @returns TRUE if domain was saved successfully, FALSE otherwise.
             */
            save(flags: number): boolean;
            /**
             * Asynchronous variant of #gvir_domain_save.
             * @param flags extra flags, currently unused
             * @param cancellable cancellation object
             */
            save_async(flags: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronous variant of #gvir_domain_save.
             * @param flags extra flags, currently unused
             * @param cancellable cancellation object
             * @param callback completion callback
             */
            save_async(
                flags: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronous variant of #gvir_domain_save.
             * @param flags extra flags, currently unused
             * @param cancellable cancellation object
             * @param callback completion callback
             */
            save_async(
                flags: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes the operation started by #gvir_domain_save_async.
             * @param result async method result
             * @returns TRUE if domain was saved successfully, FALSE otherwise.
             */
            save_finish(result: Gio.AsyncResult): boolean;
            save_to_file(filename: string, custom_conf: LibvirtGConfig.Domain | null, flags: number): boolean;
            /**
             * Asynchronous variant of #gvir_domain_save_to_file
             * @param filename path to output file
             * @param custom_conf configuration for domain or NULL
             * @param flags the flags
             * @param cancellable cancellation object
             */
            save_to_file_async(
                filename: string,
                custom_conf: LibvirtGConfig.Domain | null,
                flags: number,
                cancellable?: Gio.Cancellable | null,
            ): Promise<boolean>;
            /**
             * Asynchronous variant of #gvir_domain_save_to_file
             * @param filename path to output file
             * @param custom_conf configuration for domain or NULL
             * @param flags the flags
             * @param cancellable cancellation object
             * @param callback completion callback
             */
            save_to_file_async(
                filename: string,
                custom_conf: LibvirtGConfig.Domain | null,
                flags: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronous variant of #gvir_domain_save_to_file
             * @param filename path to output file
             * @param custom_conf configuration for domain or NULL
             * @param flags the flags
             * @param cancellable cancellation object
             * @param callback completion callback
             */
            save_to_file_async(
                filename: string,
                custom_conf: LibvirtGConfig.Domain | null,
                flags: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes the operation started by #gvir_domain_save_to_file_async.
             * @param result async method result
             * @returns TRUE if domain was saved successfully, FALSE otherwise.
             */
            save_to_file_finish(result: Gio.AsyncResult): boolean;
            screenshot(stream: Stream, monitor_id: number, flags: number): string;
            /**
             * Resets configuration of an existing domain.
             *
             * Note: If domain is already running, the new configuration will not take
             * affect until domain reboots.
             * @param conf the new configuration for the domain
             * @returns TRUE on success, FALSE if an error occurred.
             */
            set_config(conf: LibvirtGConfig.Domain): boolean;
            /**
             * This function tries to set guest time to the given value. The passed
             * time must in UTC.
             *
             * If `date_time` is %NULL, the time is reset using the domain's RTC.
             *
             * Please note that some hypervisors may require guest agent to be configured
             * and running in order for this function to work.
             * @param date_time the time to set as #GDateTime.
             * @param flags Unused, pass 0.
             * @returns %TRUE on success, %FALSE otherwise.
             */
            set_time(date_time: GLib.DateTime | null, flags: number): boolean;
            /**
             * Asynchronous variant of #gvir_domain_set_time.
             * @param date_time the time to set as #GDateTime.
             * @param flags bitwise-OR of #GVirDomainSetTimeFlags.
             * @param cancellable cancellation object
             */
            set_time_async(
                date_time: GLib.DateTime | null,
                flags: number,
                cancellable?: Gio.Cancellable | null,
            ): Promise<boolean>;
            /**
             * Asynchronous variant of #gvir_domain_set_time.
             * @param date_time the time to set as #GDateTime.
             * @param flags bitwise-OR of #GVirDomainSetTimeFlags.
             * @param cancellable cancellation object
             * @param callback completion callback
             */
            set_time_async(
                date_time: GLib.DateTime | null,
                flags: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronous variant of #gvir_domain_set_time.
             * @param date_time the time to set as #GDateTime.
             * @param flags bitwise-OR of #GVirDomainSetTimeFlags.
             * @param cancellable cancellation object
             * @param callback completion callback
             */
            set_time_async(
                date_time: GLib.DateTime | null,
                flags: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes the operation started by #gvir_domain_set_time_async.
             * @param result async method result
             * @returns %TRUE on success, %FALSE otherwise.
             */
            set_time_finish(result: Gio.AsyncResult): boolean;
            shutdown(flags: number): boolean;
            start(flags: number): boolean;
            /**
             * Asynchronous variant of #gvir_domain_start.
             * @param flags the flags
             * @param cancellable cancellation object
             */
            start_async(flags: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronous variant of #gvir_domain_start.
             * @param flags the flags
             * @param cancellable cancellation object
             * @param callback completion callback
             */
            start_async(
                flags: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronous variant of #gvir_domain_start.
             * @param flags the flags
             * @param cancellable cancellation object
             * @param callback completion callback
             */
            start_async(
                flags: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            start_finish(result: Gio.AsyncResult): boolean;
            stop(flags: number): boolean;
            /**
             * Suspends an active domain, the process is frozen without further access to
             * CPU resources and I/O but the memory used by the domain at the hypervisor
             * level will stay allocated. Use gvir_domain_resume() to reactivate the domain.
             * @returns TRUE if domain was suspended successfully, FALSE otherwise.
             */
            suspend(): boolean;
            /**
             * Update the configuration of a device.
             * @param device A modified device config
             * @param flags bitwise-OR of #GVirDomainUpdateDeviceFlags
             * @returns TRUE if device was updated successfully, FALSE otherwise.
             */
            update_device(device: LibvirtGConfig.DomainDevice, flags: number): boolean;
            wakeup(flags: number): boolean;
            /**
             * Asynchronous variant of #gvir_domain_wakeup.
             * @param flags placeholder for flags, pass 0
             * @param cancellable cancellation object
             */
            wakeup_async(flags: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronous variant of #gvir_domain_wakeup.
             * @param flags placeholder for flags, pass 0
             * @param cancellable cancellation object
             * @param callback completion callback
             */
            wakeup_async(
                flags: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronous variant of #gvir_domain_wakeup.
             * @param flags placeholder for flags, pass 0
             * @param cancellable cancellation object
             * @param callback completion callback
             */
            wakeup_async(
                flags: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            wakeup_finish(result: Gio.AsyncResult): boolean;
        }

        module DomainDevice {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {
                config: LibvirtGConfig.DomainDevice;
                domain: Domain;
            }
        }

        abstract class DomainDevice extends GObject.Object {
            static $gtype: GObject.GType<DomainDevice>;

            // Properties

            get config(): LibvirtGConfig.DomainDevice;
            get domain(): Domain;

            // Constructors

            constructor(properties?: Partial<DomainDevice.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            // Methods

            get_config(): LibvirtGConfig.DomainDevice;
            get_domain(): Domain;
        }

        module DomainDisk {
            // Constructor properties interface

            interface ConstructorProps extends DomainDevice.ConstructorProps {}
        }

        class DomainDisk extends DomainDevice {
            static $gtype: GObject.GType<DomainDisk>;

            // Constructors

            constructor(properties?: Partial<DomainDisk.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            // Methods

            /**
             * This function returns network disk stats. Individual fields
             * within the stats structure may be returned as -1, which indicates
             * that the hypervisor does not support that particular statistic.
             * @returns the stats or %NULL in case of error.The returned object should be unreffed with g_object_unref() when no longer needed.
             */
            get_stats(): DomainDiskStats;
            /**
             * This function resize the disk of a running domain.
             * @param size new size of the block image in kilobytes
             * @param flags flags, currently unused. Pass '0'.
             * @returns TRUE if size was successfully changed, FALSE otherwise.
             */
            resize(size: number, flags: number): boolean;
        }

        module DomainInterface {
            // Constructor properties interface

            interface ConstructorProps extends DomainDevice.ConstructorProps {}
        }

        class DomainInterface extends DomainDevice {
            static $gtype: GObject.GType<DomainInterface>;

            // Constructors

            constructor(properties?: Partial<DomainInterface.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            // Methods

            /**
             * This function returns network interface stats. Individual fields
             * within the stats structure may be returned as -1, which indicates
             * that the hypervisor does not support that particular statistic.
             * @returns the stats or %NULL in case of error. The returned object should be unreffed with g_object_unref() when no longer needed.
             */
            get_stats(): DomainInterfaceStats;
        }

        module DomainSnapshot {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {
                handle: DomainSnapshotHandle;
            }
        }

        class DomainSnapshot extends GObject.Object {
            static $gtype: GObject.GType<DomainSnapshot>;

            // Properties

            get handle(): DomainSnapshotHandle;

            // Constructors

            constructor(properties?: Partial<DomainSnapshot.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            // Methods

            ['delete'](flags: number): boolean;
            delete_async(flags: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            delete_async(
                flags: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            delete_async(
                flags: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            delete_finish(res: Gio.AsyncResult): boolean;
            get_config(flags: number): LibvirtGConfig.DomainSnapshot;
            get_is_current(flags: number): [boolean, boolean];
            get_name(): string;
            revert_to(flags: number): boolean;
            revert_to_async(flags: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            revert_to_async(
                flags: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            revert_to_async(
                flags: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            revert_to_finish(result: Gio.AsyncResult): boolean;
            /**
             * Updates the given snapshot's configuration according to the
             * given GVirConfigDomainSnapshot.
             * @param conf The new config object
             * @returns %TRUE if no error was reported, %FALSE otherwise.
             */
            set_config(conf: LibvirtGConfig.DomainSnapshot): boolean;
        }

        module Interface {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {
                handle: InterfaceHandle;
            }
        }

        class Interface extends GObject.Object {
            static $gtype: GObject.GType<Interface>;

            // Properties

            get handle(): InterfaceHandle;

            // Constructors

            constructor(properties?: Partial<Interface.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            // Methods

            get_config(flags: number): LibvirtGConfig.Interface;
            get_mac(): string;
            get_name(): string;
        }

        module Manager {
            // Signal callback interfaces

            interface ConnectionAdded {
                (object: Connection): void;
            }

            interface ConnectionRemoved {
                (object: Connection): void;
            }

            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {}
        }

        class Manager extends GObject.Object {
            static $gtype: GObject.GType<Manager>;

            // Constructors

            constructor(properties?: Partial<Manager.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            static ['new'](): Manager;

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'connection-added', callback: (_source: this, object: Connection) => void): number;
            connect_after(signal: 'connection-added', callback: (_source: this, object: Connection) => void): number;
            emit(signal: 'connection-added', object: Connection): void;
            connect(signal: 'connection-removed', callback: (_source: this, object: Connection) => void): number;
            connect_after(signal: 'connection-removed', callback: (_source: this, object: Connection) => void): number;
            emit(signal: 'connection-removed', object: Connection): void;

            // Virtual methods

            vfunc_connection_added(conn: Connection): void;
            vfunc_connection_removed(conn: Connection): void;

            // Methods

            add_connection(conn: Connection): void;
            find_connection_by_uri(uri: string): Connection | null;
            get_connections(): Connection[];
            remove_connection(conn: Connection): void;
        }

        module Network {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {
                handle: NetworkHandle;
            }
        }

        class Network extends GObject.Object {
            static $gtype: GObject.GType<Network>;

            // Properties

            get handle(): NetworkHandle;

            // Constructors

            constructor(properties?: Partial<Network.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            // Virtual methods

            vfunc_started(): void;
            vfunc_stopped(): void;

            // Methods

            get_config(flags: number): LibvirtGConfig.Network;
            /**
             * This function fetches leases info of guests in the specified network. If the
             * optional parameter `mac` is specified, the returned list will contain only
             * lease info about a specific guest interface with `mac`. There can be multiple
             * leases for a single `mac` because this API supports DHCPv6 too.
             * @param mac The optional ASCII formatted MAC address of an interface
             * @param flags placeholder for flags, must be 0
             * @returns the list of network leases. Each object in the returned list should be unreffed with g_object_unref() and the list itself using g_list_free, when no longer needed.
             */
            get_dhcp_leases(mac: string | null, flags: number): NetworkDHCPLease[];
            get_name(): string;
            get_uuid(): string;
        }

        module NetworkDHCPLease {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {
                handle: any;
            }
        }

        class NetworkDHCPLease extends GObject.Object {
            static $gtype: GObject.GType<NetworkDHCPLease>;

            // Properties

            get handle(): any;

            // Constructors

            constructor(properties?: Partial<NetworkDHCPLease.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            // Methods

            get_client_id(): string;
            get_expiry_time(): number;
            get_hostname(): string;
            get_iaid(): string;
            get_iface(): string;
            get_ip(): string;
            get_ip_type(): number;
            get_mac(): string;
            get_prefix(): number;
        }

        module NetworkFilter {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {
                handle: NetworkFilterHandle;
            }
        }

        class NetworkFilter extends GObject.Object {
            static $gtype: GObject.GType<NetworkFilter>;

            // Properties

            get handle(): NetworkFilterHandle;

            // Constructors

            constructor(properties?: Partial<NetworkFilter.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            // Methods

            get_config(flags: number): LibvirtGConfig.NetworkFilter;
            get_name(): string;
            get_uuid(): string;
        }

        module NodeDevice {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {
                handle: NodeDeviceHandle;
            }
        }

        class NodeDevice extends GObject.Object {
            static $gtype: GObject.GType<NodeDevice>;

            // Properties

            get handle(): NodeDeviceHandle;

            // Constructors

            constructor(properties?: Partial<NodeDevice.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            // Methods

            get_config(flags: number): LibvirtGConfig.NodeDevice;
            get_name(): string;
        }

        module Secret {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {
                handle: SecretHandle;
            }
        }

        class Secret extends GObject.Object {
            static $gtype: GObject.GType<Secret>;

            // Properties

            get handle(): SecretHandle;

            // Constructors

            constructor(properties?: Partial<Secret.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            // Methods

            get_config(flags: number): LibvirtGConfig.Secret;
            get_name(): string;
            get_uuid(): string;
        }

        module StoragePool {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {
                handle: StoragePoolHandle;
            }
        }

        class StoragePool extends GObject.Object {
            static $gtype: GObject.GType<StoragePool>;

            // Properties

            get handle(): StoragePoolHandle;

            // Constructors

            constructor(properties?: Partial<StoragePool.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            // Methods

            build(flags: number): boolean;
            build_async(flags: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            build_async(
                flags: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            build_async(
                flags: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            build_finish(result: Gio.AsyncResult): boolean;
            create_volume(conf: LibvirtGConfig.StorageVol): StorageVol;
            ['delete'](flags: number): boolean;
            delete_async(flags: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            delete_async(
                flags: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            delete_async(
                flags: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            delete_finish(result: Gio.AsyncResult): boolean;
            get_active(): boolean;
            get_autostart(): boolean;
            get_config(flags: number): LibvirtGConfig.StoragePool;
            get_info(): StoragePoolInfo;
            get_name(): string;
            get_persistent(): boolean;
            get_uuid(): string;
            get_volume(name: string): StorageVol;
            get_volumes(): StorageVol[];
            refresh(cancellable?: Gio.Cancellable | null): boolean;
            refresh_async(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            refresh_async(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            refresh_async(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            refresh_finish(result: Gio.AsyncResult): boolean;
            /**
             * Sets whether or not storage pool `pool` is started automatically on boot.
             * @param autostart Whether or not to autostart
             * @returns #TRUE on success, #FALSE otherwise.
             */
            set_autostart(autostart: boolean): boolean;
            start(flags: number): boolean;
            start_async(flags: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            start_async(
                flags: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            start_async(
                flags: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            start_finish(result: Gio.AsyncResult): boolean;
            stop(): boolean;
            stop_async(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            stop_async(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            stop_async(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            stop_finish(result: Gio.AsyncResult): boolean;
            undefine(): boolean;
            undefine_async(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            undefine_async(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            undefine_async(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            undefine_finish(result: Gio.AsyncResult): boolean;
        }

        module StorageVol {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {
                handle: StorageVolHandle;
                pool: StoragePool;
            }
        }

        class StorageVol extends GObject.Object {
            static $gtype: GObject.GType<StorageVol>;

            // Properties

            get handle(): StorageVolHandle;
            get pool(): StoragePool;

            // Constructors

            constructor(properties?: Partial<StorageVol.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            // Methods

            /**
             * Deletes the storage volume `vol`.
             * @param flags the flags
             * @returns %TRUE on success, %FALSE otherwise
             */
            ['delete'](flags: number): boolean;
            download(stream: Stream, offset: number, length: number, flags: number): boolean;
            get_config(flags: number): LibvirtGConfig.StorageVol;
            get_info(): StorageVolInfo;
            get_name(): string;
            get_path(): string;
            /**
             * Changes the capacity of the storage volume `vol` to `capacity`.
             * @param capacity the new capacity of the volume
             * @param flags the flags
             * @returns #TRUE success, #FALSE otherwise
             */
            resize(capacity: number, flags: StorageVolResizeFlags | null): boolean;
            upload(stream: Stream, offset: number, length: number, flags: number): boolean;
        }

        module Stream {
            // Constructor properties interface

            interface ConstructorProps extends Gio.IOStream.ConstructorProps {
                handle: StreamHandle;
            }
        }

        class Stream extends Gio.IOStream {
            static $gtype: GObject.GType<Stream>;

            // Properties

            get handle(): StreamHandle;

            // Constructors

            constructor(properties?: Partial<Stream.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            // Methods

            /**
             * Adds a watch for `stream` to the mainloop
             * @param priority the priority of the #GVirStream source
             * @param cond the conditions to watch for (bitfield of #GVirStreamIOCondition)
             * @param func the function to call when the condition is satisfied
             * @returns the event source id
             */
            add_watch(priority: number, cond: StreamIOCondition | null, func: StreamIOFunc): number;
            /**
             * Receive data (up to `size` bytes) from a stream.
             * On error -1 is returned and `error` is set accordingly.
             *
             * gvir_stream_receive() can return any number of bytes, up to
             * `size`. If more than `size` bytes have been received, the additional
             * data will be returned in future calls to gvir_stream_receive().
             *
             * If there is no data available, a %G_IO_ERROR_WOULD_BLOCK error will be
             * returned.
             * @param buffer a buffer     to read data into (which should be at least @size bytes long).
             * @param cancellable a %GCancellable or %NULL
             * @returns Number of bytes read, or 0 if the end of stream reached, or -1 on error.
             */
            receive(buffer: Uint8Array | string, cancellable?: Gio.Cancellable | null): number;
            /**
             * Receive the entire data stream, sending the data to the
             * requested data sink. This is simply a convenient alternative
             * to virStreamRecv, for apps that do blocking-I/o.
             * @param cancellable cancellation notifier
             * @param func the callback for writing data to application
             * @returns the number of bytes consumed or -1 upon error
             */
            receive_all(cancellable: Gio.Cancellable | null, func: StreamSinkFunc): number;
            /**
             * Send data (up to `size` bytes) from a stream.
             * On error -1 is returned and `error` is set accordingly.
             *
             * gvir_stream_send() can return any number of bytes, up to
             * `size`. If more than `size` bytes have been sendd, the additional
             * data will be returned in future calls to gvir_stream_send().
             *
             * If there is no data available, a %G_IO_ERROR_WOULD_BLOCK error will be
             * returned.
             * @param buffer a buffer to write data from (which should be at least @size     bytes long).
             * @param size the number of bytes you want to write to the stream
             * @param cancellable a %GCancellable or %NULL
             * @returns Number of bytes written.
             */
            send(buffer: string, size: number, cancellable?: Gio.Cancellable | null): number;
            /**
             * Send the entire data stream, sending the data to the
             * requested data source. This is simply a convenient alternative
             * to virStreamRecv, for apps that do blocking-I/o.
             * @param cancellable cancellation notifier
             * @param func the callback for writing data to application
             * @returns the number of bytes consumed or -1 upon error
             */
            send_all(cancellable: Gio.Cancellable | null, func: StreamSourceFunc): number;
        }

        type ConnectionClass = typeof Connection;
        abstract class ConnectionPrivate {
            static $gtype: GObject.GType<ConnectionPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type DomainClass = typeof Domain;
        type DomainDeviceClass = typeof DomainDevice;
        abstract class DomainDevicePrivate {
            static $gtype: GObject.GType<DomainDevicePrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type DomainDiskClass = typeof DomainDisk;
        abstract class DomainDiskPrivate {
            static $gtype: GObject.GType<DomainDiskPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        class DomainDiskStats {
            static $gtype: GObject.GType<DomainDiskStats>;

            // Fields

            rd_req: number;
            rd_bytes: number;
            wr_req: number;
            wr_bytes: number;
            errs: number;

            // Constructors

            constructor(
                properties?: Partial<{
                    rd_req: number;
                    rd_bytes: number;
                    wr_req: number;
                    wr_bytes: number;
                    errs: number;
                }>,
            );
            _init(...args: any[]): void;
        }

        class DomainInfo {
            static $gtype: GObject.GType<DomainInfo>;

            // Fields

            state: DomainState;
            maxMem: number;
            memory: number;
            nrVirtCpu: number;
            cpuTime: number;

            // Constructors

            _init(...args: any[]): void;
        }

        type DomainInterfaceClass = typeof DomainInterface;
        abstract class DomainInterfacePrivate {
            static $gtype: GObject.GType<DomainInterfacePrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        class DomainInterfaceStats {
            static $gtype: GObject.GType<DomainInterfaceStats>;

            // Fields

            rx_bytes: number;
            rx_packets: number;
            rx_errs: number;
            rx_drop: number;
            tx_bytes: number;
            tx_packets: number;
            tx_errs: number;
            tx_drop: number;

            // Constructors

            constructor(
                properties?: Partial<{
                    rx_bytes: number;
                    rx_packets: number;
                    rx_errs: number;
                    rx_drop: number;
                    tx_bytes: number;
                    tx_packets: number;
                    tx_errs: number;
                    tx_drop: number;
                }>,
            );
            _init(...args: any[]): void;
        }

        abstract class DomainPrivate {
            static $gtype: GObject.GType<DomainPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type DomainSnapshotClass = typeof DomainSnapshot;
        abstract class DomainSnapshotPrivate {
            static $gtype: GObject.GType<DomainSnapshotPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type InterfaceClass = typeof Interface;
        abstract class InterfacePrivate {
            static $gtype: GObject.GType<InterfacePrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type ManagerClass = typeof Manager;
        abstract class ManagerPrivate {
            static $gtype: GObject.GType<ManagerPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type NetworkClass = typeof Network;
        type NetworkDHCPLeaseClass = typeof NetworkDHCPLease;
        abstract class NetworkDHCPLeasePrivate {
            static $gtype: GObject.GType<NetworkDHCPLeasePrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type NetworkFilterClass = typeof NetworkFilter;
        abstract class NetworkFilterPrivate {
            static $gtype: GObject.GType<NetworkFilterPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        abstract class NetworkPrivate {
            static $gtype: GObject.GType<NetworkPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type NodeDeviceClass = typeof NodeDevice;
        abstract class NodeDevicePrivate {
            static $gtype: GObject.GType<NodeDevicePrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        class NodeInfo {
            static $gtype: GObject.GType<NodeInfo>;

            // Fields

            model: number[];
            memory: number;
            cpus: number;
            mhz: number;
            nodes: number;
            sockets: number;
            cores: number;
            threads: number;

            // Constructors

            constructor(
                properties?: Partial<{
                    model: number[];
                    memory: number;
                    cpus: number;
                    mhz: number;
                    nodes: number;
                    sockets: number;
                    cores: number;
                    threads: number;
                }>,
            );
            _init(...args: any[]): void;
        }

        type SecretClass = typeof Secret;
        abstract class SecretPrivate {
            static $gtype: GObject.GType<SecretPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type StoragePoolClass = typeof StoragePool;
        class StoragePoolInfo {
            static $gtype: GObject.GType<StoragePoolInfo>;

            // Fields

            state: StoragePoolState;
            capacity: number;
            allocation: number;
            available: number;

            // Constructors

            _init(...args: any[]): void;
        }

        abstract class StoragePoolPrivate {
            static $gtype: GObject.GType<StoragePoolPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type StorageVolClass = typeof StorageVol;
        class StorageVolInfo {
            static $gtype: GObject.GType<StorageVolInfo>;

            // Fields

            type: StorageVolType;
            capacity: number;
            allocation: number;

            // Constructors

            _init(...args: any[]): void;
        }

        abstract class StorageVolPrivate {
            static $gtype: GObject.GType<StorageVolPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type StreamClass = typeof Stream;
        abstract class StreamPrivate {
            static $gtype: GObject.GType<StreamPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        /**
         * Name of the imported GIR library
         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L188
         */
        const __name__: string;
        /**
         * Version of the imported GIR library
         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L189
         */
        const __version__: string;
    }

    export default LibvirtGObject;
}

declare module 'gi://LibvirtGObject' {
    import LibvirtGObject10 from 'gi://LibvirtGObject?version=1.0';
    export default LibvirtGObject10;
}
// END