disk 0.8.0 → 0.8.9

package/dist/index.d.ts

@@ -0,0 +1,1145 @@
+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. A default token
+         *     user is automatically generated and returned in the response, so the
+         *     disk is immediately mountable. The one-time token appears in
+         *     `authorizedUsers[].token` and cannot be retrieved again.
+         *
+         *     To provide your own users instead, pass the deprecated `authMethods`
+         *     field or call AddDiskUser after creation.
+         */
+        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/disks/{id}/exec": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Execute a command on a disk
+         * @description Launches a container with the specified disk mounted, runs the given
+         *     command to completion, and shuts down the container. Returns immediately
+         *     with the container info; poll the container endpoint for completion.
+         */
+        post: operations["execDisk"];
+        delete?: never;
+        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. Omit for archil-managed storage. */
+            mounts?: components["schemas"]["MountConfig"][];
+            /**
+             * @deprecated
+             * @description Deprecated. Use AddDiskUser after creation instead. When provided, suppresses the default auto-generated token user.
+             */
+            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";
+            /**
+             * @deprecated
+             * @description Deprecated. Client-provided token. If omitted, the server generates a cryptographically secure token and returns it in the response.
+             */
+            principal?: string;
+            nickname: string;
+            /**
+             * @deprecated
+             * @description Deprecated. Last 4 characters of the token. Required when principal is provided; ignored when the server generates the token.
+             */
+            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;
+            /** @description Session identifier for IAM-authorized mounts */
+            sessionId?: 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";
+            /**
+             * @deprecated
+             * @description Use identifier instead. Only populated for awssts type (the IAM ARN).
+             */
+            principal?: string;
+            nickname?: string;
+            tokenSuffix?: string;
+            /** @description The generated mount token. Only present in the response when the server generates the token (i.e. principal was not provided). This value is shown exactly once and cannot be retrieved again. */
+            token?: string;
+            /** @description Stable identifier for this user, returned in creation and list responses. Use this value with DELETE /api/disks/{id}/users/{type}?identifier={identifier} to remove the user. For awssts users, this is the IAM ARN. */
+            identifier?: 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;
+                authorizedUsers?: components["schemas"]["AuthorizedUser"][];
+            };
+        };
+        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;
+            };
+        };
+        ExecDiskRequest: {
+            /**
+             * @description Shell command to execute inside the container
+             * @example ls -la /mnt/archil
+             */
+            command: string;
+        };
+        ExecDiskResult: {
+            /**
+             * @description Exit code of the command (0 = success)
+             * @example 0
+             */
+            exitCode: number;
+            /** @description Standard output from the command */
+            stdout: string;
+            /** @description Standard error from the command */
+            stderr: string;
+            timing: components["schemas"]["ExecTiming"];
+        };
+        /** @description Server-measured timings for an exec request. */
+        ExecTiming: {
+            /**
+             * @description End-to-end wall clock measured on the server, from request arrival to response.
+             * @example 2450
+             */
+            totalMs: number;
+            /**
+             * @description Time spent queueing, scheduling, booting/claiming a VM, and mounting the filesystem before the command started running.
+             * @example 150
+             */
+            queueMs: number;
+            /**
+             * @description Time the user's command itself ran, measured by the runtime.
+             * @example 2300
+             */
+            executeMs: number;
+        };
+        ApiResponse_ExecDisk: {
+            /** @example true */
+            success: boolean;
+            data: components["schemas"]["ExecDiskResult"];
+        };
+    };
+    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 Identifier of the user to remove, as returned in the creation or list response. For awssts users, this is the IAM ARN. */
+                identifier?: string;
+                /**
+                 * @deprecated
+                 * @description Use identifier instead.
+                 */
+                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"];
+        };
+    };
+    execDisk: {
+        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"]["ExecDiskRequest"];
+            };
+        };
+        responses: {
+            /** @description Command completed */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ApiResponse_ExecDisk"];
+                };
+            };
+            400: components["responses"]["ValidationError"];
+            401: components["responses"]["Unauthorized"];
+            404: components["responses"]["NotFound"];
+            500: components["responses"]["InternalError"];
+            /** @description Command timed out */
+            504: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    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 ExecDiskResult = components["schemas"]["ExecDiskResult"];
+type DiskStatus = DiskResponse["status"];
+
+interface MountOptions {
+    authToken?: string;
+    logLevel?: string;
+    serverAddress?: string;
+    insecure?: boolean;
+}
+type ExecResult = ExecDiskResult;
+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);
+    toJSON(): DiskResponse;
+    addUser(user: DiskUser): Promise<AuthorizedUser>;
+    removeUser(userType: "token" | "awssts", identifier: string): Promise<void>;
+    createToken(nickname: string): Promise<AuthorizedUser & {
+        token: string;
+        identifier: string;
+    }>;
+    removeTokenUser(identifier: string): Promise<void>;
+    delete(): Promise<void>;
+    /**
+     * Execute a command in a container with this disk mounted.
+     * Blocks until the command completes and returns stdout, stderr, and exit code.
+     */
+    exec(command: string): Promise<ExecResult>;
+    /**
+     * 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;
+    name?: string;
+}
+interface CreateDiskResult {
+    disk: Disk;
+    token: string | null;
+    tokenIdentifier: string | null;
+    authorizedUsers: AuthorizedUser[];
+}
+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 with an auto-generated mount token.
+     *
+     * Returns the Disk, the one-time token (save it — it cannot be retrieved
+     * again), and the token identifier for later management.
+     */
+    create(req: CreateDiskRequest): Promise<CreateDiskResult>;
+}
+
+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 {
+    /** API key. Falls back to ARCHIL_API_KEY env var if not provided. */
+    apiKey?: string;
+    /** Region. Falls back to ARCHIL_REGION env var if not provided. */
+    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);
+}
+
+declare function configure(options: ArchilOptions): void;
+declare function createDisk(req: CreateDiskRequest): Promise<CreateDiskResult>;
+declare function listDisks(opts?: ListDisksOptions): Promise<Disk[]>;
+declare function getDisk(id: string): Promise<Disk>;
+declare function listApiKeys(opts?: ListTokensOptions): Promise<ApiTokenResponse[]>;
+declare function createApiKey(req: CreateApiTokenRequest): Promise<ApiTokenResponse & {
+    token?: string;
+}>;
+declare function deleteApiKey(id: string): Promise<void>;
+
+export { type ApiTokenResponse, Archil, ArchilApiError, type ArchilOptions, type AuthorizedUser, type AwsStsUser, type AzureBlobMount, type ConnectedClient, type CreateApiTokenRequest, type CreateDiskRequest, type CreateDiskResult, Disk, type DiskMetrics, type DiskResponse, type DiskStatus, type DiskUser, Disks, type ExecResult, type GCSMount, type ListDisksOptions, type ListTokensOptions, type MountConfig, type MountConfigResponse, type MountOptions, type MountResponse, type R2Mount, type S3CompatibleMount, type S3Mount, type TokenUser, Tokens, configure, createApiKey, createDisk, deleteApiKey, getDisk, listApiKeys, listDisks };