@distilled.cloud/archil 0.0.0 → 1.0.0-rc.11

package/lib/services/archil.d.ts

@@ -0,0 +1,783 @@
+import * as S from "@distilled.cloud/core/schema";
+import * as Redacted from "effect/Redacted";
+import * as API from "@distilled.cloud/core/api";
+import { type ArchilOpError, type ArchilOpContext } from "../protocol.ts";
+export type { ArchilOpError, ArchilOpContext };
+declare const BadRequest_base: S.Class<BadRequest, S.TaggedStruct<"BadRequest", {
+    readonly code: any;
+    readonly message: any;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        BadRequestError: true;
+    };
+});
+export declare class BadRequest extends /*@__PURE__*/ BadRequest_base {
+}
+declare const Conflict_base: S.Class<Conflict, S.TaggedStruct<"Conflict", {
+    readonly code: any;
+    readonly message: any;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        ConflictError: true;
+    };
+});
+export declare class Conflict extends /*@__PURE__*/ Conflict_base {
+}
+declare const Forbidden_base: S.Class<Forbidden, S.TaggedStruct<"Forbidden", {
+    readonly code: any;
+    readonly message: any;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        AuthError: true;
+    };
+});
+export declare class Forbidden extends /*@__PURE__*/ Forbidden_base {
+}
+declare const NotFound_base: S.Class<NotFound, S.TaggedStruct<"NotFound", {
+    readonly code: any;
+    readonly message: any;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        BadRequestError: true;
+    };
+});
+export declare class NotFound extends /*@__PURE__*/ NotFound_base {
+}
+export type TokenUserType = "token";
+export declare const TokenUserType: any;
+export interface TokenUser {
+    type: TokenUserType;
+    /** Deprecated. Client-provided token. If omitted, the server generates a cryptographically secure token and returns it in the response. */
+    principal?: string;
+    nickname: string;
+    /** Deprecated. Last 4 characters of the token. Required when principal is provided; ignored when the server generates the token. */
+    tokenSuffix?: string;
+}
+export declare const TokenUser: S.Schema<TokenUser>;
+export type AwsStsUserType = "awssts";
+export declare const AwsStsUserType: any;
+export interface AwsStsUser {
+    type: AwsStsUserType;
+    /** IAM principal ARN */
+    principal: string;
+}
+export declare const AwsStsUser: S.Schema<AwsStsUser>;
+export type DiskUser = TokenUser | AwsStsUser;
+export declare const DiskUser: S.Schema<DiskUser>;
+export interface AddDiskUserRequest {
+    /** Disk ID (format `dsk-{16 hex chars}`) */
+    id: string;
+    body: DiskUser;
+}
+export declare const AddDiskUserRequest: S.Schema<AddDiskUserRequest>;
+export type AuthorizedUserType = "token" | "awssts";
+export declare const AuthorizedUserType: any;
+export interface AuthorizedUser {
+    type?: AuthorizedUserType;
+    /** Use identifier instead. Only populated for awssts type (the IAM ARN). */
+    principal?: string;
+    nickname?: string;
+    tokenSuffix?: string;
+    /** The generated disk token (used by clients when mounting the disk). 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;
+    /** 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;
+    createdAt?: string;
+}
+export declare const AuthorizedUser: S.Schema<AuthorizedUser>;
+export interface ApiResponseAuthorizedUser {
+    success: boolean;
+    data: AuthorizedUser;
+}
+export declare const ApiResponseAuthorizedUser: S.Schema<ApiResponseAuthorizedUser>;
+export interface CreateApiTokenRequest {
+    /** Token name */
+    name: string;
+    /** Token description */
+    description?: string;
+}
+export declare const CreateApiTokenRequest: S.Schema<CreateApiTokenRequest>;
+export interface ApiResponseTokenCreatedData {
+    /** Token hash/ID */
+    id?: string;
+    name?: string;
+    description?: string;
+    /** Last 4 characters of the token */
+    tokenSuffix?: string;
+    createdAt?: string;
+    lastUsedAt?: string;
+    /** Full token value (only shown at creation) */
+    token?: string;
+}
+export declare const ApiResponseTokenCreatedData: S.Schema<ApiResponseTokenCreatedData>;
+export interface ApiResponseTokenCreated {
+    success: boolean;
+    data: ApiResponseTokenCreatedData;
+}
+export declare const ApiResponseTokenCreated: S.Schema<ApiResponseTokenCreated>;
+/** Mount type identifier */
+export type S3MountType = "s3";
+export declare const S3MountType: any;
+/** Mount configuration for Amazon S3 buckets */
+export interface S3Mount {
+    /** Mount type identifier */
+    type: S3MountType;
+    /** S3 bucket name */
+    bucketName: string;
+    /** AWS access key ID (optional for public buckets or IAM role auth) */
+    accessKeyId?: string | Redacted.Redacted<string>;
+    /** AWS secret access key */
+    secretAccessKey?: string | Redacted.Redacted<string>;
+    /** Session token for temporary credentials */
+    sessionToken?: string | Redacted.Redacted<string>;
+    /** Prefix within the bucket */
+    bucketPrefix?: string;
+}
+export declare const S3Mount: S.Schema<S3Mount>;
+/** Mount type identifier */
+export type GCSMountType = "gcs";
+export declare const GCSMountType: any;
+/** Mount configuration for Google Cloud Storage buckets */
+export interface GCSMount {
+    /** Mount type identifier */
+    type: GCSMountType;
+    /** GCS bucket name */
+    bucketName: string;
+    /** HMAC access key ID */
+    accessKeyId: string | Redacted.Redacted<string>;
+    /** HMAC secret access key */
+    secretAccessKey: string | Redacted.Redacted<string>;
+    /** Prefix within the bucket (optional) */
+    bucketPrefix?: string;
+}
+export declare const GCSMount: S.Schema<GCSMount>;
+/** Mount type identifier */
+export type R2MountType = "r2";
+export declare const R2MountType: any;
+/** Mount configuration for Cloudflare R2 buckets */
+export interface R2Mount {
+    /** Mount type identifier */
+    type: R2MountType;
+    /** R2 bucket name */
+    bucketName: string;
+    /** R2 endpoint URL */
+    bucketEndpoint: string;
+    /** R2 access key ID */
+    accessKeyId: string | Redacted.Redacted<string>;
+    /** R2 secret access key */
+    secretAccessKey: string | Redacted.Redacted<string>;
+    /** Prefix within the bucket (optional) */
+    bucketPrefix?: string;
+}
+export declare const R2Mount: S.Schema<R2Mount>;
+/** Mount type identifier */
+export type S3CompatibleMountType = "s3-compatible";
+export declare const S3CompatibleMountType: any;
+/** Mount configuration for S3-compatible storage (MinIO, Backblaze B2, etc.) */
+export interface S3CompatibleMount {
+    /** Mount type identifier */
+    type: S3CompatibleMountType;
+    /** Bucket name */
+    bucketName: string;
+    /** S3-compatible endpoint URL */
+    bucketEndpoint: string;
+    /** Access key ID */
+    accessKeyId: string | Redacted.Redacted<string>;
+    /** Secret access key */
+    secretAccessKey: string | Redacted.Redacted<string>;
+    /** Prefix within the bucket (optional) */
+    bucketPrefix?: string;
+}
+export declare const S3CompatibleMount: S.Schema<S3CompatibleMount>;
+/** Mount type identifier */
+export type AzureBlobMountType = "azure-blob";
+export declare const AzureBlobMountType: any;
+/** Mount configuration for Azure Blob Storage containers */
+export interface AzureBlobMount {
+    /** Mount type identifier */
+    type: AzureBlobMountType;
+    /** Azure blob container name */
+    containerName: string;
+    /** Azure blob endpoint URL (optional if storageAccountName provided) */
+    endpoint?: string;
+    /** Azure storage account name (used to derive endpoint if not provided) */
+    storageAccountName?: string;
+    /** Azure AD tenant ID */
+    tenantId: string;
+    /** Azure AD application client ID */
+    clientId: string;
+    /** Azure AD application client secret */
+    clientSecret: string | Redacted.Redacted<string>;
+    /** Prefix within the container */
+    bucketPrefix?: string;
+}
+export declare const AzureBlobMount: S.Schema<AzureBlobMount>;
+export type MountConfig = S3Mount | GCSMount | R2Mount | S3CompatibleMount | AzureBlobMount;
+export declare const MountConfig: S.Schema<MountConfig>;
+/** Storage mount to attach. Omit for archil-managed storage. */
+export type CreateDiskRequestMountsList = Array<MountConfig>;
+export declare const CreateDiskRequestMountsList: S.Schema<CreateDiskRequestMountsList>;
+/** Deprecated. Use AddDiskUser after creation instead. When provided, suppresses the default auto-generated token user. */
+export type CreateDiskRequestAuthMethodsList = Array<DiskUser>;
+export declare const CreateDiskRequestAuthMethodsList: S.Schema<CreateDiskRequestAuthMethodsList>;
+export interface CreateDiskRequest {
+    /** Disk name (alphanumeric, dashes, underscores) */
+    name: string;
+    /** Storage mount to attach. Omit for archil-managed storage. */
+    mounts?: CreateDiskRequestMountsList;
+    /** Deprecated. Use AddDiskUser after creation instead. When provided, suppresses the default auto-generated token user. */
+    authMethods?: CreateDiskRequestAuthMethodsList;
+}
+export declare const CreateDiskRequest: S.Schema<CreateDiskRequest>;
+export type ApiResponseCreateDiskDataAuthorizedUsersList = Array<AuthorizedUser>;
+export declare const ApiResponseCreateDiskDataAuthorizedUsersList: S.Schema<ApiResponseCreateDiskDataAuthorizedUsersList>;
+export interface ApiResponseCreateDiskData {
+    diskId?: string;
+    authorizedUsers?: ApiResponseCreateDiskDataAuthorizedUsersList;
+}
+export declare const ApiResponseCreateDiskData: S.Schema<ApiResponseCreateDiskData>;
+export interface ApiResponseCreateDisk {
+    success: boolean;
+    data: ApiResponseCreateDiskData;
+}
+export declare const ApiResponseCreateDisk: S.Schema<ApiResponseCreateDisk>;
+/** Environment variables applied to every process */
+export type CreateSandboxRequestEnvMap = {
+    [key: string]: string | undefined;
+};
+export declare const CreateSandboxRequestEnvMap: S.Schema<CreateSandboxRequestEnvMap>;
+export interface CreateSandboxRequest {
+    /** Hold the request for a completed sandbox lifecycle transition */
+    wait?: boolean;
+    /** Sandbox name, unique within the account. A random word-list name is generated when omitted. */
+    name?: string;
+    vcpu_count?: number;
+    mem_size_mib?: number;
+    /** Public Linux OCI image reference. Docker shorthand and tags are accepted. */
+    base_image?: string;
+    /** Environment variables applied to every process */
+    env?: CreateSandboxRequestEnvMap;
+    /** Lifetime budget for each powered-on session. Activity does not extend the deadline; starting or resuming the sandbox begins a fresh session. */
+    max_ttl_seconds?: number;
+    /** Maximum concurrently attached process sessions */
+    max_concurrent_execs?: number;
+}
+export declare const CreateSandboxRequest: S.Schema<CreateSandboxRequest>;
+export interface CreateSandboxResponse {
+}
+export declare const CreateSandboxResponse: S.Schema<CreateSandboxResponse>;
+export interface CreateSandboxConnectionRequest {
+    /** Sandbox UUID */
+    sid: string;
+}
+export declare const CreateSandboxConnectionRequest: S.Schema<CreateSandboxConnectionRequest>;
+export interface SandboxConnection {
+    url: string;
+    expires_at: string;
+}
+export declare const SandboxConnection: S.Schema<SandboxConnection>;
+export interface ApiResponseSandboxConnection {
+    success: boolean;
+    data: SandboxConnection;
+}
+export declare const ApiResponseSandboxConnection: S.Schema<ApiResponseSandboxConnection>;
+export interface CreateShareUrlRequest {
+    /** Disk ID (format `dsk-{16 hex chars}`) */
+    id: string;
+    /** File key (path) within the disk. */
+    key: string;
+    /** URL lifetime in seconds. Any integer from 1 to 604800 (7 days). Defaults to 86400 (24 hours). */
+    expiresIn?: number;
+}
+export declare const CreateShareUrlRequest: S.Schema<CreateShareUrlRequest>;
+export interface ApiResponseShareUrlData {
+    /** The signed, public download URL. */
+    url: string;
+    /** URL lifetime in seconds. */
+    expiresIn: number;
+}
+export declare const ApiResponseShareUrlData: S.Schema<ApiResponseShareUrlData>;
+export interface ApiResponseShareUrl {
+    success: boolean;
+    data: ApiResponseShareUrlData;
+}
+export declare const ApiResponseShareUrl: S.Schema<ApiResponseShareUrl>;
+export interface DeleteDiskRequest {
+    /** Disk ID (format `dsk-{16 hex chars}`) */
+    id: string;
+}
+export declare const DeleteDiskRequest: S.Schema<DeleteDiskRequest>;
+export interface ApiResponseEmpty {
+    success: boolean;
+}
+export declare const ApiResponseEmpty: S.Schema<ApiResponseEmpty>;
+export interface DeleteSandboxRequest {
+    /** Sandbox UUID */
+    sid: string;
+}
+export declare const DeleteSandboxRequest: S.Schema<DeleteSandboxRequest>;
+export interface DeleteSandboxResponse {
+}
+export declare const DeleteSandboxResponse: S.Schema<DeleteSandboxResponse>;
+export interface DeleteTokenRequest {
+    /** The token ID (hash) */
+    id: string;
+}
+export declare const DeleteTokenRequest: S.Schema<DeleteTokenRequest>;
+export interface ApiResponseMessageData {
+    message?: string;
+}
+export declare const ApiResponseMessageData: S.Schema<ApiResponseMessageData>;
+export interface ApiResponseMessage {
+    success: boolean;
+    data: ApiResponseMessageData;
+}
+export declare const ApiResponseMessage: S.Schema<ApiResponseMessage>;
+export interface ExecMount {
+    /** Disk ID to mount at this relative path */
+    disk: string;
+    /** Subdirectory of the disk to expose at the mountpoint. Must be a relative path with no `.` or `..` segments. When omitted, the disk's root is exposed. */
+    subdirectory?: string;
+    /** When true, the disk is mounted read-only inside the container. Writes against the mount fail with EROFS. */
+    readOnly?: boolean;
+}
+export declare const ExecMount: S.Schema<ExecMount>;
+export type ExecRequestDisksValue = string | ExecMount;
+export declare const ExecRequestDisksValue: S.Schema<ExecRequestDisksValue>;
+/** Map of relative path under `/mnt/archil` to the disk to mount there. At least one entry is required. Relative paths must be non-empty, non-absolute, and contain no `.` or `..` segments. Each value is either a plain disk ID string (mounts the disk's root, read-write) or an object that additionally selects a subdirectory of the disk and/or marks the mount as read-only. */
+export type ExecRequestDisksMap = {
+    [key: string]: ExecRequestDisksValue | undefined;
+};
+export declare const ExecRequestDisksMap: S.Schema<ExecRequestDisksMap>;
+export interface ExecRequest {
+    /** Map of relative path under `/mnt/archil` to the disk to mount there. At least one entry is required. Relative paths must be non-empty, non-absolute, and contain no `.` or `..` segments. Each value is either a plain disk ID string (mounts the disk's root, read-write) or an object that additionally selects a subdirectory of the disk and/or marks the mount as read-only. */
+    disks: ExecRequestDisksMap;
+    /** Shell command to execute inside the container */
+    command: string;
+}
+export declare const ExecRequest: S.Schema<ExecRequest>;
+/** Server-measured timings for an exec request. */
+export interface ExecTiming {
+    /** End-to-end wall clock measured on the server, from request arrival to response. */
+    totalMs: number;
+    /** Time spent queueing, scheduling, booting/claiming a VM, and mounting the filesystem before the command started running. */
+    queueMs: number;
+    /** Time the user's command itself ran, measured by the runtime. */
+    executeMs: number;
+}
+export declare const ExecTiming: S.Schema<ExecTiming>;
+export interface ExecDiskResult {
+    /** Exit code of the command (0 = success) */
+    exitCode: number;
+    /** Standard output from the command */
+    stdout: string;
+    /** Standard error from the command */
+    stderr: string;
+    timing: ExecTiming;
+}
+export declare const ExecDiskResult: S.Schema<ExecDiskResult>;
+export interface ApiResponseExec {
+    success: boolean;
+    data: ExecDiskResult;
+}
+export declare const ApiResponseExec: S.Schema<ApiResponseExec>;
+export interface ExecDiskRequest {
+    /** Disk ID (format `dsk-{16 hex chars}`) */
+    id: string;
+    /** Shell command to execute inside the container */
+    command: string;
+}
+export declare const ExecDiskRequest: S.Schema<ExecDiskRequest>;
+export interface ApiResponseExecDisk {
+    success: boolean;
+    data: ExecDiskResult;
+}
+export declare const ApiResponseExecDisk: S.Schema<ApiResponseExecDisk>;
+export interface ForkSandboxRequest {
+    /** Sandbox UUID */
+    sid: string;
+    /** Hold the request for a completed sandbox lifecycle transition */
+    wait?: boolean;
+    /** Name for the fork. A random word-list name is generated when omitted. */
+    name?: string;
+}
+export declare const ForkSandboxRequest: S.Schema<ForkSandboxRequest>;
+export interface ForkSandboxResponse {
+}
+export declare const ForkSandboxResponse: S.Schema<ForkSandboxResponse>;
+export interface GetDiskRequest {
+    /** Disk ID (format `dsk-{16 hex chars}`) */
+    id: string;
+}
+export declare const GetDiskRequest: S.Schema<GetDiskRequest>;
+/** Disk status */
+export type DiskResponseStatus = "available" | "creating" | "deleting" | "deleted" | "failed";
+export declare const DiskResponseStatus: any;
+/** Storage backend type */
+export type MountResponseType = "s3" | "gcs" | "r2" | "s3-compatible" | "azure-blob";
+export declare const MountResponseType: any;
+/** Access mode */
+export type MountResponseAccessMode = "rw" | "ro";
+export declare const MountResponseAccessMode: any;
+/** Mount configuration details (secrets omitted) */
+export interface MountConfigResponse {
+    /** Bucket name */
+    bucketName?: string;
+    /** Storage endpoint URL */
+    bucketEndpoint?: string;
+    /** Prefix within the bucket */
+    bucketPrefix?: string;
+    /** Session identifier for IAM-authorized mounts */
+    sessionId?: string;
+}
+export declare const MountConfigResponse: S.Schema<MountConfigResponse>;
+/** Current connection status */
+export type MountResponseConnectionStatus = "connected" | "disconnected";
+export declare const MountResponseConnectionStatus: any;
+/** How the mount authenticates to the storage backend */
+export type MountResponseAuthorizationType = "iam" | "accessKeys" | "oauth";
+export declare const MountResponseAuthorizationType: any;
+export interface MountResponse {
+    /** Mount identifier */
+    id?: string;
+    /** Storage backend type */
+    type?: MountResponseType;
+    /** Mount path */
+    path?: string;
+    /** Bucket/container name */
+    name?: string;
+    /** Access mode */
+    accessMode?: MountResponseAccessMode;
+    config?: MountConfigResponse;
+    /** Current connection status */
+    connectionStatus?: MountResponseConnectionStatus;
+    /** Authentication error message (if disconnected) */
+    authError?: string;
+    /** How the mount authenticates to the storage backend */
+    authorizationType?: MountResponseAuthorizationType;
+}
+export declare const MountResponse: S.Schema<MountResponse>;
+export type DiskResponseMountsList = Array<MountResponse>;
+export declare const DiskResponseMountsList: S.Schema<DiskResponseMountsList>;
+export interface DiskMetrics {
+    /** Data transfer amount with unit (e.g., "1.5 GB") */
+    dataTransfer?: string;
+    /** Total request count as a formatted string (e.g., "1,234") */
+    requests?: string;
+    /** Average response time with unit (e.g., "45ms") */
+    avgResponseTime?: string;
+}
+export declare const DiskMetrics: S.Schema<DiskMetrics>;
+export interface ConnectedClient {
+    id?: string;
+    ipAddress?: string;
+    connectedAt?: string;
+}
+export declare const ConnectedClient: S.Schema<ConnectedClient>;
+export type DiskResponseConnectedClientsList = Array<ConnectedClient>;
+export declare const DiskResponseConnectedClientsList: S.Schema<DiskResponseConnectedClientsList>;
+export type DiskResponseAuthorizedUsersList = Array<AuthorizedUser>;
+export declare const DiskResponseAuthorizedUsersList: S.Schema<DiskResponseAuthorizedUsersList>;
+export interface DiskResponse {
+    /** Disk ID */
+    id: string;
+    /** Disk name */
+    name: string;
+    /** Owning organization ID */
+    organization: string;
+    /** Disk status */
+    status: DiskResponseStatus;
+    /** Filesystem handler status */
+    fsHandlerStatus?: string;
+    /** Cloud provider */
+    provider: string;
+    /** Disk region (e.g., aws-us-east-1, gcp-us-central1) */
+    region: string;
+    /** Creation timestamp */
+    createdAt: string;
+    /** Last access timestamp */
+    lastAccessed?: string;
+    /** Total data size in bytes */
+    dataSize?: number;
+    /** Monthly usage amount formatted as a currency string (e.g., "$1.23") */
+    monthlyUsage?: string;
+    mounts?: DiskResponseMountsList;
+    metrics?: DiskMetrics;
+    connectedClients?: DiskResponseConnectedClientsList;
+    authorizedUsers?: DiskResponseAuthorizedUsersList;
+}
+export declare const DiskResponse: S.Schema<DiskResponse>;
+export interface ApiResponseDisk {
+    success: boolean;
+    data: DiskResponse;
+}
+export declare const ApiResponseDisk: S.Schema<ApiResponseDisk>;
+export interface GetSandboxRequest {
+    /** Sandbox UUID */
+    sid: string;
+}
+export declare const GetSandboxRequest: S.Schema<GetSandboxRequest>;
+export type SandboxState = "pending" | "running" | "pausing" | "paused" | "stopping" | "stopped" | "exited" | "failed" | "deleting" | "deleted";
+export declare const SandboxState: any;
+/** Sandbox CPU architecture. */
+export type SandboxPlatform = "arm64" | "amd64";
+export declare const SandboxPlatform: any;
+export interface SandboxEndpoint {
+    port: number;
+    hostname: string;
+}
+export declare const SandboxEndpoint: S.Schema<SandboxEndpoint>;
+export type SandboxEndpointsList = Array<SandboxEndpoint>;
+export declare const SandboxEndpointsList: S.Schema<SandboxEndpointsList>;
+export interface Sandbox {
+    sandbox_id: string;
+    /** Sandbox name. */
+    name: string;
+    status: SandboxState;
+    vcpu_count: number;
+    mem_size_mib: number;
+    /** Lifetime budget for each powered-on session. Activity does not extend the deadline; starting or resuming the sandbox begins a fresh session. */
+    max_ttl_seconds: number;
+    /** Maximum concurrently attached process sessions */
+    max_concurrent_execs: number;
+    /** OCI reference requested when the sandbox was created. */
+    base_image: string;
+    /** Sandbox CPU architecture. */
+    platform?: SandboxPlatform;
+    endpoints?: SandboxEndpointsList;
+    created_at: string;
+    running_at?: string;
+    finished_at?: string;
+    last_active_at: string;
+    /** Current powered-on session deadline; absent while inactive. */
+    expires_at?: string;
+    exit_reason?: string;
+}
+export declare const Sandbox: S.Schema<Sandbox>;
+export interface ApiResponseSandbox {
+    success: boolean;
+    data: Sandbox;
+}
+export declare const ApiResponseSandbox: S.Schema<ApiResponseSandbox>;
+export interface GrepDiskRequest {
+    /** Disk ID (format `dsk-{16 hex chars}`) */
+    id: string;
+    /** Directory on the disk to search, relative to the disk root. An empty string or "/" means the disk root. */
+    directory: string;
+    /** Extended regular expression (passed to `grep -E`) */
+    pattern: string;
+    /** When true, walks subdirectories breadth-first. */
+    recursive?: boolean;
+    /** Wall-clock deadline for the entire request. Capped at 30 seconds because the runtime exec container itself is bounded at ~30s; longer requests would have their workers killed mid-scan. */
+    maxDurationSeconds?: number;
+    /** Maximum number of parallel grep workers. Higher values finish larger datasets within the deadline but consume proportionally more runtime capacity. */
+    concurrency?: number;
+    /** Stop scanning once the aggregator has this many matches. Returned matches are a sample of whichever workers reported first, not the lexicographically first N. */
+    maxResults?: number;
+}
+export declare const GrepDiskRequest: S.Schema<GrepDiskRequest>;
+export interface GrepMatch {
+    /** Path to the file (relative to the disk root). */
+    file: string;
+    /** 1-based line number where the match occurred. */
+    line: number;
+    /** The matching line. */
+    text: string;
+}
+export declare const GrepMatch: S.Schema<GrepMatch>;
+export type GrepDiskResultMatchesList = Array<GrepMatch>;
+export declare const GrepDiskResultMatchesList: S.Schema<GrepDiskResultMatchesList>;
+/** Why the search stopped. - `completed`: every file under the directory was scanned successfully. - `incomplete`: pipeline ran to its natural end but one or more batches errored (invalid regex, unreadable file, runtime issue). Results may be partial or wrong; do not rely on completeness. - `max_results`: hit `maxResults` before scanning everything. - `deadline`: hit `maxDurationSeconds`. - `list_failed`: directory listing failed; partial results may be present. */
+export type GrepStoppedReason = "completed" | "incomplete" | "max_results" | "deadline" | "list_failed";
+export declare const GrepStoppedReason: any;
+export interface GrepDiskResult {
+    matches: GrepDiskResultMatchesList;
+    stoppedReason: GrepStoppedReason;
+    /** Files actually fed to a grep container. */
+    filesScanned: number;
+    /** Number of grep containers started for this request. */
+    containersDispatched: number;
+    /** Sum of per-container execution time in seconds, measured by the runtime. Approximates billable container-seconds. */
+    computeSecondsUsed: number;
+    /** End-to-end wall clock measured by the server. */
+    durationMs: number;
+    /** Wall-clock time spent enumerating files via listObjects, from the request's start to the moment listing fully drained (or was canceled). Listing and matching overlap, so listingMs + grepMs typically exceeds durationMs. */
+    listingMs: number;
+    /** Wall-clock time spent matching, from the first grep container being dispatched to the last container reporting results. 0 if no batches ran. */
+    grepMs: number;
+}
+export declare const GrepDiskResult: S.Schema<GrepDiskResult>;
+export interface ApiResponseGrepDisk {
+    success: boolean;
+    data: GrepDiskResult;
+}
+export declare const ApiResponseGrepDisk: S.Schema<ApiResponseGrepDisk>;
+export interface ListApiTokensRequest {
+    /** Maximum number of items to return */
+    limit?: number;
+    /** Pagination cursor from a previous response */
+    cursor?: string;
+}
+export declare const ListApiTokensRequest: S.Schema<ListApiTokensRequest>;
+export interface ApiTokenResponse {
+    /** Token hash/ID */
+    id?: string;
+    name?: string;
+    description?: string;
+    /** Last 4 characters of the token */
+    tokenSuffix?: string;
+    createdAt?: string;
+    lastUsedAt?: string;
+}
+export declare const ApiTokenResponse: S.Schema<ApiTokenResponse>;
+export type ApiResponseTokenListDataTokensList = Array<ApiTokenResponse>;
+export declare const ApiResponseTokenListDataTokensList: S.Schema<ApiResponseTokenListDataTokensList>;
+export interface ApiResponseTokenListData {
+    tokens?: ApiResponseTokenListDataTokensList;
+}
+export declare const ApiResponseTokenListData: S.Schema<ApiResponseTokenListData>;
+export interface ApiResponseTokenList {
+    success: boolean;
+    data: ApiResponseTokenListData;
+}
+export declare const ApiResponseTokenList: S.Schema<ApiResponseTokenList>;
+export interface ListDisksRequest {
+    /** Maximum number of items to return */
+    limit?: number;
+    /** Pagination cursor from a previous response */
+    cursor?: string;
+    /** Filter disks by exact name match. */
+    name?: string;
+}
+export declare const ListDisksRequest: S.Schema<ListDisksRequest>;
+export type ApiResponseDiskListDataList = Array<DiskResponse>;
+export declare const ApiResponseDiskListDataList: S.Schema<ApiResponseDiskListDataList>;
+/** 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. */
+export interface ApiResponseDiskList {
+    success: boolean;
+    data: ApiResponseDiskListDataList;
+}
+export declare const ApiResponseDiskList: S.Schema<ApiResponseDiskList>;
+export interface ListSandboxesRequest {
+    /** Only sandboxes that mount this disk */
+    filesystem?: string;
+}
+export declare const ListSandboxesRequest: S.Schema<ListSandboxesRequest>;
+export type ApiResponseSandboxListDataSandboxesList = Array<Sandbox>;
+export declare const ApiResponseSandboxListDataSandboxesList: S.Schema<ApiResponseSandboxListDataSandboxesList>;
+export interface ApiResponseSandboxListData {
+    sandboxes?: ApiResponseSandboxListDataSandboxesList;
+}
+export declare const ApiResponseSandboxListData: S.Schema<ApiResponseSandboxListData>;
+export interface ApiResponseSandboxList {
+    success: boolean;
+    data: ApiResponseSandboxListData;
+}
+export declare const ApiResponseSandboxList: S.Schema<ApiResponseSandboxList>;
+export interface PauseSandboxRequest {
+    /** Sandbox UUID */
+    sid: string;
+}
+export declare const PauseSandboxRequest: S.Schema<PauseSandboxRequest>;
+export type RemoveDiskUserRequestUserType = "token" | "awssts";
+export declare const RemoveDiskUserRequestUserType: any;
+export interface RemoveDiskUserRequest {
+    /** Disk ID (format `dsk-{16 hex chars}`) */
+    id: string;
+    /** The type of user authentication */
+    userType: RemoveDiskUserRequestUserType | (string & {});
+    /** Identifier of the user to remove, as returned in the creation or list response. For awssts users, this is the IAM ARN. */
+    identifier?: string;
+    /** Use identifier instead. */
+    principal?: string;
+}
+export declare const RemoveDiskUserRequest: S.Schema<RemoveDiskUserRequest>;
+export interface ResumeSandboxRequest {
+    /** Sandbox UUID */
+    sid: string;
+    /** Hold the request for a completed sandbox lifecycle transition */
+    wait?: boolean;
+}
+export declare const ResumeSandboxRequest: S.Schema<ResumeSandboxRequest>;
+export interface StartSandboxRequest {
+    /** Sandbox UUID */
+    sid: string;
+    /** Hold the request for a completed sandbox lifecycle transition */
+    wait?: boolean;
+}
+export declare const StartSandboxRequest: S.Schema<StartSandboxRequest>;
+export interface StopSandboxRequest {
+    /** Sandbox UUID */
+    sid: string;
+}
+export declare const StopSandboxRequest: S.Schema<StopSandboxRequest>;
+export type AddDiskUserError = BadRequest | ArchilOpError;
+/** Add user to disk 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 */
+export declare const addDiskUser: API.OperationMethod<AddDiskUserRequest, ApiResponseAuthorizedUser, AddDiskUserError, ArchilOpContext>;
+export type CreateApiTokenError = BadRequest | ArchilOpError;
+/** Create API token Creates a new API token for programmatic access. The full token value is only returned once at creation time. */
+export declare const createApiToken: API.OperationMethod<CreateApiTokenRequest, ApiResponseTokenCreated, CreateApiTokenError, ArchilOpContext>;
+export type CreateDiskError = BadRequest | Forbidden | Conflict | ArchilOpError;
+/** Create a new disk Creates a new disk with the specified configuration. A default disk token user is automatically generated and returned in the response, so the disk is immediately mountable. The one-time disk token appears in `authorizedUsers[].token` and cannot be retrieved again. (This disk token is scoped to the new disk and is separate from the API key you used to make this request.) To provide your own users instead, pass the deprecated `authMethods` field or call AddDiskUser after creation. */
+export declare const createDisk: API.OperationMethod<CreateDiskRequest, ApiResponseCreateDisk, CreateDiskError, ArchilOpContext>;
+export type CreateSandboxError = BadRequest | Conflict | ArchilOpError;
+/** Create a sandbox Provisions a sandbox VM with the requested shape and a dedicated, persistent Archil disk. By default the response reports `pending` after the runtime accepts the start. Set `wait=true` to hold for `running`; if the wait budget expires, the response remains `pending` and startup continues. */
+export declare const createSandbox: API.OperationMethod<CreateSandboxRequest, CreateSandboxResponse, CreateSandboxError, ArchilOpContext>;
+export type CreateSandboxConnectionError = NotFound | Conflict | ArchilOpError;
+/** Create a sandbox process connection Returns a short-lived WebSocket URL for the process API in a running sandbox. The URL contains a signed token that expires at `expires_at`. */
+export declare const createSandboxConnection: API.OperationMethod<CreateSandboxConnectionRequest, ApiResponseSandboxConnection, CreateSandboxConnectionError, ArchilOpContext>;
+export type CreateShareUrlError = BadRequest | NotFound | ArchilOpError;
+/** Create a share URL for a file Creates a signed, time-limited URL for downloading a file without authentication. The URL expires after 24 hours by default; pass `expiresIn` to set a custom lifetime up to 7 days. The returned URL points to a public endpoint (`GET /api/shared/{token}`) that verifies the signature, checks expiry, and streams the file with a sensible `Content-Type` and `Content-Disposition`. Range requests are supported. No credentials are needed to open the URL. */
+export declare const createShareUrl: API.OperationMethod<CreateShareUrlRequest, ApiResponseShareUrl, CreateShareUrlError, ArchilOpContext>;
+export type DeleteDiskError = BadRequest | NotFound | ArchilOpError;
+/** Delete a disk Deletes a disk and all associated resources. */
+export declare const deleteDisk: API.OperationMethod<DeleteDiskRequest, ApiResponseEmpty, DeleteDiskError, ArchilOpContext>;
+export type DeleteSandboxError = NotFound | Conflict | ArchilOpError;
+/** Delete a sandbox Permanently deletes a stopped, exited, or failed sandbox and its backing disk. A sandbox with child forks cannot be deleted until those children are deleted, starting with the deepest ones. */
+export declare const deleteSandbox: API.OperationMethod<DeleteSandboxRequest, DeleteSandboxResponse, DeleteSandboxError, ArchilOpContext>;
+export type DeleteTokenError = NotFound | ArchilOpError;
+/** Delete API token Revokes and deletes an API token. */
+export declare const deleteToken: API.OperationMethod<DeleteTokenRequest, ApiResponseMessage, DeleteTokenError, ArchilOpContext>;
+export type ExecError = BadRequest | NotFound | ArchilOpError;
+/** Execute a command with multiple disks mounted Launches a container with the supplied set of disks each mounted at its own relative path under `/mnt/archil`, runs the command to completion, and shuts down the container. Activation is atomic: every disk mounts or none of them do. Relative paths must be non-empty, non-absolute, and contain no `.` / `..` segments. Mounting two disks at the same relative path is an error. */
+export declare const exec: API.OperationMethod<ExecRequest, ApiResponseExec, ExecError, ArchilOpContext>;
+export type ExecDiskError = BadRequest | NotFound | ArchilOpError;
+/** Execute a command on a disk Launches a container with the specified disk mounted, runs the given command to completion, shuts down the container, and returns the command result. */
+export declare const execDisk: API.OperationMethod<ExecDiskRequest, ApiResponseExecDisk, ExecDiskError, ArchilOpContext>;
+export type ForkSandboxError = BadRequest | NotFound | Conflict | ArchilOpError;
+/** Fork a sandbox Checkpoints a running source sandbox and creates an isolated writable disk branch. Forks from running or paused sources resume from the source's CPU, memory, and disk state. Forks from stopped sources cold-boot from the saved disk checkpoint. A running source is resumed after its checkpoint; paused and stopped sources remain inactive. Forked sandboxes may themselves be forked. */
+export declare const forkSandbox: API.OperationMethod<ForkSandboxRequest, ForkSandboxResponse, ForkSandboxError, ArchilOpContext>;
+export type GetDiskError = BadRequest | NotFound | ArchilOpError;
+/** Get disk details Returns detailed information about a specific disk. */
+export declare const getDisk: API.OperationMethod<GetDiskRequest, ApiResponseDisk, GetDiskError, ArchilOpContext>;
+export type GetSandboxError = NotFound | ArchilOpError;
+/** Get a sandbox */
+export declare const getSandbox: API.OperationMethod<GetSandboxRequest, ApiResponseSandbox, GetSandboxError, ArchilOpContext>;
+export type GrepDiskError = BadRequest | NotFound | ArchilOpError;
+/** Parallel grep over a directory on a disk Searches files under a directory on the disk for lines matching a regular expression. Listing and matching are fanned out across ephemeral exec containers, so the request finishes within the user's time budget regardless of the size of the directory. The user controls cost and latency with three knobs: - `maxDurationSeconds` is the wall-clock deadline (capped at 30s). - `concurrency` is the maximum number of parallel grep workers. Higher concurrency finishes larger datasets within the deadline, at proportionally more compute. - `maxResults` causes the search to short-circuit after the aggregator has collected this many matches. With `recursive: false` only files directly under `directory` are searched. With `recursive: true` subdirectories are walked breadth-first and grep workers are dispatched as soon as each level finishes listing — listing and matching overlap. The matches returned when stopping early on `maxResults` are a sample of whichever workers reported first, not the lexicographically first N. The response surfaces `stoppedReason` so callers can distinguish completion from early termination. */
+export declare const grepDisk: API.OperationMethod<GrepDiskRequest, ApiResponseGrepDisk, GrepDiskError, ArchilOpContext>;
+export type ListApiTokensError = ArchilOpError;
+/** List API tokens Returns all API tokens for the authenticated account. */
+export declare const listApiTokens: API.OperationMethod<ListApiTokensRequest, ApiResponseTokenList, ListApiTokensError, ArchilOpContext>;
+export type ListDisksError = ArchilOpError;
+/** List all disks Returns all disks owned by the authenticated account. */
+export declare const listDisks: API.OperationMethod<ListDisksRequest, ApiResponseDiskList, ListDisksError, ArchilOpContext>;
+export type ListSandboxesError = BadRequest | ArchilOpError;
+/** List sandboxes All the account's sandboxes, oldest first. */
+export declare const listSandboxes: API.OperationMethod<ListSandboxesRequest, ApiResponseSandboxList, ListSandboxesError, ArchilOpContext>;
+export type PauseSandboxError = BadRequest | NotFound | Conflict | ArchilOpError;
+/** Pause a sandbox Snapshot the CPU & memory state, then stop the VM. The sandbox reports `pausing` until the snapshot commit marker is durable and the VM exits, then reports `paused`. Attached process connections close, while agent-owned processes remain available for reattachment after resume. A sandbox that is still `pending` must reach `running` before it can be paused. To restore the snapshot, call `/resume`. */
+export declare const pauseSandbox: API.OperationMethod<PauseSandboxRequest, ApiResponseSandbox, PauseSandboxError, ArchilOpContext>;
+export type RemoveDiskUserError = BadRequest | ArchilOpError;
+/** Remove user from disk Removes an authorized user from a disk. */
+export declare const removeDiskUser: API.OperationMethod<RemoveDiskUserRequest, ApiResponseMessage, RemoveDiskUserError, ArchilOpContext>;
+export type ResumeSandboxError = BadRequest | NotFound | Conflict | ArchilOpError;
+/** Resume a sandbox Restores a paused sandbox's committed CPU and memory snapshot. Resuming a running sandbox or a pending resume is idempotent. Only a `paused` sandbox can begin a new resume; `stopped`, `exited`, `failed`, `stopping`, `pausing`, or a pending cold start returns 409. */
+export declare const resumeSandbox: API.OperationMethod<ResumeSandboxRequest, ApiResponseSandbox, ResumeSandboxError, ArchilOpContext>;
+export type StartSandboxError = BadRequest | NotFound | Conflict | ArchilOpError;
+/** Cold-start a sandbox Cold-boots from the persisted configuration and disks. If the sandbox was paused, its memory snapshot is consumed and discarded before the new VM runs; disk state remains. Starting a running sandbox or a pending cold start is idempotent. A sandbox that is stopping, pausing, or pending a resume returns 409. */
+export declare const startSandbox: API.OperationMethod<StartSandboxRequest, ApiResponseSandbox, StartSandboxError, ArchilOpContext>;
+export type StopSandboxError = BadRequest | NotFound | Conflict | ArchilOpError;
+/** Stop a sandbox Gracefully shuts down the guest, then checkpoints its disk before entering `stopped`. The sandbox and any forks from it cold-boot from disk state. Stopping a paused sandbox reuses its existing disk checkpoint. In-flight processes receive the guest shutdown signal. */
+export declare const stopSandbox: API.OperationMethod<StopSandboxRequest, ApiResponseSandbox, StopSandboxError, ArchilOpContext>;
+//# sourceMappingURL=archil.d.ts.map