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

package/lib/services/archil.js

@@ -0,0 +1,721 @@
+// AUTO-GENERATED by scripts/generate.ts from .generated-specs (specs/spec-mirror-archil). Do not edit.
+import * as S from "@distilled.cloud/core/schema";
+import * as Redacted from "effect/Redacted";
+import * as API from "@distilled.cloud/core/api";
+import * as C from "@distilled.cloud/core/category";
+import * as T from "../traits.js";
+import { ArchilProtocol, } from "../protocol.js";
+import { UnknownArchilError } from "../errors.js";
+import * as Retry from "../retry.js";
+export class BadRequest extends /*@__PURE__*/ /*@__PURE__*/ T.applyErrorMatchers(
+/*@__PURE__*/ S.TaggedError()("BadRequest", {
+    code: S.Number,
+    message: S.String,
+}).pipe(C.withBadRequestError), [{ status: 400 }]) {
+}
+export class Conflict extends /*@__PURE__*/ /*@__PURE__*/ T.applyErrorMatchers(
+/*@__PURE__*/ S.TaggedError()("Conflict", {
+    code: S.Number,
+    message: S.String,
+}).pipe(C.withConflictError), [{ status: 409 }]) {
+}
+export class Forbidden extends /*@__PURE__*/ /*@__PURE__*/ T.applyErrorMatchers(
+/*@__PURE__*/ S.TaggedError()("Forbidden", {
+    code: S.Number,
+    message: S.String,
+}).pipe(C.withAuthError), [{ status: 403 }]) {
+}
+export class NotFound extends /*@__PURE__*/ /*@__PURE__*/ T.applyErrorMatchers(
+/*@__PURE__*/ S.TaggedError()("NotFound", {
+    code: S.Number,
+    message: S.String,
+}).pipe(C.withBadRequestError), [{ status: 404 }]) {
+}
+export const TokenUserType = /*@__PURE__*/ S.String;
+export const TokenUser = /*@__PURE__*/ S.suspend(() => S.Struct({
+    type: TokenUserType,
+    principal: S.optional(S.String),
+    nickname: S.String,
+    tokenSuffix: S.optional(S.String),
+})).annotate({ identifier: "TokenUser" });
+export const AwsStsUserType = /*@__PURE__*/ S.String;
+export const AwsStsUser = /*@__PURE__*/ S.suspend(() => S.Struct({
+    type: AwsStsUserType,
+    principal: S.String,
+})).annotate({ identifier: "AwsStsUser" });
+export const DiskUser = /*@__PURE__*/ S.Unknown;
+export const AddDiskUserRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    id: S.String.pipe(T.Label()),
+    body: DiskUser.pipe(T.HttpBody()),
+}).pipe(T.Http({ method: "POST", uri: "/api/disks/{id}/users", code: 200 }))).annotate({
+    identifier: "AddDiskUserRequest",
+});
+export const AuthorizedUserType = /*@__PURE__*/ S.String;
+export const AuthorizedUser = /*@__PURE__*/ S.suspend(() => S.Struct({
+    type: S.optional(AuthorizedUserType),
+    principal: S.optional(S.String),
+    nickname: S.optional(S.String),
+    tokenSuffix: S.optional(S.String),
+    token: S.optional(S.String),
+    identifier: S.optional(S.String),
+    createdAt: S.optional(S.String),
+})).annotate({ identifier: "AuthorizedUser" });
+export const ApiResponseAuthorizedUser = /*@__PURE__*/ S.suspend(() => S.Struct({
+    success: S.Boolean,
+    data: AuthorizedUser,
+})).annotate({
+    identifier: "ApiResponseAuthorizedUser",
+});
+export const CreateApiTokenRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    name: S.String,
+    description: S.optional(S.String),
+}).pipe(T.Http({ method: "POST", uri: "/api/tokens", code: 200 }))).annotate({
+    identifier: "CreateApiTokenRequest",
+});
+export const ApiResponseTokenCreatedData = /*@__PURE__*/ S.suspend(() => S.Struct({
+    id: S.optional(S.String),
+    name: S.optional(S.String),
+    description: S.optional(S.String),
+    tokenSuffix: S.optional(S.String),
+    createdAt: S.optional(S.String),
+    lastUsedAt: S.optional(S.String),
+    token: S.optional(S.String),
+})).annotate({
+    identifier: "ApiResponseTokenCreatedData",
+});
+export const ApiResponseTokenCreated = /*@__PURE__*/ S.suspend(() => S.Struct({
+    success: S.Boolean,
+    data: ApiResponseTokenCreatedData,
+})).annotate({
+    identifier: "ApiResponseTokenCreated",
+});
+export const S3MountType = /*@__PURE__*/ S.String;
+export const S3Mount = /*@__PURE__*/ S.suspend(() => S.Struct({
+    type: S3MountType,
+    bucketName: S.String,
+    accessKeyId: S.optional(S.String.pipe(T.SensitiveValue({}))),
+    secretAccessKey: S.optional(S.String.pipe(T.SensitiveValue({}))),
+    sessionToken: S.optional(S.String.pipe(T.SensitiveValue({}))),
+    bucketPrefix: S.optional(S.String),
+})).annotate({ identifier: "S3Mount" });
+export const GCSMountType = /*@__PURE__*/ S.String;
+export const GCSMount = /*@__PURE__*/ S.suspend(() => S.Struct({
+    type: GCSMountType,
+    bucketName: S.String,
+    accessKeyId: S.String.pipe(T.SensitiveValue({})),
+    secretAccessKey: S.String.pipe(T.SensitiveValue({})),
+    bucketPrefix: S.optional(S.String),
+})).annotate({ identifier: "GCSMount" });
+export const R2MountType = /*@__PURE__*/ S.String;
+export const R2Mount = /*@__PURE__*/ S.suspend(() => S.Struct({
+    type: R2MountType,
+    bucketName: S.String,
+    bucketEndpoint: S.String,
+    accessKeyId: S.String.pipe(T.SensitiveValue({})),
+    secretAccessKey: S.String.pipe(T.SensitiveValue({})),
+    bucketPrefix: S.optional(S.String),
+})).annotate({ identifier: "R2Mount" });
+export const S3CompatibleMountType = /*@__PURE__*/ S.String;
+export const S3CompatibleMount = /*@__PURE__*/ S.suspend(() => S.Struct({
+    type: S3CompatibleMountType,
+    bucketName: S.String,
+    bucketEndpoint: S.String,
+    accessKeyId: S.String.pipe(T.SensitiveValue({})),
+    secretAccessKey: S.String.pipe(T.SensitiveValue({})),
+    bucketPrefix: S.optional(S.String),
+})).annotate({
+    identifier: "S3CompatibleMount",
+});
+export const AzureBlobMountType = /*@__PURE__*/ S.String;
+export const AzureBlobMount = /*@__PURE__*/ S.suspend(() => S.Struct({
+    type: AzureBlobMountType,
+    containerName: S.String,
+    endpoint: S.optional(S.String),
+    storageAccountName: S.optional(S.String),
+    tenantId: S.String,
+    clientId: S.String,
+    clientSecret: S.String.pipe(T.SensitiveValue({})),
+    bucketPrefix: S.optional(S.String),
+})).annotate({ identifier: "AzureBlobMount" });
+export const MountConfig = 
+/*@__PURE__*/ S.Unknown;
+export const CreateDiskRequestMountsList = /*@__PURE__*/ S.Array(MountConfig);
+export const CreateDiskRequestAuthMethodsList = /*@__PURE__*/ S.Array(DiskUser);
+export const CreateDiskRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    name: S.String,
+    mounts: S.optional(CreateDiskRequestMountsList),
+    authMethods: S.optional(CreateDiskRequestAuthMethodsList),
+}).pipe(T.Http({ method: "POST", uri: "/api/disks", code: 200 }))).annotate({
+    identifier: "CreateDiskRequest",
+});
+export const ApiResponseCreateDiskDataAuthorizedUsersList = 
+/*@__PURE__*/ S.Array(AuthorizedUser);
+export const ApiResponseCreateDiskData = /*@__PURE__*/ S.suspend(() => S.Struct({
+    diskId: S.optional(S.String),
+    authorizedUsers: S.optional(ApiResponseCreateDiskDataAuthorizedUsersList),
+})).annotate({
+    identifier: "ApiResponseCreateDiskData",
+});
+export const ApiResponseCreateDisk = /*@__PURE__*/ S.suspend(() => S.Struct({
+    success: S.Boolean,
+    data: ApiResponseCreateDiskData,
+})).annotate({
+    identifier: "ApiResponseCreateDisk",
+});
+export const CreateSandboxRequestEnvMap = /*@__PURE__*/ S.Record(S.String, S.String);
+export const CreateSandboxRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    wait: S.optional(S.Boolean.pipe(T.Query())),
+    name: S.optional(S.String),
+    vcpu_count: S.optional(S.Number),
+    mem_size_mib: S.optional(S.Number),
+    base_image: S.optional(S.String),
+    env: S.optional(CreateSandboxRequestEnvMap),
+    max_ttl_seconds: S.optional(S.Number),
+    max_concurrent_execs: S.optional(S.Number),
+}).pipe(T.Http({ method: "POST", uri: "/api/sandboxes", code: 200 }))).annotate({
+    identifier: "CreateSandboxRequest",
+});
+export const CreateSandboxResponse = /*@__PURE__*/ S.suspend(() => S.Struct({})).annotate({
+    identifier: "CreateSandboxResponse",
+});
+export const CreateSandboxConnectionRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    sid: S.String.pipe(T.Label()),
+}).pipe(T.Http({
+    method: "POST",
+    uri: "/api/sandboxes/{sid}/connections",
+    code: 200,
+}))).annotate({
+    identifier: "CreateSandboxConnectionRequest",
+});
+export const SandboxConnection = /*@__PURE__*/ S.suspend(() => S.Struct({
+    url: S.String,
+    expires_at: S.String,
+})).annotate({
+    identifier: "SandboxConnection",
+});
+export const ApiResponseSandboxConnection = /*@__PURE__*/ S.suspend(() => S.Struct({
+    success: S.Boolean,
+    data: SandboxConnection,
+})).annotate({
+    identifier: "ApiResponseSandboxConnection",
+});
+export const CreateShareUrlRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    id: S.String.pipe(T.Label()),
+    key: S.String,
+    expiresIn: S.optional(S.Number),
+}).pipe(T.Http({ method: "POST", uri: "/api/disks/{id}/share", code: 200 }))).annotate({
+    identifier: "CreateShareUrlRequest",
+});
+export const ApiResponseShareUrlData = /*@__PURE__*/ S.suspend(() => S.Struct({
+    url: S.String,
+    expiresIn: S.Number,
+})).annotate({
+    identifier: "ApiResponseShareUrlData",
+});
+export const ApiResponseShareUrl = /*@__PURE__*/ S.suspend(() => S.Struct({
+    success: S.Boolean,
+    data: ApiResponseShareUrlData,
+})).annotate({
+    identifier: "ApiResponseShareUrl",
+});
+export const DeleteDiskRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    id: S.String.pipe(T.Label()),
+}).pipe(T.Http({ method: "DELETE", uri: "/api/disks/{id}", code: 200 }))).annotate({
+    identifier: "DeleteDiskRequest",
+});
+export const ApiResponseEmpty = /*@__PURE__*/ S.suspend(() => S.Struct({
+    success: S.Boolean,
+})).annotate({
+    identifier: "ApiResponseEmpty",
+});
+export const DeleteSandboxRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    sid: S.String.pipe(T.Label()),
+}).pipe(T.Http({ method: "DELETE", uri: "/api/sandboxes/{sid}", code: 200 }))).annotate({
+    identifier: "DeleteSandboxRequest",
+});
+export const DeleteSandboxResponse = /*@__PURE__*/ S.suspend(() => S.Struct({})).annotate({
+    identifier: "DeleteSandboxResponse",
+});
+export const DeleteTokenRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    id: S.String.pipe(T.Label()),
+}).pipe(T.Http({ method: "DELETE", uri: "/api/tokens/{id}", code: 200 }))).annotate({
+    identifier: "DeleteTokenRequest",
+});
+export const ApiResponseMessageData = /*@__PURE__*/ S.suspend(() => S.Struct({
+    message: S.optional(S.String),
+})).annotate({
+    identifier: "ApiResponseMessageData",
+});
+export const ApiResponseMessage = /*@__PURE__*/ S.suspend(() => S.Struct({
+    success: S.Boolean,
+    data: ApiResponseMessageData,
+})).annotate({
+    identifier: "ApiResponseMessage",
+});
+export const ExecMount = /*@__PURE__*/ S.suspend(() => S.Struct({
+    disk: S.String,
+    subdirectory: S.optional(S.String),
+    readOnly: S.optional(S.Boolean),
+})).annotate({ identifier: "ExecMount" });
+export const ExecRequestDisksValue = 
+/*@__PURE__*/ S.Unknown;
+export const ExecRequestDisksMap = /*@__PURE__*/ S.Record(S.String, ExecRequestDisksValue);
+export const ExecRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    disks: ExecRequestDisksMap,
+    command: S.String,
+}).pipe(T.Http({ method: "POST", uri: "/api/exec", code: 200 }))).annotate({ identifier: "ExecRequest" });
+export const ExecTiming = /*@__PURE__*/ S.suspend(() => S.Struct({
+    totalMs: S.Number,
+    queueMs: S.Number,
+    executeMs: S.Number,
+})).annotate({ identifier: "ExecTiming" });
+export const ExecDiskResult = /*@__PURE__*/ S.suspend(() => S.Struct({
+    exitCode: S.Number,
+    stdout: S.String,
+    stderr: S.String,
+    timing: ExecTiming,
+})).annotate({ identifier: "ExecDiskResult" });
+export const ApiResponseExec = /*@__PURE__*/ S.suspend(() => S.Struct({
+    success: S.Boolean,
+    data: ExecDiskResult,
+})).annotate({
+    identifier: "ApiResponseExec",
+});
+export const ExecDiskRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    id: S.String.pipe(T.Label()),
+    command: S.String,
+}).pipe(T.Http({ method: "POST", uri: "/api/disks/{id}/exec", code: 200 }))).annotate({
+    identifier: "ExecDiskRequest",
+});
+export const ApiResponseExecDisk = /*@__PURE__*/ S.suspend(() => S.Struct({
+    success: S.Boolean,
+    data: ExecDiskResult,
+})).annotate({
+    identifier: "ApiResponseExecDisk",
+});
+export const ForkSandboxRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    sid: S.String.pipe(T.Label()),
+    wait: S.optional(S.Boolean.pipe(T.Query())),
+    name: S.optional(S.String),
+}).pipe(T.Http({ method: "POST", uri: "/api/sandboxes/{sid}/fork", code: 200 }))).annotate({
+    identifier: "ForkSandboxRequest",
+});
+export const ForkSandboxResponse = /*@__PURE__*/ S.suspend(() => S.Struct({})).annotate({
+    identifier: "ForkSandboxResponse",
+});
+export const GetDiskRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    id: S.String.pipe(T.Label()),
+}).pipe(T.Http({ method: "GET", uri: "/api/disks/{id}", code: 200 }))).annotate({ identifier: "GetDiskRequest" });
+export const DiskResponseStatus = /*@__PURE__*/ S.String;
+export const MountResponseType = /*@__PURE__*/ S.String;
+export const MountResponseAccessMode = /*@__PURE__*/ S.String;
+export const MountConfigResponse = /*@__PURE__*/ S.suspend(() => S.Struct({
+    bucketName: S.optional(S.String),
+    bucketEndpoint: S.optional(S.String),
+    bucketPrefix: S.optional(S.String),
+    sessionId: S.optional(S.String),
+})).annotate({
+    identifier: "MountConfigResponse",
+});
+export const MountResponseConnectionStatus = /*@__PURE__*/ S.String;
+export const MountResponseAuthorizationType = /*@__PURE__*/ S.String;
+export const MountResponse = /*@__PURE__*/ S.suspend(() => S.Struct({
+    id: S.optional(S.String),
+    type: S.optional(MountResponseType),
+    path: S.optional(S.String),
+    name: S.optional(S.String),
+    accessMode: S.optional(MountResponseAccessMode),
+    config: S.optional(MountConfigResponse),
+    connectionStatus: S.optional(MountResponseConnectionStatus),
+    authError: S.optional(S.String),
+    authorizationType: S.optional(MountResponseAuthorizationType),
+})).annotate({ identifier: "MountResponse" });
+export const DiskResponseMountsList = /*@__PURE__*/ S.Array(MountResponse);
+export const DiskMetrics = /*@__PURE__*/ S.suspend(() => S.Struct({
+    dataTransfer: S.optional(S.String),
+    requests: S.optional(S.String),
+    avgResponseTime: S.optional(S.String),
+})).annotate({ identifier: "DiskMetrics" });
+export const ConnectedClient = /*@__PURE__*/ S.suspend(() => S.Struct({
+    id: S.optional(S.String),
+    ipAddress: S.optional(S.String),
+    connectedAt: S.optional(S.String),
+})).annotate({
+    identifier: "ConnectedClient",
+});
+export const DiskResponseConnectedClientsList = /*@__PURE__*/ S.Array(ConnectedClient);
+export const DiskResponseAuthorizedUsersList = /*@__PURE__*/ S.Array(AuthorizedUser);
+export const DiskResponse = /*@__PURE__*/ S.suspend(() => S.Struct({
+    id: S.String,
+    name: S.String,
+    organization: S.String,
+    status: DiskResponseStatus,
+    fsHandlerStatus: S.optional(S.String),
+    provider: S.String,
+    region: S.String,
+    createdAt: S.String,
+    lastAccessed: S.optional(S.String),
+    dataSize: S.optional(S.Number),
+    monthlyUsage: S.optional(S.String),
+    mounts: S.optional(DiskResponseMountsList),
+    metrics: S.optional(DiskMetrics),
+    connectedClients: S.optional(DiskResponseConnectedClientsList),
+    authorizedUsers: S.optional(DiskResponseAuthorizedUsersList),
+})).annotate({ identifier: "DiskResponse" });
+export const ApiResponseDisk = /*@__PURE__*/ S.suspend(() => S.Struct({
+    success: S.Boolean,
+    data: DiskResponse,
+})).annotate({
+    identifier: "ApiResponseDisk",
+});
+export const GetSandboxRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    sid: S.String.pipe(T.Label()),
+}).pipe(T.Http({ method: "GET", uri: "/api/sandboxes/{sid}", code: 200 }))).annotate({
+    identifier: "GetSandboxRequest",
+});
+export const SandboxState = /*@__PURE__*/ S.String;
+export const SandboxPlatform = /*@__PURE__*/ S.String;
+export const SandboxEndpoint = /*@__PURE__*/ S.suspend(() => S.Struct({
+    port: S.Number,
+    hostname: S.String,
+})).annotate({
+    identifier: "SandboxEndpoint",
+});
+export const SandboxEndpointsList = /*@__PURE__*/ S.Array(SandboxEndpoint);
+export const Sandbox = /*@__PURE__*/ S.suspend(() => S.Struct({
+    sandbox_id: S.String,
+    name: S.String,
+    status: SandboxState,
+    vcpu_count: S.Number,
+    mem_size_mib: S.Number,
+    max_ttl_seconds: S.Number,
+    max_concurrent_execs: S.Number,
+    base_image: S.String,
+    platform: S.optional(SandboxPlatform),
+    endpoints: S.optional(SandboxEndpointsList),
+    created_at: S.String,
+    running_at: S.optional(S.String),
+    finished_at: S.optional(S.String),
+    last_active_at: S.String,
+    expires_at: S.optional(S.String),
+    exit_reason: S.optional(S.String),
+})).annotate({ identifier: "Sandbox" });
+export const ApiResponseSandbox = /*@__PURE__*/ S.suspend(() => S.Struct({
+    success: S.Boolean,
+    data: Sandbox,
+})).annotate({
+    identifier: "ApiResponseSandbox",
+});
+export const GrepDiskRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    id: S.String.pipe(T.Label()),
+    directory: S.String,
+    pattern: S.String,
+    recursive: S.optional(S.Boolean),
+    maxDurationSeconds: S.optional(S.Number),
+    concurrency: S.optional(S.Number),
+    maxResults: S.optional(S.Number),
+}).pipe(T.Http({ method: "POST", uri: "/api/disks/{id}/grep", code: 200 }))).annotate({
+    identifier: "GrepDiskRequest",
+});
+export const GrepMatch = /*@__PURE__*/ S.suspend(() => S.Struct({
+    file: S.String,
+    line: S.Number,
+    text: S.String,
+})).annotate({ identifier: "GrepMatch" });
+export const GrepDiskResultMatchesList = /*@__PURE__*/ S.Array(GrepMatch);
+export const GrepStoppedReason = /*@__PURE__*/ S.String;
+export const GrepDiskResult = /*@__PURE__*/ S.suspend(() => S.Struct({
+    matches: GrepDiskResultMatchesList,
+    stoppedReason: GrepStoppedReason,
+    filesScanned: S.Number,
+    containersDispatched: S.Number,
+    computeSecondsUsed: S.Number,
+    durationMs: S.Number,
+    listingMs: S.Number,
+    grepMs: S.Number,
+})).annotate({ identifier: "GrepDiskResult" });
+export const ApiResponseGrepDisk = /*@__PURE__*/ S.suspend(() => S.Struct({
+    success: S.Boolean,
+    data: GrepDiskResult,
+})).annotate({
+    identifier: "ApiResponseGrepDisk",
+});
+export const ListApiTokensRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    limit: S.optional(S.Number.pipe(T.Query())),
+    cursor: S.optional(S.String.pipe(T.Query())),
+}).pipe(T.Http({ method: "GET", uri: "/api/tokens", code: 200 }))).annotate({
+    identifier: "ListApiTokensRequest",
+});
+export const ApiTokenResponse = /*@__PURE__*/ S.suspend(() => S.Struct({
+    id: S.optional(S.String),
+    name: S.optional(S.String),
+    description: S.optional(S.String),
+    tokenSuffix: S.optional(S.String),
+    createdAt: S.optional(S.String),
+    lastUsedAt: S.optional(S.String),
+})).annotate({
+    identifier: "ApiTokenResponse",
+});
+export const ApiResponseTokenListDataTokensList = /*@__PURE__*/ S.Array(ApiTokenResponse);
+export const ApiResponseTokenListData = /*@__PURE__*/ S.suspend(() => S.Struct({
+    tokens: S.optional(ApiResponseTokenListDataTokensList),
+})).annotate({
+    identifier: "ApiResponseTokenListData",
+});
+export const ApiResponseTokenList = /*@__PURE__*/ S.suspend(() => S.Struct({
+    success: S.Boolean,
+    data: ApiResponseTokenListData,
+})).annotate({
+    identifier: "ApiResponseTokenList",
+});
+export const ListDisksRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    limit: S.optional(S.Number.pipe(T.Query())),
+    cursor: S.optional(S.String.pipe(T.Query())),
+    name: S.optional(S.String.pipe(T.Query())),
+}).pipe(T.Http({ method: "GET", uri: "/api/disks", code: 200 }))).annotate({
+    identifier: "ListDisksRequest",
+});
+export const ApiResponseDiskListDataList = /*@__PURE__*/ S.Array(DiskResponse);
+export const ApiResponseDiskList = /*@__PURE__*/ S.suspend(() => S.Struct({
+    success: S.Boolean,
+    data: ApiResponseDiskListDataList,
+})).annotate({
+    identifier: "ApiResponseDiskList",
+});
+export const ListSandboxesRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    filesystem: S.optional(S.String.pipe(T.Query())),
+}).pipe(T.Http({ method: "GET", uri: "/api/sandboxes", code: 200 }))).annotate({
+    identifier: "ListSandboxesRequest",
+});
+export const ApiResponseSandboxListDataSandboxesList = /*@__PURE__*/ S.Array(Sandbox);
+export const ApiResponseSandboxListData = /*@__PURE__*/ S.suspend(() => S.Struct({
+    sandboxes: S.optional(ApiResponseSandboxListDataSandboxesList),
+})).annotate({
+    identifier: "ApiResponseSandboxListData",
+});
+export const ApiResponseSandboxList = /*@__PURE__*/ S.suspend(() => S.Struct({
+    success: S.Boolean,
+    data: ApiResponseSandboxListData,
+})).annotate({
+    identifier: "ApiResponseSandboxList",
+});
+export const PauseSandboxRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    sid: S.String.pipe(T.Label()),
+}).pipe(T.Http({ method: "POST", uri: "/api/sandboxes/{sid}/pause", code: 200 }))).annotate({
+    identifier: "PauseSandboxRequest",
+});
+export const RemoveDiskUserRequestUserType = /*@__PURE__*/ S.String;
+export const RemoveDiskUserRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    id: S.String.pipe(T.Label()),
+    userType: RemoveDiskUserRequestUserType.pipe(T.Label()),
+    identifier: S.optional(S.String.pipe(T.Query())),
+    principal: S.optional(S.String.pipe(T.Query())),
+}).pipe(T.Http({
+    method: "DELETE",
+    uri: "/api/disks/{id}/users/{userType}",
+    code: 200,
+}))).annotate({
+    identifier: "RemoveDiskUserRequest",
+});
+export const ResumeSandboxRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    sid: S.String.pipe(T.Label()),
+    wait: S.optional(S.Boolean.pipe(T.Query())),
+}).pipe(T.Http({ method: "POST", uri: "/api/sandboxes/{sid}/resume", code: 200 }))).annotate({
+    identifier: "ResumeSandboxRequest",
+});
+export const StartSandboxRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    sid: S.String.pipe(T.Label()),
+    wait: S.optional(S.Boolean.pipe(T.Query())),
+}).pipe(T.Http({ method: "POST", uri: "/api/sandboxes/{sid}/start", code: 200 }))).annotate({
+    identifier: "StartSandboxRequest",
+});
+export const StopSandboxRequest = /*@__PURE__*/ S.suspend(() => S.Struct({
+    sid: S.String.pipe(T.Label()),
+}).pipe(T.Http({ method: "POST", uri: "/api/sandboxes/{sid}/stop", code: 200 }))).annotate({
+    identifier: "StopSandboxRequest",
+});
+/** 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 const addDiskUser = /*@__PURE__*/ API.make(() => ({
+    input: AddDiskUserRequest,
+    output: ApiResponseAuthorizedUser,
+    errors: [BadRequest, UnknownArchilError],
+    protocol: ArchilProtocol,
+    retry: Retry.Retry,
+}));
+/** Create API token Creates a new API token for programmatic access. The full token value is only returned once at creation time. */
+export const createApiToken = /*@__PURE__*/ API.make(() => ({
+    input: CreateApiTokenRequest,
+    output: ApiResponseTokenCreated,
+    errors: [BadRequest, UnknownArchilError],
+    protocol: ArchilProtocol,
+    retry: Retry.Retry,
+}));
+/** 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 const createDisk = /*@__PURE__*/ API.make(() => ({
+    input: CreateDiskRequest,
+    output: ApiResponseCreateDisk,
+    errors: [BadRequest, Forbidden, Conflict, UnknownArchilError],
+    protocol: ArchilProtocol,
+    retry: Retry.Retry,
+}));
+/** 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 const createSandbox = /*@__PURE__*/ API.make(() => ({
+    input: CreateSandboxRequest,
+    output: CreateSandboxResponse,
+    errors: [BadRequest, Conflict, UnknownArchilError],
+    protocol: ArchilProtocol,
+    retry: Retry.Retry,
+}));
+/** 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 const createSandboxConnection = /*@__PURE__*/ API.make(() => ({
+    input: CreateSandboxConnectionRequest,
+    output: ApiResponseSandboxConnection,
+    errors: [NotFound, Conflict, UnknownArchilError],
+    protocol: ArchilProtocol,
+    retry: Retry.Retry,
+}));
+/** 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 const createShareUrl = /*@__PURE__*/ API.make(() => ({
+    input: CreateShareUrlRequest,
+    output: ApiResponseShareUrl,
+    errors: [BadRequest, NotFound, UnknownArchilError],
+    protocol: ArchilProtocol,
+    retry: Retry.Retry,
+}));
+/** Delete a disk Deletes a disk and all associated resources. */
+export const deleteDisk = /*@__PURE__*/ API.make(() => ({
+    input: DeleteDiskRequest,
+    output: ApiResponseEmpty,
+    errors: [BadRequest, NotFound, UnknownArchilError],
+    protocol: ArchilProtocol,
+    retry: Retry.Retry,
+}));
+/** 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 const deleteSandbox = /*@__PURE__*/ API.make(() => ({
+    input: DeleteSandboxRequest,
+    output: DeleteSandboxResponse,
+    errors: [NotFound, Conflict, UnknownArchilError],
+    protocol: ArchilProtocol,
+    retry: Retry.Retry,
+}));
+/** Delete API token Revokes and deletes an API token. */
+export const deleteToken = /*@__PURE__*/ API.make(() => ({
+    input: DeleteTokenRequest,
+    output: ApiResponseMessage,
+    errors: [NotFound, UnknownArchilError],
+    protocol: ArchilProtocol,
+    retry: Retry.Retry,
+}));
+/** 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 const exec = /*@__PURE__*/ API.make(() => ({
+    input: ExecRequest,
+    output: ApiResponseExec,
+    errors: [BadRequest, NotFound, UnknownArchilError],
+    protocol: ArchilProtocol,
+    retry: Retry.Retry,
+}));
+/** 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 const execDisk = /*@__PURE__*/ API.make(() => ({
+    input: ExecDiskRequest,
+    output: ApiResponseExecDisk,
+    errors: [BadRequest, NotFound, UnknownArchilError],
+    protocol: ArchilProtocol,
+    retry: Retry.Retry,
+}));
+/** 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 const forkSandbox = /*@__PURE__*/ API.make(() => ({
+    input: ForkSandboxRequest,
+    output: ForkSandboxResponse,
+    errors: [BadRequest, NotFound, Conflict, UnknownArchilError],
+    protocol: ArchilProtocol,
+    retry: Retry.Retry,
+}));
+/** Get disk details Returns detailed information about a specific disk. */
+export const getDisk = /*@__PURE__*/ API.make(() => ({
+    input: GetDiskRequest,
+    output: ApiResponseDisk,
+    errors: [BadRequest, NotFound, UnknownArchilError],
+    protocol: ArchilProtocol,
+    retry: Retry.Retry,
+}));
+/** Get a sandbox */
+export const getSandbox = /*@__PURE__*/ API.make(() => ({
+    input: GetSandboxRequest,
+    output: ApiResponseSandbox,
+    errors: [NotFound, UnknownArchilError],
+    protocol: ArchilProtocol,
+    retry: Retry.Retry,
+}));
+/** 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 const grepDisk = /*@__PURE__*/ API.make(() => ({
+    input: GrepDiskRequest,
+    output: ApiResponseGrepDisk,
+    errors: [BadRequest, NotFound, UnknownArchilError],
+    protocol: ArchilProtocol,
+    retry: Retry.Retry,
+}));
+/** List API tokens Returns all API tokens for the authenticated account. */
+export const listApiTokens = /*@__PURE__*/ API.make(() => ({
+    input: ListApiTokensRequest,
+    output: ApiResponseTokenList,
+    errors: [UnknownArchilError],
+    protocol: ArchilProtocol,
+    retry: Retry.Retry,
+}));
+/** List all disks Returns all disks owned by the authenticated account. */
+export const listDisks = /*@__PURE__*/ API.make(() => ({
+    input: ListDisksRequest,
+    output: ApiResponseDiskList,
+    errors: [UnknownArchilError],
+    protocol: ArchilProtocol,
+    retry: Retry.Retry,
+}));
+/** List sandboxes All the account's sandboxes, oldest first. */
+export const listSandboxes = /*@__PURE__*/ API.make(() => ({
+    input: ListSandboxesRequest,
+    output: ApiResponseSandboxList,
+    errors: [BadRequest, UnknownArchilError],
+    protocol: ArchilProtocol,
+    retry: Retry.Retry,
+}));
+/** 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 const pauseSandbox = /*@__PURE__*/ API.make(() => ({
+    input: PauseSandboxRequest,
+    output: ApiResponseSandbox,
+    errors: [BadRequest, NotFound, Conflict, UnknownArchilError],
+    protocol: ArchilProtocol,
+    retry: Retry.Retry,
+}));
+/** Remove user from disk Removes an authorized user from a disk. */
+export const removeDiskUser = /*@__PURE__*/ API.make(() => ({
+    input: RemoveDiskUserRequest,
+    output: ApiResponseMessage,
+    errors: [BadRequest, UnknownArchilError],
+    protocol: ArchilProtocol,
+    retry: Retry.Retry,
+}));
+/** 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 const resumeSandbox = /*@__PURE__*/ API.make(() => ({
+    input: ResumeSandboxRequest,
+    output: ApiResponseSandbox,
+    errors: [BadRequest, NotFound, Conflict, UnknownArchilError],
+    protocol: ArchilProtocol,
+    retry: Retry.Retry,
+}));
+/** 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 const startSandbox = /*@__PURE__*/ API.make(() => ({
+    input: StartSandboxRequest,
+    output: ApiResponseSandbox,
+    errors: [BadRequest, NotFound, Conflict, UnknownArchilError],
+    protocol: ArchilProtocol,
+    retry: Retry.Retry,
+}));
+/** 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 const stopSandbox = /*@__PURE__*/ API.make(() => ({
+    input: StopSandboxRequest,
+    output: ApiResponseSandbox,
+    errors: [BadRequest, NotFound, Conflict, UnknownArchilError],
+    protocol: ArchilProtocol,
+    retry: Retry.Retry,
+}));
+//# sourceMappingURL=archil.js.map