incus-ts 0.1.2 → 0.1.4

package/dist/incus.d.ts

@@ -0,0 +1,685 @@
+export type IncusRecord = Record<string, unknown>;
+export type IncusInstanceType = "container" | "virtual-machine" | string;
+export type IncusBinaryInput = Blob | ArrayBuffer | ArrayBufferView | Uint8Array | ReadableStream<Uint8Array>;
+export type IncusProgress = {
+    processedBytes?: number;
+    totalBytes?: number;
+    percent?: number;
+    speedBytesPerSecond?: number;
+};
+export type IncusEntity<T = unknown> = {
+    value: T;
+    etag?: string;
+};
+export type IncusMutationOptions = {
+    etag?: string;
+};
+export type IncusListOptions = {
+    filter?: string[];
+    allProjects?: boolean;
+};
+export type IncusScopeOptions = {
+    allProjects?: boolean;
+};
+export type IncusRequestContext = {
+    project?: string;
+    target?: string;
+    requireAuthenticated?: boolean;
+};
+export type IncusConnectionOptions = {
+    userAgent?: string;
+    authType?: string;
+    skipGetEvents?: boolean;
+    skipGetServer?: boolean;
+    headers?: HeadersInit;
+    fetch?: typeof fetch;
+    signal?: AbortSignal;
+    tempPath?: string;
+    tlsServerCert?: string;
+    tlsClientCert?: string;
+    tlsClientKey?: string;
+    tlsCA?: string;
+    insecureSkipVerify?: boolean;
+    identicalCertificate?: boolean;
+    oidcTokens?: {
+        accessToken?: string;
+        refreshToken?: string;
+        expiry?: string;
+    };
+};
+export type IncusSimpleStreamsOptions = IncusConnectionOptions & {
+    cachePath?: string;
+    cacheExpiryMs?: number;
+};
+export type IncusUnixConnectOptions = IncusConnectionOptions & {
+    socketPath?: string;
+};
+export type IncusHttpConnectOptions = IncusConnectionOptions & {
+    endpoint?: string;
+};
+export type IncusConnectKind = "incus" | "incus-public" | "incus-unix" | "incus-http" | "simple-streams";
+export type IncusConnectionInfo = {
+    addresses: string[];
+    certificate?: string;
+    protocol?: string;
+    url?: string;
+    socketPath?: string;
+    project?: string;
+    target?: string;
+};
+export type IncusTransportRequestOptions = {
+    query?: Record<string, string | number | boolean | undefined>;
+    headers?: HeadersInit;
+    body?: unknown;
+    signal?: AbortSignal;
+    etag?: string;
+    context?: IncusRequestContext;
+};
+export type IncusTransportResponse<T = unknown> = {
+    status: number;
+    etag?: string;
+    data: T;
+    headers?: Headers;
+};
+export interface IncusTransport {
+    request<T = unknown>(method: string, path: string, options?: IncusTransportRequestOptions): Promise<IncusTransportResponse<T>>;
+    websocket?(path: string, protocols?: string | string[]): Promise<WebSocket>;
+    close?(): void;
+}
+export type IncusOperationWaitOptions = {
+    timeoutSeconds?: number;
+    signal?: AbortSignal;
+};
+export interface IncusOperation {
+    id: string;
+    wait(options?: IncusOperationWaitOptions): Promise<IncusRecord>;
+    cancel(): Promise<void>;
+    refresh(): Promise<IncusRecord>;
+    websocket(secret: string): Promise<WebSocket>;
+    onUpdate(handler: (operation: IncusRecord) => void): Promise<() => void>;
+}
+export interface IncusAwaitableOperation extends IncusOperation, PromiseLike<IncusRecord> {
+    catch<TResult = never>(onRejected?: ((reason: unknown) => TResult | PromiseLike<TResult>) | null): Promise<IncusRecord | TResult>;
+    finally(onFinally?: (() => void) | null): Promise<IncusRecord>;
+}
+export interface IncusRemoteOperation {
+    wait(options?: IncusOperationWaitOptions): Promise<void>;
+    cancelTarget(): Promise<void>;
+    target(): Promise<IncusRecord | null>;
+    onUpdate(handler: (operation: IncusRecord) => void): Promise<() => void>;
+}
+export type IncusEventStreamOptions = {
+    types?: string[];
+    allProjects?: boolean;
+    signal?: AbortSignal;
+};
+export type IncusEvent = {
+    type: string;
+    timestamp?: string;
+    metadata?: IncusRecord;
+};
+export interface IncusEventListener extends AsyncIterable<IncusEvent> {
+    close(): Promise<void>;
+}
+export interface ConnectionApi {
+    info(): Promise<IncusConnectionInfo>;
+    httpClient(): Promise<unknown>;
+    doHttp(request: Request): Promise<Response>;
+    disconnect(): void;
+}
+export interface ServerApi {
+    metrics(): Promise<string>;
+    get(): Promise<IncusEntity<IncusRecord>>;
+    resources(): Promise<IncusRecord>;
+    update(server: IncusRecord, options?: IncusMutationOptions): Promise<void>;
+    applyPreseed(config: IncusRecord): Promise<void>;
+    hasExtension(extension: string): Promise<boolean>;
+    isClustered(): Promise<boolean>;
+}
+export interface CertificatesApi {
+    fingerprints(): Promise<string[]>;
+    list(options?: IncusListOptions): Promise<IncusRecord[]>;
+    get(fingerprint: string): Promise<IncusEntity<IncusRecord>>;
+    create(certificate: IncusRecord): Promise<void>;
+    update(fingerprint: string, certificate: IncusRecord, options?: IncusMutationOptions): Promise<void>;
+    remove(fingerprint: string): Promise<void>;
+    createToken(certificate: IncusRecord): IncusAwaitableOperation;
+}
+export type ImageListOptions = IncusListOptions;
+export type ImageDownloadOptions = {
+    signal?: AbortSignal;
+    onProgress?: (progress: IncusProgress) => void;
+    secret?: string;
+};
+export type ImageDownloadResult = {
+    metadataName?: string;
+    metadataSize?: number;
+    rootfsName?: string;
+    rootfsSize?: number;
+};
+export interface ImageAliasesApi {
+    list(): Promise<IncusRecord[]>;
+    names(): Promise<string[]>;
+    get(name: string, options?: {
+        imageType?: string;
+    }): Promise<IncusEntity<IncusRecord>>;
+    getArchitectures(name: string, options?: {
+        imageType?: string;
+    }): Promise<Record<string, IncusRecord>>;
+    create(alias: IncusRecord): Promise<void>;
+    update(name: string, alias: IncusRecord, options?: IncusMutationOptions): Promise<void>;
+    rename(name: string, alias: IncusRecord): Promise<void>;
+    remove(name: string): Promise<void>;
+}
+export interface ImagesApi {
+    list(options?: ImageListOptions): Promise<IncusRecord[]>;
+    fingerprints(options?: ImageListOptions): Promise<string[]>;
+    get(fingerprint: string, options?: {
+        secret?: string;
+    }): Promise<IncusEntity<IncusRecord>>;
+    downloadFile(fingerprint: string, options?: ImageDownloadOptions): Promise<ImageDownloadResult>;
+    create(image: IncusRecord, upload?: IncusRecord): IncusAwaitableOperation;
+    copyFrom(source: IncusImageClient, image: IncusRecord, options?: IncusRecord): Promise<IncusRemoteOperation>;
+    update(fingerprint: string, image: IncusRecord, options?: IncusMutationOptions): Promise<void>;
+    remove(fingerprint: string): IncusAwaitableOperation;
+    refresh(fingerprint: string): IncusAwaitableOperation;
+    createSecret(fingerprint: string): IncusAwaitableOperation;
+    export(fingerprint: string, request?: IncusRecord): IncusAwaitableOperation;
+    aliases: ImageAliasesApi;
+}
+export type InstanceListOptions = IncusListOptions & {
+    type?: IncusInstanceType;
+    full?: boolean;
+};
+export type InstanceExecOptions = {
+    stdin?: IncusBinaryInput;
+    stdout?: "pipe" | WritableStream<Uint8Array>;
+    stderr?: "pipe" | WritableStream<Uint8Array>;
+    signal?: AbortSignal;
+    onControl?: (socket: WebSocket) => void;
+};
+export type InstanceForkOptions = {
+    fromSnapshot?: string;
+    sourceProject?: string;
+    live?: boolean;
+    instanceOnly?: boolean;
+    refresh?: boolean;
+    refreshExcludeOlder?: boolean;
+    allowInconsistent?: boolean;
+};
+export type IncusExecOutputChunk = {
+    stream: "stdout" | "stderr";
+    chunk: Uint8Array;
+};
+export type IncusExecResult = {
+    operation: IncusRecord;
+    exitCode?: number;
+    ok: boolean;
+};
+export interface IncusExecProcess extends IncusOperation, AsyncIterable<Uint8Array>, PromiseLike<IncusExecResult> {
+    stdout: AsyncIterable<Uint8Array>;
+    stderr: AsyncIterable<Uint8Array>;
+    output(): AsyncIterable<IncusExecOutputChunk>;
+    waitResult(options?: IncusOperationWaitOptions): Promise<IncusExecResult>;
+    catch<TResult = never>(onRejected?: ((reason: unknown) => TResult | PromiseLike<TResult>) | null): Promise<IncusExecResult | TResult>;
+    finally(onFinally?: (() => void) | null): Promise<IncusExecResult>;
+}
+export type InstanceConsoleOptions = {
+    terminal?: WebSocket;
+    signal?: AbortSignal;
+    onControl?: (socket: WebSocket) => void;
+};
+export type InstanceConsoleDynamicResult = {
+    operation: IncusOperation;
+    attach: (terminal: WebSocket) => Promise<void>;
+};
+export type InstanceFilePutOptions = {
+    content: IncusBinaryInput;
+    uid?: number;
+    gid?: number;
+    mode?: number;
+    type?: "file" | "directory" | string;
+    writeMode?: "overwrite" | "append" | string;
+};
+export type InstanceFileResult = {
+    stream: ReadableStream<Uint8Array>;
+    uid?: number;
+    gid?: number;
+    mode?: number;
+    type?: string;
+    entries?: string[];
+};
+export interface InstanceLogsApi {
+    list(): Promise<string[]>;
+    get(filename: string): Promise<ReadableStream<Uint8Array>>;
+    remove(filename: string): Promise<void>;
+    getConsole(): Promise<ReadableStream<Uint8Array>>;
+    removeConsole(): Promise<void>;
+}
+export interface InstanceFilesApi {
+    get(path: string): Promise<InstanceFileResult>;
+    put(path: string, options: InstanceFilePutOptions): Promise<void>;
+    remove(path: string): Promise<void>;
+    sftp(): Promise<unknown>;
+}
+export interface InstanceTemplatesApi {
+    list(): Promise<string[]>;
+    get(templateName: string): Promise<ReadableStream<Uint8Array>>;
+    put(templateName: string, content: IncusBinaryInput): Promise<void>;
+    remove(templateName: string): Promise<void>;
+}
+export interface InstanceSnapshotsApi {
+    names(): Promise<string[]>;
+    list(): Promise<IncusRecord[]>;
+    get(name: string): Promise<IncusEntity<IncusRecord>>;
+    create(snapshot: IncusRecord): IncusAwaitableOperation;
+    copyFrom(source: IncusClient, snapshot: IncusRecord, options?: IncusRecord): Promise<IncusRemoteOperation>;
+    rename(name: string, request: IncusRecord): IncusAwaitableOperation;
+    migrate(name: string, request: IncusRecord): IncusAwaitableOperation;
+    remove(name: string): IncusAwaitableOperation;
+    update(name: string, snapshot: IncusRecord, options?: IncusMutationOptions): IncusAwaitableOperation;
+    restore(name: string, options?: {
+        stateful?: boolean;
+    }): IncusAwaitableOperation;
+}
+export interface InstanceBackupsApi {
+    names(): Promise<string[]>;
+    list(): Promise<IncusRecord[]>;
+    get(name: string): Promise<IncusEntity<IncusRecord>>;
+    create(backup: IncusRecord): IncusAwaitableOperation;
+    rename(name: string, backup: IncusRecord): IncusAwaitableOperation;
+    remove(name: string): IncusAwaitableOperation;
+    download(name: string): Promise<ReadableStream<Uint8Array>>;
+    upload(backup: IncusRecord, body: IncusBinaryInput): Promise<void>;
+}
+export interface InstanceApi {
+    readonly name: string;
+    get(options?: {
+        full?: boolean;
+    }): Promise<IncusEntity<IncusRecord>>;
+    fork(name: string, options?: InstanceForkOptions): IncusAwaitableOperation;
+    update(instance: IncusRecord, options?: IncusMutationOptions): IncusAwaitableOperation;
+    rename(request: IncusRecord): IncusAwaitableOperation;
+    migrate(request: IncusRecord): IncusAwaitableOperation;
+    remove(): IncusAwaitableOperation;
+    rebuild(request: IncusRecord): IncusAwaitableOperation;
+    rebuildFromImage(source: IncusImageClient, image: IncusRecord, request: IncusRecord): Promise<IncusRemoteOperation>;
+    restore(snapshotName: string, options?: {
+        stateful?: boolean;
+    }): IncusAwaitableOperation;
+    state(): Promise<IncusEntity<IncusRecord>>;
+    setState(state: IncusRecord, options?: IncusMutationOptions): IncusAwaitableOperation;
+    access(): Promise<IncusRecord>;
+    exec(request: IncusRecord, options?: InstanceExecOptions): IncusExecProcess;
+    console(request: IncusRecord, options?: InstanceConsoleOptions): IncusAwaitableOperation;
+    consoleDynamic(request: IncusRecord, options?: InstanceConsoleOptions): Promise<InstanceConsoleDynamicResult>;
+    metadata(): Promise<IncusEntity<IncusRecord>>;
+    updateMetadata(metadata: IncusRecord, options?: IncusMutationOptions): Promise<void>;
+    debugMemory(format?: string): Promise<ReadableStream<Uint8Array>>;
+    logs: InstanceLogsApi;
+    files: InstanceFilesApi;
+    templates: InstanceTemplatesApi;
+    snapshots: InstanceSnapshotsApi;
+    backups: InstanceBackupsApi;
+}
+export interface InstancesApi {
+    names(options?: InstanceListOptions): Promise<string[] | Record<string, string[]>>;
+    list(options?: InstanceListOptions): Promise<IncusRecord[]>;
+    instance(name: string): InstanceApi;
+    create(instance: IncusRecord): IncusAwaitableOperation;
+    createFromImage(source: IncusImageClient, image: IncusRecord, request: IncusRecord): Promise<IncusRemoteOperation>;
+    createFromBackup(args: IncusRecord): IncusAwaitableOperation;
+    copyFrom(source: IncusClient, instance: IncusRecord, options?: IncusRecord): Promise<IncusRemoteOperation>;
+    updateMany(state: IncusRecord, options?: IncusMutationOptions): IncusAwaitableOperation;
+}
+export interface EventsApi {
+    stream(options?: IncusEventStreamOptions): Promise<IncusEventListener>;
+    send(event: IncusEvent): Promise<void>;
+}
+export interface MetadataApi {
+    configuration(): Promise<IncusRecord>;
+}
+export interface NetworkForwardsApi {
+    addresses(networkName: string): Promise<string[]>;
+    list(networkName: string): Promise<IncusRecord[]>;
+    get(networkName: string, listenAddress: string): Promise<IncusEntity<IncusRecord>>;
+    create(networkName: string, request: IncusRecord): Promise<void>;
+    update(networkName: string, listenAddress: string, request: IncusRecord, options?: IncusMutationOptions): Promise<void>;
+    remove(networkName: string, listenAddress: string): Promise<void>;
+}
+export interface NetworkLoadBalancersApi {
+    addresses(networkName: string): Promise<string[]>;
+    list(networkName: string): Promise<IncusRecord[]>;
+    get(networkName: string, listenAddress: string): Promise<IncusEntity<IncusRecord>>;
+    state(networkName: string, listenAddress: string): Promise<IncusRecord>;
+    create(networkName: string, request: IncusRecord): Promise<void>;
+    update(networkName: string, listenAddress: string, request: IncusRecord, options?: IncusMutationOptions): Promise<void>;
+    remove(networkName: string, listenAddress: string): Promise<void>;
+}
+export interface NetworkPeersApi {
+    names(networkName: string): Promise<string[]>;
+    list(networkName: string): Promise<IncusRecord[]>;
+    get(networkName: string, peerName: string): Promise<IncusEntity<IncusRecord>>;
+    create(networkName: string, request: IncusRecord): Promise<void>;
+    update(networkName: string, peerName: string, request: IncusRecord, options?: IncusMutationOptions): Promise<void>;
+    remove(networkName: string, peerName: string): Promise<void>;
+}
+export interface NetworkAclsApi {
+    names(): Promise<string[]>;
+    list(options?: IncusScopeOptions): Promise<IncusRecord[]>;
+    get(name: string): Promise<IncusEntity<IncusRecord>>;
+    getLog(name: string): Promise<ReadableStream<Uint8Array>>;
+    create(request: IncusRecord): Promise<void>;
+    update(name: string, request: IncusRecord, options?: IncusMutationOptions): Promise<void>;
+    rename(name: string, request: IncusRecord): Promise<void>;
+    remove(name: string): Promise<void>;
+}
+export interface NetworkAddressSetsApi {
+    names(): Promise<string[]>;
+    list(options?: IncusScopeOptions): Promise<IncusRecord[]>;
+    get(name: string): Promise<IncusEntity<IncusRecord>>;
+    create(request: IncusRecord): Promise<void>;
+    update(name: string, request: IncusRecord, options?: IncusMutationOptions): Promise<void>;
+    rename(name: string, request: IncusRecord): Promise<void>;
+    remove(name: string): Promise<void>;
+}
+export interface NetworkZoneRecordsApi {
+    names(zone: string): Promise<string[]>;
+    list(zone: string): Promise<IncusRecord[]>;
+    get(zone: string, name: string): Promise<IncusEntity<IncusRecord>>;
+    create(zone: string, request: IncusRecord): Promise<void>;
+    update(zone: string, name: string, request: IncusRecord, options?: IncusMutationOptions): Promise<void>;
+    remove(zone: string, name: string): Promise<void>;
+}
+export interface NetworkZonesApi {
+    names(): Promise<string[]>;
+    list(options?: IncusScopeOptions): Promise<IncusRecord[]>;
+    get(name: string): Promise<IncusEntity<IncusRecord>>;
+    create(request: IncusRecord): Promise<void>;
+    update(name: string, request: IncusRecord, options?: IncusMutationOptions): Promise<void>;
+    remove(name: string): Promise<void>;
+    records: NetworkZoneRecordsApi;
+}
+export interface NetworkIntegrationsApi {
+    names(): Promise<string[]>;
+    list(): Promise<IncusRecord[]>;
+    get(name: string): Promise<IncusEntity<IncusRecord>>;
+    create(request: IncusRecord): Promise<void>;
+    update(name: string, request: IncusRecord, options?: IncusMutationOptions): Promise<void>;
+    rename(name: string, request: IncusRecord): Promise<void>;
+    remove(name: string): Promise<void>;
+}
+export interface NetworksApi {
+    names(): Promise<string[]>;
+    list(options?: IncusListOptions): Promise<IncusRecord[]>;
+    get(name: string): Promise<IncusEntity<IncusRecord>>;
+    leases(name: string): Promise<IncusRecord[]>;
+    state(name: string): Promise<IncusRecord>;
+    create(request: IncusRecord): Promise<void>;
+    update(name: string, request: IncusRecord, options?: IncusMutationOptions): Promise<void>;
+    rename(name: string, request: IncusRecord): Promise<void>;
+    remove(name: string): Promise<void>;
+    allocations(options?: IncusScopeOptions): Promise<IncusRecord[]>;
+    forwards: NetworkForwardsApi;
+    loadBalancers: NetworkLoadBalancersApi;
+    peers: NetworkPeersApi;
+    acls: NetworkAclsApi;
+    addressSets: NetworkAddressSetsApi;
+    zones: NetworkZonesApi;
+    integrations: NetworkIntegrationsApi;
+}
+export interface OperationsApi {
+    uuids(): Promise<string[]>;
+    list(options?: IncusScopeOptions): Promise<IncusRecord[]>;
+    get(uuid: string): Promise<IncusEntity<IncusRecord>>;
+    wait(uuid: string, timeoutSeconds?: number): Promise<IncusEntity<IncusRecord>>;
+    waitWithSecret(uuid: string, secret: string, timeoutSeconds?: number): Promise<IncusEntity<IncusRecord>>;
+    websocket(uuid: string, secret: string): Promise<WebSocket>;
+    remove(uuid: string): Promise<void>;
+}
+export interface ProfilesApi {
+    names(): Promise<string[]>;
+    list(options?: IncusListOptions): Promise<IncusRecord[]>;
+    get(name: string): Promise<IncusEntity<IncusRecord>>;
+    create(profile: IncusRecord): Promise<void>;
+    update(name: string, profile: IncusRecord, options?: IncusMutationOptions): Promise<void>;
+    rename(name: string, profile: IncusRecord): Promise<void>;
+    remove(name: string): Promise<void>;
+}
+export interface ProjectsApi {
+    names(): Promise<string[]>;
+    list(options?: IncusListOptions): Promise<IncusRecord[]>;
+    get(name: string): Promise<IncusEntity<IncusRecord>>;
+    state(name: string): Promise<IncusRecord>;
+    access(name: string): Promise<IncusRecord>;
+    create(project: IncusRecord): Promise<void>;
+    update(name: string, project: IncusRecord, options?: IncusMutationOptions): Promise<void>;
+    rename(name: string, project: IncusRecord): IncusAwaitableOperation;
+    remove(name: string): Promise<void>;
+    removeForce(name: string): Promise<void>;
+}
+export interface StoragePoolsApi {
+    names(): Promise<string[]>;
+    list(options?: IncusListOptions): Promise<IncusRecord[]>;
+    get(name: string): Promise<IncusEntity<IncusRecord>>;
+    resources(name: string): Promise<IncusRecord>;
+    create(pool: IncusRecord): Promise<void>;
+    update(name: string, pool: IncusRecord, options?: IncusMutationOptions): Promise<void>;
+    remove(name: string): Promise<void>;
+}
+export interface StorageBucketKeysApi {
+    names(poolName: string, bucketName: string): Promise<string[]>;
+    list(poolName: string, bucketName: string): Promise<IncusRecord[]>;
+    get(poolName: string, bucketName: string, keyName: string): Promise<IncusEntity<IncusRecord>>;
+    create(poolName: string, bucketName: string, key: IncusRecord): Promise<IncusRecord>;
+    update(poolName: string, bucketName: string, keyName: string, key: IncusRecord, options?: IncusMutationOptions): Promise<void>;
+    remove(poolName: string, bucketName: string, keyName: string): Promise<void>;
+}
+export interface StorageBucketBackupsApi {
+    create(poolName: string, bucketName: string, backup: IncusRecord): IncusAwaitableOperation;
+    remove(poolName: string, bucketName: string, name: string): IncusAwaitableOperation;
+    download(poolName: string, bucketName: string, name: string): Promise<ReadableStream<Uint8Array>>;
+    upload(poolName: string, bucketName: string, backup: IncusRecord, body: IncusBinaryInput): Promise<void>;
+    createFromBackup(poolName: string, args: IncusRecord): IncusAwaitableOperation;
+}
+export interface StorageBucketsApi {
+    names(poolName: string): Promise<string[]>;
+    list(poolName: string, options?: IncusListOptions & {
+        full?: boolean;
+    }): Promise<IncusRecord[]>;
+    get(poolName: string, bucketName: string, options?: {
+        full?: boolean;
+    }): Promise<IncusEntity<IncusRecord>>;
+    create(poolName: string, bucket: IncusRecord): Promise<IncusRecord>;
+    update(poolName: string, bucketName: string, bucket: IncusRecord, options?: IncusMutationOptions): Promise<void>;
+    remove(poolName: string, bucketName: string): Promise<void>;
+    keys: StorageBucketKeysApi;
+    backups: StorageBucketBackupsApi;
+}
+export interface StorageVolumeFilesApi {
+    get(poolName: string, volumeType: string, volumeName: string, filePath: string): Promise<InstanceFileResult>;
+    put(poolName: string, volumeType: string, volumeName: string, filePath: string, options: InstanceFilePutOptions): Promise<void>;
+    remove(poolName: string, volumeType: string, volumeName: string, filePath: string): Promise<void>;
+}
+export interface StorageVolumeSnapshotsApi {
+    names(poolName: string, volumeType: string, volumeName: string): Promise<string[]>;
+    list(poolName: string, volumeType: string, volumeName: string): Promise<IncusRecord[]>;
+    get(poolName: string, volumeType: string, volumeName: string, snapshotName: string): Promise<IncusEntity<IncusRecord>>;
+    create(poolName: string, volumeType: string, volumeName: string, request: IncusRecord): IncusAwaitableOperation;
+    rename(poolName: string, volumeType: string, volumeName: string, snapshotName: string, request: IncusRecord): IncusAwaitableOperation;
+    update(poolName: string, volumeType: string, volumeName: string, snapshotName: string, request: IncusRecord, options?: IncusMutationOptions): Promise<void>;
+    remove(poolName: string, volumeType: string, volumeName: string, snapshotName: string): IncusAwaitableOperation;
+}
+export interface StorageVolumeBackupsApi {
+    names(poolName: string, volumeName: string): Promise<string[]>;
+    list(poolName: string, volumeName: string): Promise<IncusRecord[]>;
+    get(poolName: string, volumeName: string, backupName: string): Promise<IncusEntity<IncusRecord>>;
+    create(poolName: string, volumeName: string, backup: IncusRecord): IncusAwaitableOperation;
+    rename(poolName: string, volumeName: string, backupName: string, request: IncusRecord): IncusAwaitableOperation;
+    remove(poolName: string, volumeName: string, backupName: string): IncusAwaitableOperation;
+    download(poolName: string, volumeName: string, backupName: string): Promise<ReadableStream<Uint8Array>>;
+    upload(poolName: string, volumeName: string, backup: IncusRecord, body: IncusBinaryInput): Promise<void>;
+    createFromBackup(poolName: string, args: IncusRecord): IncusAwaitableOperation;
+    createFromIso(poolName: string, args: IncusRecord): IncusAwaitableOperation;
+}
+export interface StorageVolumesApi {
+    names(poolName: string, options?: IncusScopeOptions): Promise<string[] | Record<string, string[]>>;
+    list(poolName: string, options?: IncusListOptions & {
+        full?: boolean;
+    }): Promise<IncusRecord[]>;
+    get(poolName: string, volumeType: string, name: string, options?: {
+        full?: boolean;
+    }): Promise<IncusEntity<IncusRecord>>;
+    state(poolName: string, volumeType: string, name: string): Promise<IncusRecord>;
+    create(poolName: string, volume: IncusRecord): Promise<void>;
+    update(poolName: string, volumeType: string, name: string, volume: IncusRecord, options?: IncusMutationOptions): Promise<void>;
+    remove(poolName: string, volumeType: string, name: string): Promise<void>;
+    rename(poolName: string, volumeType: string, name: string, request: IncusRecord): Promise<void>;
+    copyFrom(poolName: string, source: IncusClient, sourcePool: string, volume: IncusRecord, options?: IncusRecord): Promise<IncusRemoteOperation>;
+    moveFrom(poolName: string, source: IncusClient, sourcePool: string, volume: IncusRecord, options?: IncusRecord): Promise<IncusRemoteOperation>;
+    migrate(poolName: string, volume: IncusRecord): IncusAwaitableOperation;
+    createFromMigration(poolName: string, volume: IncusRecord): IncusAwaitableOperation;
+    snapshots: StorageVolumeSnapshotsApi;
+    backups: StorageVolumeBackupsApi;
+    files: StorageVolumeFilesApi;
+    sftp(poolName: string, volumeType: string, volumeName: string): Promise<unknown>;
+}
+export interface StorageApi {
+    pools: StoragePoolsApi;
+    buckets: StorageBucketsApi;
+    volumes: StorageVolumesApi;
+}
+export interface ClusterMembersApi {
+    names(): Promise<string[]>;
+    list(options?: IncusListOptions): Promise<IncusRecord[]>;
+    get(name: string): Promise<IncusEntity<IncusRecord>>;
+    state(name: string): Promise<IncusEntity<IncusRecord>>;
+    create(member: IncusRecord): IncusAwaitableOperation;
+    update(name: string, member: IncusRecord, options?: IncusMutationOptions): Promise<void>;
+    rename(name: string, request: IncusRecord): Promise<void>;
+    remove(name: string, options?: {
+        force?: boolean;
+        pending?: boolean;
+    }): Promise<void>;
+    updateState(name: string, state: IncusRecord): IncusAwaitableOperation;
+}
+export interface ClusterGroupsApi {
+    names(): Promise<string[]>;
+    list(): Promise<IncusRecord[]>;
+    get(name: string): Promise<IncusEntity<IncusRecord>>;
+    create(group: IncusRecord): Promise<void>;
+    update(name: string, group: IncusRecord, options?: IncusMutationOptions): Promise<void>;
+    rename(name: string, request: IncusRecord): Promise<void>;
+    remove(name: string): Promise<void>;
+}
+export interface ClusterApi {
+    get(): Promise<IncusEntity<IncusRecord>>;
+    update(cluster: IncusRecord, options?: IncusMutationOptions): IncusAwaitableOperation;
+    updateCertificate(certificate: IncusRecord, options?: IncusMutationOptions): Promise<void>;
+    members: ClusterMembersApi;
+    groups: ClusterGroupsApi;
+}
+export interface WarningsApi {
+    uuids(): Promise<string[]>;
+    list(): Promise<IncusRecord[]>;
+    get(uuid: string): Promise<IncusEntity<IncusRecord>>;
+    update(uuid: string, warning: IncusRecord, options?: IncusMutationOptions): Promise<void>;
+    remove(uuid: string): Promise<void>;
+}
+export interface OidcApi {
+    tokens(): Promise<IncusRecord | null>;
+}
+export interface RawApi {
+    query<T = IncusRecord>(method: string, path: string, body?: unknown, options?: IncusMutationOptions): Promise<IncusEntity<T>>;
+    websocket(path: string): Promise<WebSocket>;
+    operation(method: string, path: string, body?: unknown, options?: IncusMutationOptions): IncusAwaitableOperation;
+}
+type InternalRequestOptions = Omit<IncusTransportRequestOptions, "context"> & {
+    applyContext?: boolean;
+};
+type IncusEnvelopeResult<T = unknown> = {
+    value: T;
+    etag?: string;
+    operation?: string;
+    status: number;
+    headers?: Headers;
+};
+export declare class IncusApiError extends Error {
+    readonly status: number;
+    readonly statusCode?: number;
+    readonly errorCode?: number;
+    readonly details?: unknown;
+    constructor(message: string, status: number, options?: {
+        statusCode?: number;
+        errorCode?: number;
+        details?: unknown;
+    });
+}
+export declare class IncusImageClient {
+    protected readonly transport: IncusTransport;
+    readonly endpoint: string;
+    readonly options: Readonly<IncusConnectionOptions>;
+    readonly connection: ConnectionApi;
+    readonly images: ImagesApi;
+    readonly raw: RawApi;
+    protected readonly contextState: Readonly<IncusRequestContext>;
+    protected readonly kind: IncusConnectKind;
+    private serverSnapshot?;
+    constructor(transport: IncusTransport, endpoint: string, options?: Readonly<IncusConnectionOptions>, context?: Readonly<IncusRequestContext>, kind?: IncusConnectKind);
+    get context(): Readonly<IncusRequestContext>;
+    disconnect(): void;
+    protected requestTransport(method: string, path: string, options?: InternalRequestOptions): Promise<IncusTransportResponse<unknown>>;
+    protected requestEnvelope<T = unknown>(method: string, path: string, options?: InternalRequestOptions): Promise<IncusEnvelopeResult<T>>;
+    protected requestBinary(method: string, path: string, options?: InternalRequestOptions): Promise<IncusEnvelopeResult<Uint8Array>>;
+    protected createOperationFromRequest(method: string, path: string, options?: InternalRequestOptions): IncusAwaitableOperation;
+    protected createOperationFromEnvelopeResult(method: string, path: string, result: IncusEnvelopeResult<unknown>): IncusOperation;
+    protected createOperation(id: string): IncusOperation;
+    protected openWebsocket(path: string, options?: {
+        applyContext?: boolean;
+    }): Promise<WebSocket>;
+    private getServerSnapshot;
+    private createConnectionApi;
+    private createRawApi;
+    private createImageAliasesApi;
+    private createImagesApi;
+}
+export declare class IncusClient extends IncusImageClient {
+    readonly server: ServerApi;
+    readonly certificates: CertificatesApi;
+    readonly instances: InstancesApi;
+    readonly events: EventsApi;
+    readonly metadata: MetadataApi;
+    readonly networks: NetworksApi;
+    readonly operations: OperationsApi;
+    readonly profiles: ProfilesApi;
+    readonly projects: ProjectsApi;
+    readonly storage: StorageApi;
+    readonly cluster: ClusterApi;
+    readonly warnings: WarningsApi;
+    readonly oidc: OidcApi;
+    constructor(transport: IncusTransport, endpoint: string, options?: Readonly<IncusConnectionOptions>, context?: Readonly<IncusRequestContext>, kind?: IncusConnectKind);
+    withContext(contextPatch: Partial<IncusRequestContext>): IncusClient;
+    project(name: string): IncusClient;
+    target(name: string): IncusClient;
+    requireAuthenticated(authenticated?: boolean): IncusClient;
+    private createServerApi;
+    private createOperationsApi;
+    private isPipeTarget;
+    private toWritableTarget;
+    private shouldAttachExecIO;
+    private shouldPipeExecIO;
+    private getExecFds;
+    private attachExecWebsockets;
+    private createInstancesApi;
+}
+export declare class Incus {
+    static connect(endpoint: string, options?: IncusConnectionOptions): Promise<IncusClient>;
+    static connectHttp(options?: IncusHttpConnectOptions): Promise<IncusClient>;
+    static connectUnix(options?: IncusUnixConnectOptions): Promise<IncusClient>;
+    static connectPublic(endpoint: string, options?: IncusConnectionOptions): Promise<IncusImageClient>;
+    static connectSimpleStreams(endpoint: string, options?: IncusSimpleStreamsOptions): Promise<IncusImageClient>;
+    static fromTransport(endpoint: string, transport: IncusTransport, options?: IncusConnectionOptions): IncusClient;
+    static fromImageTransport(endpoint: string, transport: IncusTransport, options?: IncusConnectionOptions): IncusImageClient;
+}
+export {};
+//# sourceMappingURL=incus.d.ts.map