@archildata/client 0.8.1 → 0.8.3

package/dist/api/index.d.ts

@@ -0,0 +1,976 @@
+import { Client } from 'openapi-fetch';
+
+/**
+ * This file was auto-generated by openapi-typescript.
+ * Do not make direct changes to the file.
+ */
+
+interface paths {
+    "/api/disks": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List all disks
+         * @description Returns all disks owned by the authenticated account.
+         */
+        get: operations["listDisks"];
+        put?: never;
+        /**
+         * Create a new disk
+         * @description Creates a new disk with the specified configuration. The disk will be
+         *     provisioned in the specified region with the given mounts and authentication methods.
+         */
+        post: operations["createDisk"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/disks/{id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get disk details
+         * @description Returns detailed information about a specific disk.
+         */
+        get: operations["getDisk"];
+        put?: never;
+        post?: never;
+        /**
+         * Delete a disk
+         * @description Deletes a disk and all associated resources.
+         */
+        delete: operations["deleteDisk"];
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/disks/{id}/users": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Add user to disk
+         * @description Adds an authorized user to a disk. Users can authenticate via:
+         *     - **token**: A shared token with a nickname and 4-character suffix
+         *     - **awssts**: AWS STS role assumption with an IAM principal ARN
+         */
+        post: operations["addDiskUser"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/disks/{id}/users/{userType}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post?: never;
+        /**
+         * Remove user from disk
+         * @description Removes an authorized user from a disk.
+         */
+        delete: operations["removeDiskUser"];
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/tokens": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List API tokens
+         * @description Returns all API tokens for the authenticated account.
+         */
+        get: operations["listApiTokens"];
+        put?: never;
+        /**
+         * Create API token
+         * @description Creates a new API token for programmatic access. The full token value
+         *     is only returned once at creation time.
+         */
+        post: operations["createApiToken"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/tokens/{id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post?: never;
+        /**
+         * Delete API token
+         * @description Revokes and deletes an API token.
+         */
+        delete: operations["deleteApiToken"];
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+}
+interface components {
+    schemas: {
+        ErrorResponse: {
+            /** @example false */
+            success: boolean;
+            /** @example Invalid request parameters */
+            error: string;
+        };
+        ApiResponse_Empty: {
+            /** @example true */
+            success: boolean;
+        };
+        ApiResponse_Message: {
+            /** @example true */
+            success: boolean;
+            data: {
+                message?: string;
+            };
+        };
+        CreateDiskRequest: {
+            /**
+             * @description Disk name (alphanumeric, dashes, underscores)
+             * @example my-data-disk
+             */
+            name: string;
+            /** @description Storage mount to attach (exactly one required) */
+            mounts: components["schemas"]["MountConfig"][];
+            /** @description Authentication methods for disk access */
+            authMethods?: components["schemas"]["DiskUser"][];
+        };
+        MountConfig: components["schemas"]["S3Mount"] | components["schemas"]["GCSMount"] | components["schemas"]["R2Mount"] | components["schemas"]["S3CompatibleMount"] | components["schemas"]["AzureBlobMount"];
+        /**
+         * S3
+         * @description Mount configuration for Amazon S3 buckets
+         */
+        S3Mount: {
+            /**
+             * @description Mount type identifier (enum property replaced by openapi-typescript)
+             * @enum {string}
+             */
+            type: "s3";
+            /**
+             * @description S3 bucket name
+             * @example my-bucket
+             */
+            bucketName: string;
+            /** @description AWS access key ID (optional for public buckets or IAM role auth) */
+            accessKeyId?: string;
+            /**
+             * Format: password
+             * @description AWS secret access key
+             */
+            secretAccessKey?: string;
+            /** @description Session token for temporary credentials */
+            sessionToken?: string;
+            /**
+             * @description Prefix within the bucket
+             * @example data/
+             */
+            bucketPrefix?: string;
+        };
+        /**
+         * Google Cloud Storage
+         * @description Mount configuration for Google Cloud Storage buckets
+         */
+        GCSMount: {
+            /**
+             * @description Mount type identifier (enum property replaced by openapi-typescript)
+             * @enum {string}
+             */
+            type: "gcs";
+            /**
+             * @description GCS bucket name
+             * @example my-gcs-bucket
+             */
+            bucketName: string;
+            /** @description HMAC access key ID */
+            accessKeyId: string;
+            /**
+             * Format: password
+             * @description HMAC secret access key
+             */
+            secretAccessKey: string;
+            /**
+             * @description Prefix within the bucket (optional)
+             * @example data/
+             */
+            bucketPrefix?: string;
+        };
+        /**
+         * Cloudflare R2
+         * @description Mount configuration for Cloudflare R2 buckets
+         */
+        R2Mount: {
+            /**
+             * @description Mount type identifier (enum property replaced by openapi-typescript)
+             * @enum {string}
+             */
+            type: "r2";
+            /**
+             * @description R2 bucket name
+             * @example my-r2-bucket
+             */
+            bucketName: string;
+            /**
+             * @description R2 endpoint URL
+             * @example https://accountid.r2.cloudflarestorage.com
+             */
+            bucketEndpoint: string;
+            /** @description R2 access key ID */
+            accessKeyId: string;
+            /**
+             * Format: password
+             * @description R2 secret access key
+             */
+            secretAccessKey: string;
+            /**
+             * @description Prefix within the bucket (optional)
+             * @example data/
+             */
+            bucketPrefix?: string;
+        };
+        /**
+         * S3-Compatible
+         * @description Mount configuration for S3-compatible storage (MinIO, Backblaze B2, etc.)
+         */
+        S3CompatibleMount: {
+            /**
+             * @description Mount type identifier (enum property replaced by openapi-typescript)
+             * @enum {string}
+             */
+            type: "s3-compatible";
+            /**
+             * @description Bucket name
+             * @example my-bucket
+             */
+            bucketName: string;
+            /**
+             * @description S3-compatible endpoint URL
+             * @example https://s3.us-west-001.backblazeb2.com
+             */
+            bucketEndpoint: string;
+            /** @description Access key ID */
+            accessKeyId: string;
+            /**
+             * Format: password
+             * @description Secret access key
+             */
+            secretAccessKey: string;
+            /**
+             * @description Prefix within the bucket (optional)
+             * @example data/
+             */
+            bucketPrefix?: string;
+        };
+        /**
+         * Azure Blob Storage
+         * @description Mount configuration for Azure Blob Storage containers
+         */
+        AzureBlobMount: {
+            /**
+             * @description Mount type identifier (enum property replaced by openapi-typescript)
+             * @enum {string}
+             */
+            type: "azure-blob";
+            /**
+             * @description Azure blob container name
+             * @example my-container
+             */
+            containerName: string;
+            /**
+             * @description Azure blob endpoint URL (optional if storageAccountName provided)
+             * @example https://myaccount.blob.core.windows.net
+             */
+            endpoint?: string;
+            /**
+             * @description Azure storage account name (used to derive endpoint if not provided)
+             * @example myaccount
+             */
+            storageAccountName?: string;
+            /** @description Azure AD tenant ID */
+            tenantId: string;
+            /** @description Azure AD application client ID */
+            clientId: string;
+            /**
+             * Format: password
+             * @description Azure AD application client secret
+             */
+            clientSecret: string;
+            /**
+             * @description Prefix within the container
+             * @example data/
+             */
+            bucketPrefix?: string;
+        };
+        TokenUser: {
+            /**
+             * @description discriminator enum property added by openapi-typescript
+             * @enum {string}
+             */
+            type: "token";
+            principal: string;
+            nickname: string;
+            tokenSuffix: string;
+        };
+        AwsStsUser: {
+            /**
+             * @description discriminator enum property added by openapi-typescript
+             * @enum {string}
+             */
+            type: "awssts";
+            /** @description IAM principal ARN */
+            principal: string;
+        };
+        DiskUser: components["schemas"]["TokenUser"] | components["schemas"]["AwsStsUser"];
+        DiskResponse: {
+            /**
+             * @description Disk ID
+             * @example dsk-0123456789abcdef
+             */
+            id: string;
+            /** @description Disk name */
+            name: string;
+            /** @description Owning organization ID */
+            organization: string;
+            /**
+             * @description Disk status
+             * @enum {string}
+             */
+            status: "available" | "creating" | "deleting" | "deleted" | "failed";
+            /** @description Filesystem handler status */
+            fsHandlerStatus?: string;
+            /** @description Cloud provider */
+            provider: string;
+            /** @description Disk region (e.g., aws-us-east-1, gcp-us-central1) */
+            region: string;
+            /**
+             * Format: date-time
+             * @description Creation timestamp
+             */
+            createdAt: string;
+            /**
+             * Format: date-time
+             * @description Last access timestamp
+             */
+            lastAccessed?: string;
+            /**
+             * Format: int64
+             * @description Total data size in bytes
+             */
+            dataSize?: number;
+            /** @description Monthly usage amount formatted as a currency string (e.g., "$1.23") */
+            monthlyUsage?: string;
+            mounts?: components["schemas"]["MountResponse"][];
+            metrics?: components["schemas"]["DiskMetrics"];
+            connectedClients?: components["schemas"]["ConnectedClient"][];
+            authorizedUsers?: components["schemas"]["AuthorizedUser"][];
+        };
+        MountResponse: {
+            /** @description Mount identifier */
+            id?: string;
+            /**
+             * @description Storage backend type
+             * @enum {string}
+             */
+            type?: "s3" | "gcs" | "r2" | "s3-compatible" | "azure-blob";
+            /** @description Mount path */
+            path?: string;
+            /** @description Bucket/container name */
+            name?: string;
+            /**
+             * @description Access mode
+             * @example rw
+             * @enum {string}
+             */
+            accessMode?: "rw" | "ro";
+            config?: components["schemas"]["MountConfigResponse"];
+            /**
+             * @description Current connection status
+             * @enum {string}
+             */
+            connectionStatus?: "connected" | "disconnected";
+            /** @description Authentication error message (if disconnected) */
+            authError?: string;
+            /**
+             * @description How the mount authenticates to the storage backend
+             * @enum {string}
+             */
+            authorizationType?: "iam" | "accessKeys" | "oauth";
+        };
+        /** @description Mount configuration details (secrets omitted) */
+        MountConfigResponse: {
+            /** @description Bucket name */
+            bucketName?: string;
+            /** @description Storage endpoint URL */
+            bucketEndpoint?: string;
+            /** @description Prefix within the bucket */
+            bucketPrefix?: string;
+        };
+        DiskMetrics: {
+            /** @description Data transfer amount with unit (e.g., "1.5 GB") */
+            dataTransfer?: string;
+            /** @description Total request count as a formatted string (e.g., "1,234") */
+            requests?: string;
+            /** @description Average response time with unit (e.g., "45ms") */
+            avgResponseTime?: string;
+        };
+        ConnectedClient: {
+            id?: string;
+            ipAddress?: string;
+            /** Format: date-time */
+            connectedAt?: string;
+        };
+        AuthorizedUser: {
+            /** @enum {string} */
+            type?: "token" | "awssts";
+            principal?: string;
+            nickname?: string;
+            tokenSuffix?: string;
+            /** Format: date-time */
+            createdAt?: string;
+        };
+        /** @description All API responses use a standard envelope with `success: boolean` and `data` (on success) or `error: string` (on failure). The ApiResponse_* schemas each define the specific `data` shape for their endpoint. */
+        ApiResponse_DiskList: {
+            /** @example true */
+            success: boolean;
+            data: components["schemas"]["DiskResponse"][];
+        };
+        ApiResponse_Disk: {
+            /** @example true */
+            success: boolean;
+            data: components["schemas"]["DiskResponse"];
+        };
+        ApiResponse_CreateDisk: {
+            /** @example true */
+            success: boolean;
+            data: {
+                /** @example dsk-0123456789abcdef */
+                diskId?: string;
+            };
+        };
+        ApiResponse_AuthorizedUser: {
+            /** @example true */
+            success: boolean;
+            data: components["schemas"]["AuthorizedUser"];
+        };
+        CreateApiTokenRequest: {
+            /** @description Token name */
+            name: string;
+            /** @description Token description */
+            description?: string;
+        };
+        ApiTokenResponse: {
+            /** @description Token hash/ID */
+            id?: string;
+            name?: string;
+            description?: string;
+            /** @description Last 4 characters of the token */
+            tokenSuffix?: string;
+            /** Format: date-time */
+            createdAt?: string;
+            /** Format: date-time */
+            lastUsedAt?: string;
+        };
+        ApiResponse_TokenList: {
+            /** @example true */
+            success: boolean;
+            data: {
+                tokens?: components["schemas"]["ApiTokenResponse"][];
+            };
+        };
+        ApiResponse_TokenCreated: {
+            /** @example true */
+            success: boolean;
+            data: components["schemas"]["ApiTokenResponse"] & {
+                /**
+                 * @description Full token value (only shown at creation)
+                 * @example key-abc123...
+                 */
+                token?: string;
+            };
+        };
+    };
+    responses: {
+        /** @description Invalid or missing authentication credentials */
+        Unauthorized: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": components["schemas"]["ErrorResponse"];
+            };
+        };
+        /** @description Validation error */
+        ValidationError: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": components["schemas"]["ErrorResponse"];
+            };
+        };
+        /** @description Resource not found */
+        NotFound: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": components["schemas"]["ErrorResponse"];
+            };
+        };
+        /** @description Internal server error */
+        InternalError: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": components["schemas"]["ErrorResponse"];
+            };
+        };
+    };
+    parameters: {
+        /** @description Disk ID (format `dsk-{16 hex chars}`) */
+        DiskId: string;
+        /** @description Maximum number of items to return */
+        Limit: number;
+        /** @description Pagination cursor from a previous response */
+        Cursor: string;
+    };
+    requestBodies: never;
+    headers: never;
+    pathItems: never;
+}
+interface operations {
+    listDisks: {
+        parameters: {
+            query?: {
+                /** @description Maximum number of items to return */
+                limit?: components["parameters"]["Limit"];
+                /** @description Pagination cursor from a previous response */
+                cursor?: components["parameters"]["Cursor"];
+                /** @description Filter disks by exact name match. */
+                name?: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description List of disks */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ApiResponse_DiskList"];
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            500: components["responses"]["InternalError"];
+        };
+    };
+    createDisk: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["CreateDiskRequest"];
+            };
+        };
+        responses: {
+            /** @description Disk with this name already exists and configuration matches (idempotent) */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ApiResponse_CreateDisk"];
+                };
+            };
+            /** @description Disk created successfully */
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ApiResponse_CreateDisk"];
+                };
+            };
+            400: components["responses"]["ValidationError"];
+            401: components["responses"]["Unauthorized"];
+            /** @description Access denied (e.g., preview region not enabled) */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Disk with this name already exists but configuration differs */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            500: components["responses"]["InternalError"];
+        };
+    };
+    getDisk: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Disk ID (format `dsk-{16 hex chars}`) */
+                id: components["parameters"]["DiskId"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Disk details */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ApiResponse_Disk"];
+                };
+            };
+            400: components["responses"]["ValidationError"];
+            401: components["responses"]["Unauthorized"];
+            404: components["responses"]["NotFound"];
+            500: components["responses"]["InternalError"];
+        };
+    };
+    deleteDisk: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Disk ID (format `dsk-{16 hex chars}`) */
+                id: components["parameters"]["DiskId"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Disk deleted successfully */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ApiResponse_Empty"];
+                };
+            };
+            400: components["responses"]["ValidationError"];
+            401: components["responses"]["Unauthorized"];
+            404: components["responses"]["NotFound"];
+            500: components["responses"]["InternalError"];
+        };
+    };
+    addDiskUser: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Disk ID (format `dsk-{16 hex chars}`) */
+                id: components["parameters"]["DiskId"];
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["DiskUser"];
+            };
+        };
+        responses: {
+            /** @description User added successfully */
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ApiResponse_AuthorizedUser"];
+                };
+            };
+            400: components["responses"]["ValidationError"];
+            401: components["responses"]["Unauthorized"];
+            500: components["responses"]["InternalError"];
+        };
+    };
+    removeDiskUser: {
+        parameters: {
+            query: {
+                /** @description The user's principal identifier. For token type, this is the MD5 hash (hex-encoded) of the token principal. For awssts type, this is the full IAM ARN (e.g., arn:aws:iam::123456789012:role/MyRole). */
+                principal: string;
+            };
+            header?: never;
+            path: {
+                /** @description Disk ID (format `dsk-{16 hex chars}`) */
+                id: components["parameters"]["DiskId"];
+                /** @description The type of user authentication */
+                userType: "token" | "awssts";
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description User removed successfully */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ApiResponse_Message"];
+                };
+            };
+            400: components["responses"]["ValidationError"];
+            401: components["responses"]["Unauthorized"];
+            500: components["responses"]["InternalError"];
+        };
+    };
+    listApiTokens: {
+        parameters: {
+            query?: {
+                /** @description Maximum number of items to return */
+                limit?: components["parameters"]["Limit"];
+                /** @description Pagination cursor from a previous response */
+                cursor?: components["parameters"]["Cursor"];
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description List of API tokens */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ApiResponse_TokenList"];
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            500: components["responses"]["InternalError"];
+        };
+    };
+    createApiToken: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["CreateApiTokenRequest"];
+            };
+        };
+        responses: {
+            /** @description Token created successfully */
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ApiResponse_TokenCreated"];
+                };
+            };
+            400: components["responses"]["ValidationError"];
+            401: components["responses"]["Unauthorized"];
+            500: components["responses"]["InternalError"];
+        };
+    };
+    deleteApiToken: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description The token ID (hash) */
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Token deleted successfully */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ApiResponse_Message"];
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            404: components["responses"]["NotFound"];
+            500: components["responses"]["InternalError"];
+        };
+    };
+}
+
+type ApiClient = Client<paths>;
+
+type DiskResponse = components["schemas"]["DiskResponse"];
+type MountResponse = components["schemas"]["MountResponse"];
+type MountConfigResponse = components["schemas"]["MountConfigResponse"];
+type DiskMetrics = components["schemas"]["DiskMetrics"];
+type ConnectedClient = components["schemas"]["ConnectedClient"];
+type AuthorizedUser = components["schemas"]["AuthorizedUser"];
+type CreateDiskRequest = components["schemas"]["CreateDiskRequest"];
+type MountConfig = components["schemas"]["MountConfig"];
+type S3Mount = components["schemas"]["S3Mount"];
+type GCSMount = components["schemas"]["GCSMount"];
+type R2Mount = components["schemas"]["R2Mount"];
+type S3CompatibleMount = components["schemas"]["S3CompatibleMount"];
+type AzureBlobMount = components["schemas"]["AzureBlobMount"];
+type DiskUser = components["schemas"]["DiskUser"];
+type TokenUser = components["schemas"]["TokenUser"];
+type AwsStsUser = components["schemas"]["AwsStsUser"];
+type CreateApiTokenRequest = components["schemas"]["CreateApiTokenRequest"];
+type ApiTokenResponse = components["schemas"]["ApiTokenResponse"];
+type DiskStatus = DiskResponse["status"];
+
+interface MountOptions {
+    authToken?: string;
+    logLevel?: string;
+    serverAddress?: string;
+    insecure?: boolean;
+}
+declare class Disk {
+    readonly id: string;
+    readonly name: string;
+    readonly organization: string;
+    readonly status: DiskStatus;
+    readonly provider: string;
+    readonly region: string;
+    readonly createdAt: string;
+    readonly fsHandlerStatus?: string;
+    readonly lastAccessed?: string;
+    readonly dataSize?: number;
+    readonly monthlyUsage?: string;
+    readonly mounts?: MountResponse[];
+    readonly metrics?: DiskMetrics;
+    readonly connectedClients?: ConnectedClient[];
+    readonly authorizedUsers?: AuthorizedUser[];
+    /** @internal */
+    private readonly _client;
+    /** @internal */
+    private readonly _archilRegion;
+    /** @internal */
+    constructor(data: DiskResponse, client: ApiClient, archilRegion: string);
+    addUser(user: DiskUser): Promise<AuthorizedUser>;
+    removeUser(userType: "token" | "awssts", principal: string): Promise<void>;
+    delete(): Promise<void>;
+    /**
+     * Connect to this disk's data plane via the native ArchilClient.
+     *
+     * Requires the native module to be available (platform-specific .node binary).
+     */
+    mount(opts?: MountOptions): Promise<unknown>;
+}
+
+interface ListDisksOptions {
+    limit?: number;
+    cursor?: string;
+}
+declare class Disks {
+    /** @internal */
+    private readonly _client;
+    /** @internal */
+    private readonly _region;
+    /** @internal */
+    constructor(client: ApiClient, region: string);
+    list(opts?: ListDisksOptions): Promise<Disk[]>;
+    get(id: string): Promise<Disk>;
+    /**
+     * Create a new disk and return a Disk object with full details.
+     *
+     * Internally calls POST /api/disks (returns diskId) then GET /api/disks/{id}.
+     */
+    create(req: CreateDiskRequest): Promise<Disk>;
+}
+
+interface ListTokensOptions {
+    limit?: number;
+    cursor?: string;
+}
+declare class Tokens {
+    /** @internal */
+    private readonly _client;
+    /** @internal */
+    constructor(client: ApiClient);
+    list(opts?: ListTokensOptions): Promise<ApiTokenResponse[]>;
+    create(req: CreateApiTokenRequest): Promise<ApiTokenResponse & {
+        token?: string;
+    }>;
+    delete(id: string): Promise<void>;
+}
+
+interface ArchilOptions {
+    apiKey: string;
+    region: string;
+    /** Override the control plane base URL (useful for testing). */
+    baseUrl?: string;
+}
+declare class Archil {
+    readonly disks: Disks;
+    readonly tokens: Tokens;
+    constructor(opts: ArchilOptions);
+}
+
+declare class ArchilApiError extends Error {
+    readonly status: number;
+    readonly code?: string;
+    constructor(message: string, status: number, code?: string);
+}
+
+export { type ApiTokenResponse, Archil, ArchilApiError, type ArchilOptions, type AuthorizedUser, type AwsStsUser, type AzureBlobMount, type ConnectedClient, type CreateApiTokenRequest, type CreateDiskRequest, Disk, type DiskMetrics, type DiskResponse, type DiskStatus, type DiskUser, Disks, type GCSMount, type ListDisksOptions, type ListTokensOptions, type MountConfig, type MountConfigResponse, type MountOptions, type MountResponse, type R2Mount, type S3CompatibleMount, type S3Mount, type TokenUser, Tokens };