@distilled.cloud/daytona 0.0.0-placeholder → 1.0.0-rc.13

package/src/services/sandbox.ts

@@ -0,0 +1,3158 @@
+// AUTO-GENERATED by scripts/generate.ts from .generated-specs (specs/spec-mirror-daytona/specs/{openapi,toolbox-openapi,analytics-openapi}.json). Do not edit.
+import * as S from "@distilled.cloud/core/schema";
+import * as API from "@distilled.cloud/core/api";
+import * as T from "../traits.ts";
+import {
+  DaytonaProtocol,
+  type DaytonaOpError,
+  type DaytonaOpContext,
+} from "../protocol.ts";
+import { UnknownDaytonaError } from "../errors.ts";
+import * as Retry from "../retry.ts";
+
+export type { DaytonaOpError, DaytonaOpContext };
+
+export interface ArchiveSandboxRequest {
+  sandboxIdOrName: string;
+  /** Use with JWT to specify the organization ID */
+  xDaytonaOrganizationID?: string;
+}
+export const ArchiveSandboxRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    sandboxIdOrName: S.String.pipe(T.Label()),
+    xDaytonaOrganizationID: S.optional(
+      S.String.pipe(T.Header("X-Daytona-Organization-ID")),
+    ),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/sandbox/{sandboxIdOrName}/archive",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "ArchiveSandboxRequest",
+}) as any as S.Schema<ArchiveSandboxRequest>;
+
+/** Environment variables for the sandbox */
+export type SandboxEnvMap = { [key: string]: string | undefined };
+export const SandboxEnvMap = /*@__PURE__*/ S.Record(
+  S.String,
+  S.String,
+) as any as S.Schema<SandboxEnvMap>;
+
+/** Labels for the sandbox */
+export type SandboxLabelsMap = { [key: string]: string | undefined };
+export const SandboxLabelsMap = /*@__PURE__*/ S.Record(
+  S.String,
+  S.String,
+) as any as S.Schema<SandboxLabelsMap>;
+
+export type GpuType =
+  | "H100"
+  | "H200"
+  | "RTX-PRO-6000"
+  | "RTX-4090"
+  | "RTX-5090"
+  | "MI355X";
+export const GpuType = S.String;
+
+export type SandboxState =
+  | "creating"
+  | "restoring"
+  | "destroyed"
+  | "destroying"
+  | "started"
+  | "stopped"
+  | "starting"
+  | "stopping"
+  | "error"
+  | "build_failed"
+  | "pending_build"
+  | "building_snapshot"
+  | "unknown"
+  | "pulling_snapshot"
+  | "archived"
+  | "archiving"
+  | "resizing"
+  | "snapshotting"
+  | "forking"
+  | "pausing"
+  | "paused"
+  | "resuming";
+export const SandboxState = S.String;
+
+/** The desired state of the sandbox */
+export type SandboxDesiredState =
+  | "destroyed"
+  | "started"
+  | "stopped"
+  | "resized"
+  | "archived"
+  | "paused";
+export const SandboxDesiredState = S.String;
+
+/** The state of the backup */
+export type SandboxBackupState =
+  | "None"
+  | "Pending"
+  | "InProgress"
+  | "Completed"
+  | "Error";
+export const SandboxBackupState = S.String;
+
+export interface SandboxVolume {
+  /** The ID or name of the volume. Resolved to the volume ID on sandbox create. */
+  volumeId: string;
+  /** The mount path for the volume */
+  mountPath: string;
+  /** Optional subpath within the volume to mount. When specified, only this S3 prefix will be accessible. When omitted, the entire volume is mounted. */
+  subpath?: string;
+}
+export const SandboxVolume = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    volumeId: S.String,
+    mountPath: S.String,
+    subpath: S.optional(S.String),
+  }),
+).annotate({ identifier: "SandboxVolume" }) as any as S.Schema<SandboxVolume>;
+
+/** Array of volumes attached to the sandbox */
+export type SandboxVolumesList = Array<SandboxVolume>;
+export const SandboxVolumesList = /*@__PURE__*/ S.Array(
+  SandboxVolume,
+) as any as S.Schema<SandboxVolumesList>;
+
+/** The context hashes used for the build */
+export type BuildInfoContextHashesList = Array<string>;
+export const BuildInfoContextHashesList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<BuildInfoContextHashesList>;
+
+export interface BuildInfo {
+  /** The Dockerfile content used for the build */
+  dockerfileContent?: string;
+  /** The context hashes used for the build */
+  contextHashes?: BuildInfoContextHashesList;
+  /** The creation timestamp */
+  createdAt: string;
+  /** The last update timestamp */
+  updatedAt: string;
+  /** The snapshot reference */
+  snapshotRef: string;
+}
+export const BuildInfo = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    dockerfileContent: S.optional(S.String),
+    contextHashes: S.optional(BuildInfoContextHashesList),
+    createdAt: S.String,
+    updatedAt: S.String,
+    snapshotRef: S.String,
+  }),
+).annotate({ identifier: "BuildInfo" }) as any as S.Schema<BuildInfo>;
+
+/** The class of the sandbox */
+export type SandboxSandboxClass =
+  | "linux-vm"
+  | "container"
+  | "android"
+  | "windows";
+export const SandboxSandboxClass = S.String;
+
+export interface Sandbox2 {
+  /** The ID of the sandbox */
+  id: string;
+  /** The organization ID of the sandbox */
+  organizationId: string;
+  /** The name of the sandbox */
+  name: string;
+  /** The snapshot used for the sandbox */
+  snapshot?: string;
+  /** The user associated with the project */
+  user: string;
+  /** Environment variables for the sandbox */
+  env: SandboxEnvMap;
+  /** Labels for the sandbox */
+  labels: SandboxLabelsMap;
+  /** Whether the sandbox http preview is public */
+  public: boolean;
+  /** Whether to block all network access for the sandbox */
+  networkBlockAll: boolean;
+  /** Comma-separated list of allowed CIDR network addresses for the sandbox */
+  networkAllowList?: string;
+  /** Comma-separated list of allowed domains for the sandbox */
+  domainAllowList?: string;
+  /** Outbound proxy URL the sandbox HTTP(S) traffic is routed through. Applied via the HTTP(S)_PROXY environment variables (convenience routing); network-layer enforcement applies only when the sandbox also has a domainAllowList. Only returned on single-sandbox reads — never on list responses. */
+  outboundProxyUrl?: string;
+  /** OTel collector endpoint override for this sandbox. When set, sandbox OTel data is sent to this endpoint instead of the default collector and is not available in the Daytona analytics API or dashboard. Only returned on single-sandbox reads — never on list responses. */
+  otelEndpointOverride?: string;
+  /** The target environment for the sandbox */
+  target: string;
+  /** The CPU quota for the sandbox */
+  cpu: number;
+  /** The GPU quota for the sandbox */
+  gpu: number;
+  /** Whether this is a spot GPU sandbox. Spot sandboxes may be instantly terminated to free capacity for on-demand GPU sandboxes. Absent on APIs that predate this field; treat as false. */
+  spot?: boolean;
+  /** When this sandbox was destroyed by spot preemption. Set only for spot-evicted sandboxes, which stay retrievable by ID for 24 hours after eviction. */
+  spotEvictedAt?: string;
+  /** The GPU type assigned to the sandbox */
+  gpuType?: GpuType;
+  /** The memory quota for the sandbox */
+  memory: number;
+  /** The disk quota for the sandbox */
+  disk: number;
+  /** The state of the sandbox */
+  state?: SandboxState;
+  /** The desired state of the sandbox */
+  desiredState?: SandboxDesiredState;
+  /** The error reason of the sandbox */
+  errorReason?: string;
+  /** Whether the sandbox error is recoverable. */
+  recoverable?: boolean;
+  /** Id of the warm pool this sandbox waits in; set only while it is an unclaimed member. */
+  warmPoolId?: string;
+  /** The state of the backup */
+  backupState?: SandboxBackupState;
+  /** The creation timestamp of the last backup */
+  backupCreatedAt?: string;
+  /** Auto-stop interval in minutes (0 means disabled) */
+  autoStopInterval?: number;
+  /** Auto-pause interval in minutes (0 means disabled) */
+  autoPauseInterval?: number;
+  /** Auto-archive interval in minutes */
+  autoArchiveInterval?: number;
+  /** Auto-delete interval in minutes (negative value means disabled, 0 means delete immediately upon stopping) */
+  autoDeleteInterval?: number;
+  /** When the sandbox will be automatically destroyed, regardless of its state (only set when a TTL is configured) */
+  autoDestroyAt?: string;
+  /** Array of volumes attached to the sandbox */
+  volumes?: SandboxVolumesList;
+  /** Build information for the sandbox */
+  buildInfo?: BuildInfo;
+  /** The creation timestamp of the sandbox */
+  createdAt?: string;
+  /** The last update timestamp of the sandbox */
+  updatedAt?: string;
+  /** The last activity timestamp of the sandbox */
+  lastActivityAt?: string;
+  /** The class of the sandbox */
+  sandboxClass?: SandboxSandboxClass;
+  /** The version of the daemon running in the sandbox */
+  daemonVersion?: string;
+  /** The runner ID of the sandbox */
+  runnerId?: string;
+  /** ID of the sandbox this sandbox is linked to. When set, the sandbox is co-located on the same runner as the linked sandbox. */
+  linkedSandboxId?: string;
+  /** The toolbox proxy URL for the sandbox */
+  toolboxProxyUrl: string;
+}
+export const Sandbox2 = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.String,
+    organizationId: S.String,
+    name: S.String,
+    snapshot: S.optional(S.String),
+    user: S.String,
+    env: SandboxEnvMap,
+    labels: SandboxLabelsMap,
+    public: S.Boolean,
+    networkBlockAll: S.Boolean,
+    networkAllowList: S.optional(S.String),
+    domainAllowList: S.optional(S.String),
+    outboundProxyUrl: S.optional(S.String),
+    otelEndpointOverride: S.optional(S.String),
+    target: S.String,
+    cpu: S.Number,
+    gpu: S.Number,
+    spot: S.optional(S.Boolean),
+    spotEvictedAt: S.optional(S.String),
+    gpuType: S.optional(GpuType),
+    memory: S.Number,
+    disk: S.Number,
+    state: S.optional(SandboxState),
+    desiredState: S.optional(SandboxDesiredState),
+    errorReason: S.optional(S.String),
+    recoverable: S.optional(S.Boolean),
+    warmPoolId: S.optional(S.String),
+    backupState: S.optional(SandboxBackupState),
+    backupCreatedAt: S.optional(S.String),
+    autoStopInterval: S.optional(S.Number),
+    autoPauseInterval: S.optional(S.Number),
+    autoArchiveInterval: S.optional(S.Number),
+    autoDeleteInterval: S.optional(S.Number),
+    autoDestroyAt: S.optional(S.String),
+    volumes: S.optional(SandboxVolumesList),
+    buildInfo: S.optional(BuildInfo),
+    createdAt: S.optional(S.String),
+    updatedAt: S.optional(S.String),
+    lastActivityAt: S.optional(S.String),
+    sandboxClass: S.optional(SandboxSandboxClass),
+    daemonVersion: S.optional(S.String),
+    runnerId: S.optional(S.String),
+    linkedSandboxId: S.optional(S.String),
+    toolboxProxyUrl: S.String,
+  }),
+).annotate({ identifier: "Sandbox2" }) as any as S.Schema<Sandbox2>;
+
+/** Environment variables for the sandbox */
+export type CreateSandboxRequestEnvMap = { [key: string]: string | undefined };
+export const CreateSandboxRequestEnvMap = /*@__PURE__*/ S.Record(
+  S.String,
+  S.String,
+) as any as S.Schema<CreateSandboxRequestEnvMap>;
+
+/** Labels for the sandbox */
+export type CreateSandboxRequestLabelsMap = {
+  [key: string]: string | undefined;
+};
+export const CreateSandboxRequestLabelsMap = /*@__PURE__*/ S.Record(
+  S.String,
+  S.String,
+) as any as S.Schema<CreateSandboxRequestLabelsMap>;
+
+/** Preferred GPU type for the sandbox. Accepts a single value or an ordered preference list — the scheduler tries each in order and pins the sandbox to the first that has capacity. */
+export type CreateSandboxRequestGpuTypeList = Array<GpuType | (string & {})>;
+export const CreateSandboxRequestGpuTypeList = /*@__PURE__*/ S.Array(
+  GpuType,
+) as any as S.Schema<CreateSandboxRequestGpuTypeList>;
+
+/** Array of volumes to attach to the sandbox */
+export type CreateSandboxRequestVolumesList = Array<SandboxVolume>;
+export const CreateSandboxRequestVolumesList = /*@__PURE__*/ S.Array(
+  SandboxVolume,
+) as any as S.Schema<CreateSandboxRequestVolumesList>;
+
+/** The context hashes used for the build */
+export type CreateBuildInfoContextHashesList = Array<string>;
+export const CreateBuildInfoContextHashesList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<CreateBuildInfoContextHashesList>;
+
+export interface CreateBuildInfo {
+  /** The Dockerfile content used for the build */
+  dockerfileContent: string;
+  /** The context hashes used for the build */
+  contextHashes?: CreateBuildInfoContextHashesList;
+}
+export const CreateBuildInfo = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    dockerfileContent: S.String,
+    contextHashes: S.optional(CreateBuildInfoContextHashesList),
+  }),
+).annotate({
+  identifier: "CreateBuildInfo",
+}) as any as S.Schema<CreateBuildInfo>;
+
+export type CreateSandboxRequestSecretsItemMap = {
+  [key: string]: string | undefined;
+};
+export const CreateSandboxRequestSecretsItemMap = /*@__PURE__*/ S.Record(
+  S.String,
+  S.String,
+) as any as S.Schema<CreateSandboxRequestSecretsItemMap>;
+
+/** Secrets to mount in this sandbox. Each entry maps an env var name to a vault secret name. */
+export type CreateSandboxRequestSecretsList =
+  Array<CreateSandboxRequestSecretsItemMap>;
+export const CreateSandboxRequestSecretsList = /*@__PURE__*/ S.Array(
+  CreateSandboxRequestSecretsItemMap,
+) as any as S.Schema<CreateSandboxRequestSecretsList>;
+
+export interface CreateSandboxRequest {
+  /** Use with JWT to specify the organization ID */
+  xDaytonaOrganizationID?: string;
+  /** The name of the sandbox. If not provided, the sandbox ID will be used as the name */
+  name?: string;
+  /** The ID or name of the snapshot used for the sandbox */
+  snapshot?: string;
+  /** The user associated with the project */
+  user?: string;
+  /** Environment variables for the sandbox */
+  env?: CreateSandboxRequestEnvMap;
+  /** Labels for the sandbox */
+  labels?: CreateSandboxRequestLabelsMap;
+  /** Whether the sandbox http preview is publicly accessible */
+  public?: boolean;
+  /** Whether to block all network access for the sandbox */
+  networkBlockAll?: boolean;
+  /** Comma-separated list of allowed CIDR network addresses for the sandbox */
+  networkAllowList?: string;
+  /** Comma-separated list of allowed domains for the sandbox */
+  domainAllowList?: string;
+  /** Outbound proxy URL to route the sandbox HTTP(S) traffic through (http or https; credentials may be included in the URL). On its own this is convenience routing, not a security boundary: it is applied by injecting the standard HTTP(S)_PROXY environment variables at creation, so a process that clears those variables egresses directly. Combine with domainAllowList to have web-port (80/443) egress transparently redirected through the proxy chain at the network layer, which cannot be bypassed from inside the sandbox. */
+  outboundProxyUrl?: string;
+  /** OTel collector endpoint override for this sandbox. When set, sandbox OTel data is sent to this endpoint instead of the default collector (the Daytona-hosted collector or the region-configured endpoint) and will not be available in the Daytona analytics API or dashboard. */
+  otelEndpointOverride?: string;
+  /** The target (region) where the sandbox will be created */
+  target?: string;
+  /** CPU cores allocated to the sandbox */
+  cpu?: number;
+  /** GPU units allocated to the sandbox */
+  gpu?: number;
+  /** Preferred GPU type for the sandbox. Accepts a single value or an ordered preference list — the scheduler tries each in order and pins the sandbox to the first that has capacity. */
+  gpuType?: CreateSandboxRequestGpuTypeList;
+  /** GPU-only. When true, the sandbox may be instantly terminated without notice to free GPU capacity for an on-demand (non-spot) GPU sandbox. Ignored / rejected when the sandbox requests no GPUs. */
+  spot?: boolean;
+  /** Memory allocated to the sandbox in GB */
+  memory?: number;
+  /** Disk space allocated to the sandbox in GB */
+  disk?: number;
+  /** Auto-stop interval in minutes (0 means disabled) */
+  autoStopInterval?: number;
+  /** Auto-pause interval in minutes (0 means disabled). Only supported for sandbox classes that support pausing. Not allowed for ephemeral sandboxes. At most one of autoStopInterval and autoPauseInterval may be non-zero. For non-ephemeral sandbox classes that support pausing, defaults to 60 minutes (with auto-stop disabled) when neither interval is provided. */
+  autoPauseInterval?: number;
+  /** Auto-archive interval in minutes (0 means the maximum interval will be used) */
+  autoArchiveInterval?: number;
+  /** Auto-delete interval in minutes (negative value means disabled, 0 means delete immediately upon stopping) */
+  autoDeleteInterval?: number;
+  /** Maximum time to live in minutes, counted as wall-clock time since creation regardless of sandbox state (0 means disabled). When it elapses the sandbox is destroyed, even if it is stopped, paused, or archived. Subject to the maximum sandbox lifespan configured for the organization region and sandbox class, in which case it also defaults to that maximum and cannot be disabled. */
+  ttlMinutes?: number;
+  /** Array of volumes to attach to the sandbox */
+  volumes?: CreateSandboxRequestVolumesList;
+  /** Build information for the sandbox */
+  buildInfo?: CreateBuildInfo;
+  /** ID or name of an existing sandbox to link the new sandbox to. The new sandbox will be scheduled on the same runner as the linked sandbox so a local network can be established between them. Linked sandboxes must be ephemeral (autoDeleteInterval=0) and cannot themselves be linked to another sandbox. GPU sandboxes cannot participate in links in either direction: a GPU sandbox cannot specify linkedSandbox, and cannot be the link target of another sandbox. */
+  linkedSandbox?: string;
+  /** Secrets to mount in this sandbox. Each entry maps an env var name to a vault secret name. */
+  secrets?: CreateSandboxRequestSecretsList;
+}
+export const CreateSandboxRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    xDaytonaOrganizationID: S.optional(
+      S.String.pipe(T.Header("X-Daytona-Organization-ID")),
+    ),
+    name: S.optional(S.String),
+    snapshot: S.optional(S.String),
+    user: S.optional(S.String),
+    env: S.optional(CreateSandboxRequestEnvMap),
+    labels: S.optional(CreateSandboxRequestLabelsMap),
+    public: S.optional(S.Boolean),
+    networkBlockAll: S.optional(S.Boolean),
+    networkAllowList: S.optional(S.String),
+    domainAllowList: S.optional(S.String),
+    outboundProxyUrl: S.optional(S.String),
+    otelEndpointOverride: S.optional(S.String),
+    target: S.optional(S.String),
+    cpu: S.optional(S.Number),
+    gpu: S.optional(S.Number),
+    gpuType: S.optional(CreateSandboxRequestGpuTypeList),
+    spot: S.optional(S.Boolean),
+    memory: S.optional(S.Number),
+    disk: S.optional(S.Number),
+    autoStopInterval: S.optional(S.Number),
+    autoPauseInterval: S.optional(S.Number),
+    autoArchiveInterval: S.optional(S.Number),
+    autoDeleteInterval: S.optional(S.Number),
+    ttlMinutes: S.optional(S.Number),
+    volumes: S.optional(CreateSandboxRequestVolumesList),
+    buildInfo: S.optional(CreateBuildInfo),
+    linkedSandbox: S.optional(S.String),
+    secrets: S.optional(CreateSandboxRequestSecretsList),
+  }).pipe(T.Http({ method: "POST", uri: "/sandbox", code: 200 })),
+).annotate({
+  identifier: "CreateSandboxRequest",
+}) as any as S.Schema<CreateSandboxRequest>;
+
+export interface CreateSandboxSnapshotRequest {
+  sandboxIdOrName: string;
+  /** Use with JWT to specify the organization ID */
+  xDaytonaOrganizationID?: string;
+  /** Name for the new snapshot */
+  name: string;
+  /** Include the VM's memory in the snapshot. VM sandboxes only. When true the sandbox must be STARTED; when false (default) VM sandboxes must be STOPPED. Container sandboxes do not support memory snapshots. */
+  includeMemory?: boolean;
+}
+export const CreateSandboxSnapshotRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    sandboxIdOrName: S.String.pipe(T.Label()),
+    xDaytonaOrganizationID: S.optional(
+      S.String.pipe(T.Header("X-Daytona-Organization-ID")),
+    ),
+    name: S.String,
+    includeMemory: S.optional(S.Boolean),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/sandbox/{sandboxIdOrName}/snapshot",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "CreateSandboxSnapshotRequest",
+}) as any as S.Schema<CreateSandboxSnapshotRequest>;
+
+export interface CreateSshAccessRequest {
+  /** ID or name of the sandbox */
+  sandboxIdOrName: string;
+  /** Expiration time in minutes (default: 60) */
+  expiresInMinutes?: number;
+  /** Use with JWT to specify the organization ID */
+  xDaytonaOrganizationID?: string;
+}
+export const CreateSshAccessRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    sandboxIdOrName: S.String.pipe(T.Label()),
+    expiresInMinutes: S.optional(S.Number.pipe(T.Query())),
+    xDaytonaOrganizationID: S.optional(
+      S.String.pipe(T.Header("X-Daytona-Organization-ID")),
+    ),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/sandbox/{sandboxIdOrName}/ssh-access",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "CreateSshAccessRequest",
+}) as any as S.Schema<CreateSshAccessRequest>;
+
+export interface SshAccessDto {
+  /** Unique identifier for the SSH access */
+  id: string;
+  /** ID of the sandbox this SSH access is for */
+  sandboxId: string;
+  /** SSH access token */
+  token: string;
+  /** When the SSH access expires */
+  expiresAt: string;
+  /** When the SSH access was created */
+  createdAt: string;
+  /** When the SSH access was last updated */
+  updatedAt: string;
+  /** SSH command to connect to the sandbox */
+  sshCommand: string;
+}
+export const SshAccessDto = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.String,
+    sandboxId: S.String,
+    token: S.String,
+    expiresAt: S.String,
+    createdAt: S.String,
+    updatedAt: S.String,
+    sshCommand: S.String,
+  }),
+).annotate({ identifier: "SshAccessDto" }) as any as S.Schema<SshAccessDto>;
+
+export interface DeleteSandboxRequest {
+  /** ID or name of the sandbox */
+  sandboxIdOrName: string;
+  /** Use with JWT to specify the organization ID */
+  xDaytonaOrganizationID?: string;
+}
+export const DeleteSandboxRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    sandboxIdOrName: S.String.pipe(T.Label()),
+    xDaytonaOrganizationID: S.optional(
+      S.String.pipe(T.Header("X-Daytona-Organization-ID")),
+    ),
+  }).pipe(
+    T.Http({ method: "DELETE", uri: "/sandbox/{sandboxIdOrName}", code: 200 }),
+  ),
+).annotate({
+  identifier: "DeleteSandboxRequest",
+}) as any as S.Schema<DeleteSandboxRequest>;
+
+export interface ExpireSignedPortPreviewUrlRequest {
+  /** ID or name of the sandbox */
+  sandboxIdOrName: string;
+  /** Port number to expire signed preview URL for */
+  port: number;
+  /** Token to expire signed preview URL for */
+  token: string;
+  /** Use with JWT to specify the organization ID */
+  xDaytonaOrganizationID?: string;
+}
+export const ExpireSignedPortPreviewUrlRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    sandboxIdOrName: S.String.pipe(T.Label()),
+    port: S.Number.pipe(T.Label()),
+    token: S.String.pipe(T.Label()),
+    xDaytonaOrganizationID: S.optional(
+      S.String.pipe(T.Header("X-Daytona-Organization-ID")),
+    ),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/sandbox/{sandboxIdOrName}/ports/{port}/signed-preview-url/{token}/expire",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "ExpireSignedPortPreviewUrlRequest",
+}) as any as S.Schema<ExpireSignedPortPreviewUrlRequest>;
+
+export interface ExpireSignedPortPreviewUrlResponse {}
+export const ExpireSignedPortPreviewUrlResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "ExpireSignedPortPreviewUrlResponse",
+}) as any as S.Schema<ExpireSignedPortPreviewUrlResponse>;
+
+export interface ForkSandboxRequest {
+  sandboxIdOrName: string;
+  /** Use with JWT to specify the organization ID */
+  xDaytonaOrganizationID?: string;
+  /** The name for the forked sandbox. If not provided, a unique name will be generated. */
+  name?: string;
+}
+export const ForkSandboxRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    sandboxIdOrName: S.String.pipe(T.Label()),
+    xDaytonaOrganizationID: S.optional(
+      S.String.pipe(T.Header("X-Daytona-Organization-ID")),
+    ),
+    name: S.optional(S.String),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/sandbox/{sandboxIdOrName}/fork",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "ForkSandboxRequest",
+}) as any as S.Schema<ForkSandboxRequest>;
+
+export interface GetBuildLogsUrlRequest {
+  /** ID or name of the sandbox */
+  sandboxIdOrName: string;
+  /** Use with JWT to specify the organization ID */
+  xDaytonaOrganizationID?: string;
+}
+export const GetBuildLogsUrlRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    sandboxIdOrName: S.String.pipe(T.Label()),
+    xDaytonaOrganizationID: S.optional(
+      S.String.pipe(T.Header("X-Daytona-Organization-ID")),
+    ),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/sandbox/{sandboxIdOrName}/build-logs-url",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetBuildLogsUrlRequest",
+}) as any as S.Schema<GetBuildLogsUrlRequest>;
+
+export interface Url {
+  /** URL response */
+  url: string;
+}
+export const Url = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    url: S.String,
+  }),
+).annotate({ identifier: "Url" }) as any as S.Schema<Url>;
+
+export interface GetOrganizationBySandboxIdRequest {
+  /** ID of the sandbox */
+  sandboxId: string;
+  /** Use with JWT to specify the organization ID */
+  xDaytonaOrganizationID?: string;
+}
+export const GetOrganizationBySandboxIdRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    sandboxId: S.String.pipe(T.Label()),
+    xDaytonaOrganizationID: S.optional(
+      S.String.pipe(T.Header("X-Daytona-Organization-ID")),
+    ),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/sandbox/{sandboxId}/organization",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetOrganizationBySandboxIdRequest",
+}) as any as S.Schema<GetOrganizationBySandboxIdRequest>;
+
+/** Headers */
+export type OtelConfigHeadersMap = { [key: string]: string | undefined };
+export const OtelConfigHeadersMap = /*@__PURE__*/ S.Record(
+  S.String,
+  S.String,
+) as any as S.Schema<OtelConfigHeadersMap>;
+
+export interface OtelConfig {
+  /** Endpoint */
+  endpoint: string;
+  /** Headers */
+  headers?: OtelConfigHeadersMap | null;
+  /** Organization ID the config belongs to */
+  organizationId?: string;
+}
+export const OtelConfig = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    endpoint: S.String,
+    headers: S.optional(S.NullOr(OtelConfigHeadersMap)),
+    organizationId: S.optional(S.String),
+  }),
+).annotate({ identifier: "OtelConfig" }) as any as S.Schema<OtelConfig>;
+
+export interface Organization {
+  /** Organization ID */
+  id: string;
+  /** Organization name */
+  name: string;
+  /** User ID of the organization creator */
+  createdBy: string;
+  /** Personal organization flag */
+  personal: boolean;
+  /** Creation timestamp */
+  createdAt: string;
+  /** Last update timestamp */
+  updatedAt: string;
+  /** Suspended flag */
+  suspended: boolean;
+  /** Suspended at */
+  suspendedAt: string;
+  /** Suspended reason */
+  suspensionReason: string;
+  /** Suspended until */
+  suspendedUntil: string;
+  /** Suspension cleanup grace period hours */
+  suspensionCleanupGracePeriodHours: number;
+  /** Max CPU per sandbox */
+  maxCpuPerSandbox: number;
+  /** Max memory per sandbox */
+  maxMemoryPerSandbox: number;
+  /** Max disk per sandbox */
+  maxDiskPerSandbox: number;
+  /** Maximum number of secrets */
+  secretQuota: number;
+  /** Maximum number of secrets that can be mounted to a single sandbox */
+  maxSecretsPerSandbox: number;
+  /** Time in minutes before an unused snapshot is deactivated */
+  snapshotDeactivationTimeoutMinutes: number;
+  /** Sandbox default network block all */
+  sandboxLimitedNetworkEgress: boolean;
+  /** Whether the proxy shows the preview URL warning page for this organization */
+  previewWarningEnabled: boolean;
+  /** Whether this organization may configure SSO identity providers */
+  ssoEnabled: boolean;
+  /** Whether this organization may use SCIM directory sync */
+  scimEnabled: boolean;
+  /** Default region ID */
+  defaultRegionId?: string;
+  /** ID of the WorkOS organization mirrored from this organization (absent for personal organizations, which are never mirrored) */
+  workosOrgId?: string;
+  /** Authenticated rate limit per minute */
+  authenticatedRateLimit: number | null;
+  /** Sandbox create rate limit per minute */
+  sandboxCreateRateLimit: number | null;
+  /** Sandbox lifecycle rate limit per minute */
+  sandboxLifecycleRateLimit: number | null;
+  /** Experimental configuration */
+  experimentalConfig: unknown;
+  /** OpenTelemetry collection configuration */
+  otelConfig: OtelConfig | null;
+  /** Authenticated rate limit TTL in seconds */
+  authenticatedRateLimitTtlSeconds: number | null;
+  /** Sandbox create rate limit TTL in seconds */
+  sandboxCreateRateLimitTtlSeconds: number | null;
+  /** Sandbox lifecycle rate limit TTL in seconds */
+  sandboxLifecycleRateLimitTtlSeconds: number | null;
+}
+export const Organization = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.String,
+    name: S.String,
+    createdBy: S.String,
+    personal: S.Boolean,
+    createdAt: S.String,
+    updatedAt: S.String,
+    suspended: S.Boolean,
+    suspendedAt: S.String,
+    suspensionReason: S.String,
+    suspendedUntil: S.String,
+    suspensionCleanupGracePeriodHours: S.Number,
+    maxCpuPerSandbox: S.Number,
+    maxMemoryPerSandbox: S.Number,
+    maxDiskPerSandbox: S.Number,
+    secretQuota: S.Number,
+    maxSecretsPerSandbox: S.Number,
+    snapshotDeactivationTimeoutMinutes: S.Number,
+    sandboxLimitedNetworkEgress: S.Boolean,
+    previewWarningEnabled: S.Boolean,
+    ssoEnabled: S.Boolean,
+    scimEnabled: S.Boolean,
+    defaultRegionId: S.optional(S.String),
+    workosOrgId: S.optional(S.String),
+    authenticatedRateLimit: S.NullOr(S.Number),
+    sandboxCreateRateLimit: S.NullOr(S.Number),
+    sandboxLifecycleRateLimit: S.NullOr(S.Number),
+    experimentalConfig: S.Unknown,
+    otelConfig: S.NullOr(OtelConfig),
+    authenticatedRateLimitTtlSeconds: S.NullOr(S.Number),
+    sandboxCreateRateLimitTtlSeconds: S.NullOr(S.Number),
+    sandboxLifecycleRateLimitTtlSeconds: S.NullOr(S.Number),
+  }),
+).annotate({ identifier: "Organization" }) as any as S.Schema<Organization>;
+
+export interface GetPortPreviewUrlRequest {
+  /** ID or name of the sandbox */
+  sandboxIdOrName: string;
+  /** Port number to get preview URL for */
+  port: number;
+  /** Use with JWT to specify the organization ID */
+  xDaytonaOrganizationID?: string;
+}
+export const GetPortPreviewUrlRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    sandboxIdOrName: S.String.pipe(T.Label()),
+    port: S.Number.pipe(T.Label()),
+    xDaytonaOrganizationID: S.optional(
+      S.String.pipe(T.Header("X-Daytona-Organization-ID")),
+    ),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/sandbox/{sandboxIdOrName}/ports/{port}/preview-url",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetPortPreviewUrlRequest",
+}) as any as S.Schema<GetPortPreviewUrlRequest>;
+
+export interface PortPreviewUrl {
+  /** ID of the sandbox */
+  sandboxId: string;
+  /** Preview url */
+  url: string;
+  /** Access token */
+  token: string;
+}
+export const PortPreviewUrl = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    sandboxId: S.String,
+    url: S.String,
+    token: S.String,
+  }),
+).annotate({ identifier: "PortPreviewUrl" }) as any as S.Schema<PortPreviewUrl>;
+
+export interface GetRegionQuotaBySandboxIdRequest {
+  /** ID of the sandbox */
+  sandboxId: string;
+  /** Use with JWT to specify the organization ID */
+  xDaytonaOrganizationID?: string;
+}
+export const GetRegionQuotaBySandboxIdRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    sandboxId: S.String.pipe(T.Label()),
+    xDaytonaOrganizationID: S.optional(
+      S.String.pipe(T.Header("X-Daytona-Organization-ID")),
+    ),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/sandbox/{sandboxId}/region-quota",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetRegionQuotaBySandboxIdRequest",
+}) as any as S.Schema<GetRegionQuotaBySandboxIdRequest>;
+
+export type SandboxClass = "linux-vm" | "container" | "android" | "windows";
+export const SandboxClass = S.String;
+
+export type RegionQuotaAllowedGpuTypesList = Array<GpuType>;
+export const RegionQuotaAllowedGpuTypesList = /*@__PURE__*/ S.Array(
+  GpuType,
+) as any as S.Schema<RegionQuotaAllowedGpuTypesList>;
+
+export interface RegionQuota {
+  organizationId: string;
+  regionId: string;
+  sandboxClass: SandboxClass;
+  totalCpuQuota: number;
+  totalMemoryQuota: number;
+  totalDiskQuota: number;
+  totalGpuQuota: number;
+  allowedGpuTypes?: RegionQuotaAllowedGpuTypesList;
+  maxCpuPerSandbox: number | null;
+  maxMemoryPerSandbox: number | null;
+  maxDiskPerSandbox: number | null;
+  maxDiskPerNonEphemeralSandbox: number | null;
+  /** CPU maximum per requested GPU unit for GPU sandboxes. */
+  maxCpuPerGpu: number | null;
+  /** Memory maximum per requested GPU unit for GPU sandboxes. */
+  maxMemoryPerGpu: number | null;
+  /** Disk maximum per requested GPU unit for GPU sandboxes. */
+  maxDiskPerGpu: number | null;
+  /** Maximum sandbox lifespan in minutes, measured from sandbox creation to its auto-destroy deadline. If null or 0, lifespan is unrestricted. When set, sandboxes created without a TTL default to this lifespan and TTL cannot be disabled. */
+  maxSandboxLifespan: number | null;
+}
+export const RegionQuota = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    organizationId: S.String,
+    regionId: S.String,
+    sandboxClass: SandboxClass,
+    totalCpuQuota: S.Number,
+    totalMemoryQuota: S.Number,
+    totalDiskQuota: S.Number,
+    totalGpuQuota: S.Number,
+    allowedGpuTypes: S.optional(RegionQuotaAllowedGpuTypesList),
+    maxCpuPerSandbox: S.NullOr(S.Number),
+    maxMemoryPerSandbox: S.NullOr(S.Number),
+    maxDiskPerSandbox: S.NullOr(S.Number),
+    maxDiskPerNonEphemeralSandbox: S.NullOr(S.Number),
+    maxCpuPerGpu: S.NullOr(S.Number),
+    maxMemoryPerGpu: S.NullOr(S.Number),
+    maxDiskPerGpu: S.NullOr(S.Number),
+    maxSandboxLifespan: S.NullOr(S.Number),
+  }),
+).annotate({ identifier: "RegionQuota" }) as any as S.Schema<RegionQuota>;
+
+export interface GetSandboxRequest {
+  /** ID or name of the sandbox */
+  sandboxIdOrName: string;
+  /** Include verbose output */
+  verbose?: boolean;
+  /** Use with JWT to specify the organization ID */
+  xDaytonaOrganizationID?: string;
+}
+export const GetSandboxRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    sandboxIdOrName: S.String.pipe(T.Label()),
+    verbose: S.optional(S.Boolean.pipe(T.Query())),
+    xDaytonaOrganizationID: S.optional(
+      S.String.pipe(T.Header("X-Daytona-Organization-ID")),
+    ),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/sandbox/{sandboxIdOrName}", code: 200 }),
+  ),
+).annotate({
+  identifier: "GetSandboxRequest",
+}) as any as S.Schema<GetSandboxRequest>;
+
+export interface GetSandboxAncestorsRequest {
+  sandboxIdOrName: string;
+  /** Use with JWT to specify the organization ID */
+  xDaytonaOrganizationID?: string;
+}
+export const GetSandboxAncestorsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    sandboxIdOrName: S.String.pipe(T.Label()),
+    xDaytonaOrganizationID: S.optional(
+      S.String.pipe(T.Header("X-Daytona-Organization-ID")),
+    ),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/sandbox/{sandboxIdOrName}/ancestors",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetSandboxAncestorsRequest",
+}) as any as S.Schema<GetSandboxAncestorsRequest>;
+
+export type GetSandboxAncestorsResponseBodyList = Array<Sandbox2>;
+export const GetSandboxAncestorsResponseBodyList = /*@__PURE__*/ S.Array(
+  Sandbox2,
+) as any as S.Schema<GetSandboxAncestorsResponseBodyList>;
+
+export type GetSandboxAncestorsResponse = GetSandboxAncestorsResponseBodyList;
+export const GetSandboxAncestorsResponse = /*@__PURE__*/ S.suspend(() =>
+  GetSandboxAncestorsResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "GetSandboxAncestorsResponse",
+}) as any as S.Schema<GetSandboxAncestorsResponse>;
+
+export interface GetSandboxesForRunnerRequest {
+  /** Comma-separated list of sandbox states to filter by */
+  states?: string;
+  /** Skip sandboxes where state differs from desired state */
+  skipReconcilingSandboxes?: boolean;
+  /** Use with JWT to specify the organization ID */
+  xDaytonaOrganizationID?: string;
+}
+export const GetSandboxesForRunnerRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    states: S.optional(S.String.pipe(T.Query())),
+    skipReconcilingSandboxes: S.optional(S.Boolean.pipe(T.Query())),
+    xDaytonaOrganizationID: S.optional(
+      S.String.pipe(T.Header("X-Daytona-Organization-ID")),
+    ),
+  }).pipe(T.Http({ method: "GET", uri: "/sandbox/for-runner", code: 200 })),
+).annotate({
+  identifier: "GetSandboxesForRunnerRequest",
+}) as any as S.Schema<GetSandboxesForRunnerRequest>;
+
+export type GetSandboxesForRunnerResponseBodyList = Array<Sandbox2>;
+export const GetSandboxesForRunnerResponseBodyList = /*@__PURE__*/ S.Array(
+  Sandbox2,
+) as any as S.Schema<GetSandboxesForRunnerResponseBodyList>;
+
+export type GetSandboxesForRunnerResponse =
+  GetSandboxesForRunnerResponseBodyList;
+export const GetSandboxesForRunnerResponse = /*@__PURE__*/ S.suspend(() =>
+  GetSandboxesForRunnerResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "GetSandboxesForRunnerResponse",
+}) as any as S.Schema<GetSandboxesForRunnerResponse>;
+
+export interface GetSandboxForksRequest {
+  sandboxIdOrName: string;
+  includeDestroyed?: boolean;
+  /** Use with JWT to specify the organization ID */
+  xDaytonaOrganizationID?: string;
+}
+export const GetSandboxForksRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    sandboxIdOrName: S.String.pipe(T.Label()),
+    includeDestroyed: S.optional(S.Boolean.pipe(T.Query())),
+    xDaytonaOrganizationID: S.optional(
+      S.String.pipe(T.Header("X-Daytona-Organization-ID")),
+    ),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/sandbox/{sandboxIdOrName}/forks",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetSandboxForksRequest",
+}) as any as S.Schema<GetSandboxForksRequest>;
+
+export type GetSandboxForksResponseBodyList = Array<Sandbox2>;
+export const GetSandboxForksResponseBodyList = /*@__PURE__*/ S.Array(
+  Sandbox2,
+) as any as S.Schema<GetSandboxForksResponseBodyList>;
+
+export type GetSandboxForksResponse = GetSandboxForksResponseBodyList;
+export const GetSandboxForksResponse = /*@__PURE__*/ S.suspend(() =>
+  GetSandboxForksResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "GetSandboxForksResponse",
+}) as any as S.Schema<GetSandboxForksResponse>;
+
+export type GetSandboxLogsRequestSeveritiesList = Array<string>;
+export const GetSandboxLogsRequestSeveritiesList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<GetSandboxLogsRequestSeveritiesList>;
+
+export interface GetSandboxLogsRequest {
+  /** ID of the sandbox */
+  sandboxId: string;
+  /** Start of time range (ISO 8601) */
+  from: string;
+  /** End of time range (ISO 8601) */
+  to: string;
+  /** Page number (1-indexed) */
+  page?: number;
+  /** Number of items per page */
+  limit?: number;
+  /** Filter by severity levels (DEBUG, INFO, WARN, ERROR) */
+  severities?: GetSandboxLogsRequestSeveritiesList;
+  /** Search in log body */
+  search?: string;
+  /** Use with JWT to specify the organization ID */
+  xDaytonaOrganizationID?: string;
+}
+export const GetSandboxLogsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    sandboxId: S.String.pipe(T.Label()),
+    from: S.String.pipe(T.Query()),
+    to: S.String.pipe(T.Query()),
+    page: S.optional(S.Number.pipe(T.Query())),
+    limit: S.optional(S.Number.pipe(T.Query())),
+    severities: S.optional(GetSandboxLogsRequestSeveritiesList.pipe(T.Query())),
+    search: S.optional(S.String.pipe(T.Query())),
+    xDaytonaOrganizationID: S.optional(
+      S.String.pipe(T.Header("X-Daytona-Organization-ID")),
+    ),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/sandbox/{sandboxId}/telemetry/logs",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetSandboxLogsRequest",
+}) as any as S.Schema<GetSandboxLogsRequest>;
+
+/** Resource attributes from OTEL */
+export type LogEntryResourceAttributesMap = {
+  [key: string]: string | undefined;
+};
+export const LogEntryResourceAttributesMap = /*@__PURE__*/ S.Record(
+  S.String,
+  S.String,
+) as any as S.Schema<LogEntryResourceAttributesMap>;
+
+/** Log-specific attributes */
+export type LogEntryLogAttributesMap = { [key: string]: string | undefined };
+export const LogEntryLogAttributesMap = /*@__PURE__*/ S.Record(
+  S.String,
+  S.String,
+) as any as S.Schema<LogEntryLogAttributesMap>;
+
+export interface LogEntry {
+  /** Timestamp of the log entry */
+  timestamp: string;
+  /** Log message body */
+  body: string;
+  /** Severity level text (e.g., INFO, WARN, ERROR) */
+  severityText: string;
+  /** Severity level number */
+  severityNumber?: number;
+  /** Service name that generated the log */
+  serviceName: string;
+  /** Resource attributes from OTEL */
+  resourceAttributes: LogEntryResourceAttributesMap;
+  /** Log-specific attributes */
+  logAttributes: LogEntryLogAttributesMap;
+  /** Associated trace ID if available */
+  traceId?: string;
+  /** Associated span ID if available */
+  spanId?: string;
+}
+export const LogEntry = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    timestamp: S.String,
+    body: S.String,
+    severityText: S.String,
+    severityNumber: S.optional(S.Number),
+    serviceName: S.String,
+    resourceAttributes: LogEntryResourceAttributesMap,
+    logAttributes: LogEntryLogAttributesMap,
+    traceId: S.optional(S.String),
+    spanId: S.optional(S.String),
+  }),
+).annotate({ identifier: "LogEntry" }) as any as S.Schema<LogEntry>;
+
+/** List of log entries */
+export type PaginatedLogsItemsList = Array<LogEntry>;
+export const PaginatedLogsItemsList = /*@__PURE__*/ S.Array(
+  LogEntry,
+) as any as S.Schema<PaginatedLogsItemsList>;
+
+export interface PaginatedLogs {
+  /** List of log entries */
+  items: PaginatedLogsItemsList;
+  /** Total number of log entries matching the query */
+  total: number;
+  /** Current page number */
+  page: number;
+  /** Total number of pages */
+  totalPages: number;
+}
+export const PaginatedLogs = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    items: PaginatedLogsItemsList,
+    total: S.Number,
+    page: S.Number,
+    totalPages: S.Number,
+  }),
+).annotate({ identifier: "PaginatedLogs" }) as any as S.Schema<PaginatedLogs>;
+
+export type GetSandboxMetricsRequestMetricNamesList = Array<string>;
+export const GetSandboxMetricsRequestMetricNamesList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<GetSandboxMetricsRequestMetricNamesList>;
+
+export interface GetSandboxMetricsRequest {
+  /** ID of the sandbox */
+  sandboxId: string;
+  /** Start of time range (ISO 8601) */
+  from: string;
+  /** End of time range (ISO 8601) */
+  to: string;
+  /** Filter by metric names */
+  metricNames?: GetSandboxMetricsRequestMetricNamesList;
+  /** Use with JWT to specify the organization ID */
+  xDaytonaOrganizationID?: string;
+}
+export const GetSandboxMetricsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    sandboxId: S.String.pipe(T.Label()),
+    from: S.String.pipe(T.Query()),
+    to: S.String.pipe(T.Query()),
+    metricNames: S.optional(
+      GetSandboxMetricsRequestMetricNamesList.pipe(T.Query()),
+    ),
+    xDaytonaOrganizationID: S.optional(
+      S.String.pipe(T.Header("X-Daytona-Organization-ID")),
+    ),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/sandbox/{sandboxId}/telemetry/metrics",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetSandboxMetricsRequest",
+}) as any as S.Schema<GetSandboxMetricsRequest>;
+
+export interface MetricDataPoint {
+  /** Timestamp of the data point */
+  timestamp: string;
+  /** Value at this timestamp */
+  value: number;
+}
+export const MetricDataPoint = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    timestamp: S.String,
+    value: S.Number,
+  }),
+).annotate({
+  identifier: "MetricDataPoint",
+}) as any as S.Schema<MetricDataPoint>;
+
+/** Data points for this metric */
+export type MetricSeriesDataPointsList = Array<MetricDataPoint>;
+export const MetricSeriesDataPointsList = /*@__PURE__*/ S.Array(
+  MetricDataPoint,
+) as any as S.Schema<MetricSeriesDataPointsList>;
+
+export interface MetricSeries {
+  /** Name of the metric */
+  metricName: string;
+  /** Data points for this metric */
+  dataPoints: MetricSeriesDataPointsList;
+}
+export const MetricSeries = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    metricName: S.String,
+    dataPoints: MetricSeriesDataPointsList,
+  }),
+).annotate({ identifier: "MetricSeries" }) as any as S.Schema<MetricSeries>;
+
+/** List of metric series */
+export type MetricsResponseSeriesList = Array<MetricSeries>;
+export const MetricsResponseSeriesList = /*@__PURE__*/ S.Array(
+  MetricSeries,
+) as any as S.Schema<MetricsResponseSeriesList>;
+
+export interface MetricsResponse {
+  /** List of metric series */
+  series: MetricsResponseSeriesList;
+}
+export const MetricsResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    series: MetricsResponseSeriesList,
+  }),
+).annotate({
+  identifier: "MetricsResponse",
+}) as any as S.Schema<MetricsResponse>;
+
+export interface GetSandboxParentRequest {
+  sandboxIdOrName: string;
+  /** Use with JWT to specify the organization ID */
+  xDaytonaOrganizationID?: string;
+}
+export const GetSandboxParentRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    sandboxIdOrName: S.String.pipe(T.Label()),
+    xDaytonaOrganizationID: S.optional(
+      S.String.pipe(T.Header("X-Daytona-Organization-ID")),
+    ),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/sandbox/{sandboxIdOrName}/parent",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetSandboxParentRequest",
+}) as any as S.Schema<GetSandboxParentRequest>;
+
+export interface GetSandboxSigningKeyRequest {
+  /** ID of the sandbox */
+  sandboxId: string;
+  /** Use with JWT to specify the organization ID */
+  xDaytonaOrganizationID?: string;
+}
+export const GetSandboxSigningKeyRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    sandboxId: S.String.pipe(T.Label()),
+    xDaytonaOrganizationID: S.optional(
+      S.String.pipe(T.Header("X-Daytona-Organization-ID")),
+    ),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/sandbox/{sandboxId}/signing-key",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetSandboxSigningKeyRequest",
+}) as any as S.Schema<GetSandboxSigningKeyRequest>;
+
+export type GetSandboxSigningKeyResponse = string;
+export const GetSandboxSigningKeyResponse = /*@__PURE__*/ S.suspend(() =>
+  S.String.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "GetSandboxSigningKeyResponse",
+}) as any as S.Schema<GetSandboxSigningKeyResponse>;
+
+export interface GetSandboxTracesRequest {
+  /** ID of the sandbox */
+  sandboxId: string;
+  /** Start of time range (ISO 8601) */
+  from: string;
+  /** End of time range (ISO 8601) */
+  to: string;
+  /** Page number (1-indexed) */
+  page?: number;
+  /** Number of items per page */
+  limit?: number;
+  /** Use with JWT to specify the organization ID */
+  xDaytonaOrganizationID?: string;
+}
+export const GetSandboxTracesRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    sandboxId: S.String.pipe(T.Label()),
+    from: S.String.pipe(T.Query()),
+    to: S.String.pipe(T.Query()),
+    page: S.optional(S.Number.pipe(T.Query())),
+    limit: S.optional(S.Number.pipe(T.Query())),
+    xDaytonaOrganizationID: S.optional(
+      S.String.pipe(T.Header("X-Daytona-Organization-ID")),
+    ),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/sandbox/{sandboxId}/telemetry/traces",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetSandboxTracesRequest",
+}) as any as S.Schema<GetSandboxTracesRequest>;
+
+export interface TraceSummary {
+  /** Unique trace identifier */
+  traceId: string;
+  /** Name of the root span */
+  rootSpanName: string;
+  /** Trace start time */
+  startTime: string;
+  /** Trace end time */
+  endTime: string;
+  /** Total duration in milliseconds */
+  durationMs: number;
+  /** Number of spans in this trace */
+  spanCount: number;
+  /** Status code of the trace */
+  statusCode?: string;
+}
+export const TraceSummary = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    traceId: S.String,
+    rootSpanName: S.String,
+    startTime: S.String,
+    endTime: S.String,
+    durationMs: S.Number,
+    spanCount: S.Number,
+    statusCode: S.optional(S.String),
+  }),
+).annotate({ identifier: "TraceSummary" }) as any as S.Schema<TraceSummary>;
+
+/** List of trace summaries */
+export type PaginatedTracesItemsList = Array<TraceSummary>;
+export const PaginatedTracesItemsList = /*@__PURE__*/ S.Array(
+  TraceSummary,
+) as any as S.Schema<PaginatedTracesItemsList>;
+
+export interface PaginatedTraces {
+  /** List of trace summaries */
+  items: PaginatedTracesItemsList;
+  /** Total number of traces matching the query */
+  total: number;
+  /** Current page number */
+  page: number;
+  /** Total number of pages */
+  totalPages: number;
+}
+export const PaginatedTraces = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    items: PaginatedTracesItemsList,
+    total: S.Number,
+    page: S.Number,
+    totalPages: S.Number,
+  }),
+).annotate({
+  identifier: "PaginatedTraces",
+}) as any as S.Schema<PaginatedTraces>;
+
+export interface GetSandboxTraceSpansRequest {
+  /** ID of the sandbox */
+  sandboxId: string;
+  /** ID of the trace */
+  traceId: string;
+  /** Use with JWT to specify the organization ID */
+  xDaytonaOrganizationID?: string;
+}
+export const GetSandboxTraceSpansRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    sandboxId: S.String.pipe(T.Label()),
+    traceId: S.String.pipe(T.Label()),
+    xDaytonaOrganizationID: S.optional(
+      S.String.pipe(T.Header("X-Daytona-Organization-ID")),
+    ),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/sandbox/{sandboxId}/telemetry/traces/{traceId}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetSandboxTraceSpansRequest",
+}) as any as S.Schema<GetSandboxTraceSpansRequest>;
+
+/** Span attributes */
+export type TraceSpanSpanAttributesMap = { [key: string]: string | undefined };
+export const TraceSpanSpanAttributesMap = /*@__PURE__*/ S.Record(
+  S.String,
+  S.String,
+) as any as S.Schema<TraceSpanSpanAttributesMap>;
+
+export interface TraceSpan {
+  /** Trace identifier */
+  traceId: string;
+  /** Span identifier */
+  spanId: string;
+  /** Parent span identifier */
+  parentSpanId?: string;
+  /** Span name */
+  spanName: string;
+  /** Span start timestamp */
+  timestamp: string;
+  /** Span duration in nanoseconds */
+  durationNs: number;
+  /** Span attributes */
+  spanAttributes: TraceSpanSpanAttributesMap;
+  /** Status code of the span */
+  statusCode?: string;
+  /** Status message */
+  statusMessage?: string;
+}
+export const TraceSpan = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    traceId: S.String,
+    spanId: S.String,
+    parentSpanId: S.optional(S.String),
+    spanName: S.String,
+    timestamp: S.String,
+    durationNs: S.Number,
+    spanAttributes: TraceSpanSpanAttributesMap,
+    statusCode: S.optional(S.String),
+    statusMessage: S.optional(S.String),
+  }),
+).annotate({ identifier: "TraceSpan" }) as any as S.Schema<TraceSpan>;
+
+export type GetSandboxTraceSpansResponseBodyList = Array<TraceSpan>;
+export const GetSandboxTraceSpansResponseBodyList = /*@__PURE__*/ S.Array(
+  TraceSpan,
+) as any as S.Schema<GetSandboxTraceSpansResponseBodyList>;
+
+export type GetSandboxTraceSpansResponse = GetSandboxTraceSpansResponseBodyList;
+export const GetSandboxTraceSpansResponse = /*@__PURE__*/ S.suspend(() =>
+  GetSandboxTraceSpansResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "GetSandboxTraceSpansResponse",
+}) as any as S.Schema<GetSandboxTraceSpansResponse>;
+
+export interface GetSignedPortPreviewUrlRequest {
+  /** ID or name of the sandbox */
+  sandboxIdOrName: string;
+  /** Port number to get signed preview URL for */
+  port: number;
+  /** Expiration time in seconds (default: 60 seconds) */
+  expiresInSeconds?: number;
+  /** Use with JWT to specify the organization ID */
+  xDaytonaOrganizationID?: string;
+}
+export const GetSignedPortPreviewUrlRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    sandboxIdOrName: S.String.pipe(T.Label()),
+    port: S.Number.pipe(T.Label()),
+    expiresInSeconds: S.optional(S.Number.pipe(T.Query())),
+    xDaytonaOrganizationID: S.optional(
+      S.String.pipe(T.Header("X-Daytona-Organization-ID")),
+    ),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/sandbox/{sandboxIdOrName}/ports/{port}/signed-preview-url",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetSignedPortPreviewUrlRequest",
+}) as any as S.Schema<GetSignedPortPreviewUrlRequest>;
+
+export interface SignedPortPreviewUrl {
+  /** ID of the sandbox */
+  sandboxId: string;
+  /** Port number of the signed preview URL */
+  port: number;
+  /** Token of the signed preview URL */
+  token: string;
+  /** Signed preview url */
+  url: string;
+}
+export const SignedPortPreviewUrl = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    sandboxId: S.String,
+    port: S.Number,
+    token: S.String,
+    url: S.String,
+  }),
+).annotate({
+  identifier: "SignedPortPreviewUrl",
+}) as any as S.Schema<SignedPortPreviewUrl>;
+
+export interface GetToolboxProxyUrlRequest {
+  /** ID of the sandbox */
+  sandboxId: string;
+  /** Use with JWT to specify the organization ID */
+  xDaytonaOrganizationID?: string;
+}
+export const GetToolboxProxyUrlRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    sandboxId: S.String.pipe(T.Label()),
+    xDaytonaOrganizationID: S.optional(
+      S.String.pipe(T.Header("X-Daytona-Organization-ID")),
+    ),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/sandbox/{sandboxId}/toolbox-proxy-url",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetToolboxProxyUrlRequest",
+}) as any as S.Schema<GetToolboxProxyUrlRequest>;
+
+export interface ToolboxProxyUrl {
+  /** The toolbox proxy URL for the sandbox */
+  url: string;
+}
+export const ToolboxProxyUrl = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    url: S.String,
+  }),
+).annotate({
+  identifier: "ToolboxProxyUrl",
+}) as any as S.Schema<ToolboxProxyUrl>;
+
+export type ListSandboxesRequestStatesList = Array<
+  SandboxState | (string & {})
+>;
+export const ListSandboxesRequestStatesList = /*@__PURE__*/ S.Array(
+  SandboxState,
+) as any as S.Schema<ListSandboxesRequestStatesList>;
+
+export type ListSandboxesRequestSnapshotsList = Array<string>;
+export const ListSandboxesRequestSnapshotsList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<ListSandboxesRequestSnapshotsList>;
+
+export type ListSandboxesRequestRegionIdsList = Array<string>;
+export const ListSandboxesRequestRegionIdsList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<ListSandboxesRequestRegionIdsList>;
+
+export type ListSandboxesRequestSandboxClassesList = Array<
+  SandboxClass | (string & {})
+>;
+export const ListSandboxesRequestSandboxClassesList = /*@__PURE__*/ S.Array(
+  SandboxClass,
+) as any as S.Schema<ListSandboxesRequestSandboxClassesList>;
+
+export type SandboxListSortField =
+  | "name"
+  | "cpu"
+  | "memoryGib"
+  | "diskGib"
+  | "lastActivityAt"
+  | "createdAt";
+export const SandboxListSortField = S.String;
+
+export type SandboxListSortDirection = "asc" | "desc";
+export const SandboxListSortDirection = S.String;
+
+export interface ListSandboxesRequest {
+  /** Pagination cursor from a previous response */
+  cursor?: string;
+  /** Number of results per page */
+  limit?: number;
+  /** Filter by ID prefix (case-insensitive) */
+  id?: string;
+  /** Filter by name prefix (case-insensitive) */
+  name?: string;
+  /** JSON encoded labels to filter by */
+  labels?: string;
+  /** Include results with errored state and deleted desired state */
+  includeErroredDeleted?: boolean;
+  /** Include unclaimed warm pool sandboxes (excluded by default) */
+  includeWarm?: boolean;
+  /** List of states to filter by. */
+  states?: ListSandboxesRequestStatesList;
+  /** List of snapshot names to filter by */
+  snapshots?: ListSandboxesRequestSnapshotsList;
+  /** List of regions IDs to filter by */
+  regionIds?: ListSandboxesRequestRegionIdsList;
+  /** List of sandbox classes to filter by */
+  sandboxClasses?: ListSandboxesRequestSandboxClassesList;
+  /** Minimum CPU */
+  minCpu?: number;
+  /** Maximum CPU */
+  maxCpu?: number;
+  /** Minimum memory in GiB */
+  minMemoryGiB?: number;
+  /** Maximum memory in GiB */
+  maxMemoryGiB?: number;
+  /** Minimum disk space in GiB */
+  minDiskGiB?: number;
+  /** Maximum disk space in GiB */
+  maxDiskGiB?: number;
+  /** Minimum GPU */
+  minGpu?: number;
+  /** Maximum GPU */
+  maxGpu?: number;
+  /** Filter by public status */
+  isPublic?: boolean;
+  /** Filter by recoverable status */
+  isRecoverable?: boolean;
+  /** Include items created after this timestamp */
+  createdAtAfter?: string;
+  /** Include items created before this timestamp */
+  createdAtBefore?: string;
+  /** Include items with last event after this timestamp */
+  lastEventAfter?: string;
+  /** Include items with last event before this timestamp */
+  lastEventBefore?: string;
+  /** Include items scheduled for auto destroy after this timestamp */
+  autoDestroyAtAfter?: string;
+  /** Include items scheduled for auto destroy before this timestamp */
+  autoDestroyAtBefore?: string;
+  /** Field to sort by */
+  sort?: SandboxListSortField | (string & {});
+  /** Direction to sort by */
+  order?: SandboxListSortDirection | (string & {});
+  /** Use with JWT to specify the organization ID */
+  xDaytonaOrganizationID?: string;
+}
+export const ListSandboxesRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    cursor: S.optional(S.String.pipe(T.Query())),
+    limit: S.optional(S.Number.pipe(T.Query())),
+    id: S.optional(S.String.pipe(T.Query())),
+    name: S.optional(S.String.pipe(T.Query())),
+    labels: S.optional(S.String.pipe(T.Query())),
+    includeErroredDeleted: S.optional(S.Boolean.pipe(T.Query())),
+    includeWarm: S.optional(S.Boolean.pipe(T.Query())),
+    states: S.optional(ListSandboxesRequestStatesList.pipe(T.Query())),
+    snapshots: S.optional(ListSandboxesRequestSnapshotsList.pipe(T.Query())),
+    regionIds: S.optional(ListSandboxesRequestRegionIdsList.pipe(T.Query())),
+    sandboxClasses: S.optional(
+      ListSandboxesRequestSandboxClassesList.pipe(T.Query()),
+    ),
+    minCpu: S.optional(S.Number.pipe(T.Query())),
+    maxCpu: S.optional(S.Number.pipe(T.Query())),
+    minMemoryGiB: S.optional(S.Number.pipe(T.Query())),
+    maxMemoryGiB: S.optional(S.Number.pipe(T.Query())),
+    minDiskGiB: S.optional(S.Number.pipe(T.Query())),
+    maxDiskGiB: S.optional(S.Number.pipe(T.Query())),
+    minGpu: S.optional(S.Number.pipe(T.Query())),
+    maxGpu: S.optional(S.Number.pipe(T.Query())),
+    isPublic: S.optional(S.Boolean.pipe(T.Query())),
+    isRecoverable: S.optional(S.Boolean.pipe(T.Query())),
+    createdAtAfter: S.optional(S.String.pipe(T.Query())),
+    createdAtBefore: S.optional(S.String.pipe(T.Query())),
+    lastEventAfter: S.optional(S.String.pipe(T.Query())),
+    lastEventBefore: S.optional(S.String.pipe(T.Query())),
+    autoDestroyAtAfter: S.optional(S.String.pipe(T.Query())),
+    autoDestroyAtBefore: S.optional(S.String.pipe(T.Query())),
+    sort: S.optional(SandboxListSortField.pipe(T.Query())),
+    order: S.optional(SandboxListSortDirection.pipe(T.Query())),
+    xDaytonaOrganizationID: S.optional(
+      S.String.pipe(T.Header("X-Daytona-Organization-ID")),
+    ),
+  }).pipe(T.Http({ method: "GET", uri: "/sandbox", code: 200 })),
+).annotate({
+  identifier: "ListSandboxesRequest",
+}) as any as S.Schema<ListSandboxesRequest>;
+
+/** Labels for the sandbox */
+export type SandboxListItemLabelsMap = { [key: string]: string | undefined };
+export const SandboxListItemLabelsMap = /*@__PURE__*/ S.Record(
+  S.String,
+  S.String,
+) as any as S.Schema<SandboxListItemLabelsMap>;
+
+/** The state of the backup */
+export type SandboxListItemBackupState =
+  | "None"
+  | "Pending"
+  | "InProgress"
+  | "Completed"
+  | "Error";
+export const SandboxListItemBackupState = S.String;
+
+export interface SandboxListItem {
+  /** The ID of the sandbox */
+  id: string;
+  /** The organization ID of the sandbox */
+  organizationId: string;
+  /** The name of the sandbox */
+  name: string;
+  /** The target environment for the sandbox */
+  target: string;
+  /** The runner ID of the sandbox */
+  runnerId?: string;
+  /** The class of the sandbox */
+  sandboxClass?: SandboxClass;
+  /** The state of the sandbox */
+  state?: SandboxState;
+  /** The desired state of the sandbox */
+  desiredState?: SandboxDesiredState;
+  /** The snapshot used for the sandbox */
+  snapshot?: string;
+  /** The user associated with the project */
+  user: string;
+  /** The error reason of the sandbox */
+  errorReason?: string;
+  /** Whether the sandbox error is recoverable. */
+  recoverable?: boolean;
+  /** Whether the sandbox http preview is public */
+  public: boolean;
+  /** Whether to block all network access for the sandbox */
+  networkBlockAll: boolean;
+  /** Comma-separated list of allowed CIDR network addresses for the sandbox */
+  networkAllowList?: string;
+  /** Comma-separated list of allowed domains for the sandbox */
+  domainAllowList?: string;
+  /** The CPU quota for the sandbox */
+  cpu: number;
+  /** The GPU quota for the sandbox */
+  gpu: number;
+  /** Whether this is a spot GPU sandbox. Spot sandboxes may be instantly terminated to free capacity for on-demand GPU sandboxes. Absent on APIs that predate this field; treat as false. */
+  spot?: boolean;
+  /** When this sandbox was evicted by spot preemption. Set as soon as the sandbox is marked for eviction, so it is already present while the sandbox is still winding down. */
+  spotEvictedAt?: string;
+  /** The GPU type assigned to the sandbox */
+  gpuType?: GpuType;
+  /** The memory quota for the sandbox */
+  memory: number;
+  /** The disk quota for the sandbox */
+  disk: number;
+  /** Labels for the sandbox */
+  labels: SandboxListItemLabelsMap;
+  /** The state of the backup */
+  backupState?: SandboxListItemBackupState;
+  /** Auto-stop interval in minutes (0 means disabled) */
+  autoStopInterval?: number;
+  /** Auto-pause interval in minutes (0 means disabled) */
+  autoPauseInterval?: number;
+  /** Auto-archive interval in minutes */
+  autoArchiveInterval?: number;
+  /** Auto-delete interval in minutes (negative value means disabled, 0 means delete immediately upon stopping) */
+  autoDeleteInterval?: number;
+  /** When the sandbox will be automatically destroyed, regardless of its state (only set when a TTL is configured) */
+  autoDestroyAt?: string;
+  /** The creation timestamp of the sandbox */
+  createdAt?: string;
+  /** The last update timestamp of the sandbox */
+  updatedAt?: string;
+  /** The last activity timestamp of the sandbox */
+  lastActivityAt?: string;
+  /** The version of the daemon running in the sandbox */
+  daemonVersion?: string;
+  /** Id of the warm pool this sandbox waits in; set only while it is an unclaimed member */
+  warmPoolId?: string;
+  /** The toolbox proxy URL for the sandbox */
+  toolboxProxyUrl: string;
+}
+export const SandboxListItem = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.String,
+    organizationId: S.String,
+    name: S.String,
+    target: S.String,
+    runnerId: S.optional(S.String),
+    sandboxClass: S.optional(SandboxClass),
+    state: S.optional(SandboxState),
+    desiredState: S.optional(SandboxDesiredState),
+    snapshot: S.optional(S.String),
+    user: S.String,
+    errorReason: S.optional(S.String),
+    recoverable: S.optional(S.Boolean),
+    public: S.Boolean,
+    networkBlockAll: S.Boolean,
+    networkAllowList: S.optional(S.String),
+    domainAllowList: S.optional(S.String),
+    cpu: S.Number,
+    gpu: S.Number,
+    spot: S.optional(S.Boolean),
+    spotEvictedAt: S.optional(S.String),
+    gpuType: S.optional(GpuType),
+    memory: S.Number,
+    disk: S.Number,
+    labels: SandboxListItemLabelsMap,
+    backupState: S.optional(SandboxListItemBackupState),
+    autoStopInterval: S.optional(S.Number),
+    autoPauseInterval: S.optional(S.Number),
+    autoArchiveInterval: S.optional(S.Number),
+    autoDeleteInterval: S.optional(S.Number),
+    autoDestroyAt: S.optional(S.String),
+    createdAt: S.optional(S.String),
+    updatedAt: S.optional(S.String),
+    lastActivityAt: S.optional(S.String),
+    daemonVersion: S.optional(S.String),
+    warmPoolId: S.optional(S.String),
+    toolboxProxyUrl: S.String,
+  }),
+).annotate({
+  identifier: "SandboxListItem",
+}) as any as S.Schema<SandboxListItem>;
+
+/** List of results for the current page */
+export type ListSandboxesResponseItemsList = Array<SandboxListItem>;
+export const ListSandboxesResponseItemsList = /*@__PURE__*/ S.Array(
+  SandboxListItem,
+) as any as S.Schema<ListSandboxesResponseItemsList>;
+
+export interface ListSandboxesResponse {
+  /** List of results for the current page */
+  items: ListSandboxesResponseItemsList;
+  /** Cursor for the next page of results */
+  nextCursor: string | null;
+}
+export const ListSandboxesResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    items: ListSandboxesResponseItemsList,
+    nextCursor: S.NullOr(S.String),
+  }),
+).annotate({
+  identifier: "ListSandboxesResponse",
+}) as any as S.Schema<ListSandboxesResponse>;
+
+export interface PauseSandboxRequest {
+  /** ID or name of the sandbox */
+  sandboxIdOrName: string;
+  /** Use with JWT to specify the organization ID */
+  xDaytonaOrganizationID?: string;
+}
+export const PauseSandboxRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    sandboxIdOrName: S.String.pipe(T.Label()),
+    xDaytonaOrganizationID: S.optional(
+      S.String.pipe(T.Header("X-Daytona-Organization-ID")),
+    ),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/sandbox/{sandboxIdOrName}/pause",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "PauseSandboxRequest",
+}) as any as S.Schema<PauseSandboxRequest>;
+
+export interface RecoverSandboxRequest {
+  /** ID or name of the sandbox */
+  sandboxIdOrName: string;
+  /** If true, the sandbox is left in STOPPED after recovery instead of being started. */
+  skipStart?: boolean;
+  /** Use with JWT to specify the organization ID */
+  xDaytonaOrganizationID?: string;
+}
+export const RecoverSandboxRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    sandboxIdOrName: S.String.pipe(T.Label()),
+    skipStart: S.optional(S.Boolean.pipe(T.Query())),
+    xDaytonaOrganizationID: S.optional(
+      S.String.pipe(T.Header("X-Daytona-Organization-ID")),
+    ),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/sandbox/{sandboxIdOrName}/recover",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "RecoverSandboxRequest",
+}) as any as S.Schema<RecoverSandboxRequest>;
+
+/** Key-value pairs of labels */
+export type ReplaceLabelsRequestLabelsMap = {
+  [key: string]: string | undefined;
+};
+export const ReplaceLabelsRequestLabelsMap = /*@__PURE__*/ S.Record(
+  S.String,
+  S.String,
+) as any as S.Schema<ReplaceLabelsRequestLabelsMap>;
+
+export interface ReplaceLabelsRequest {
+  /** ID or name of the sandbox */
+  sandboxIdOrName: string;
+  /** Use with JWT to specify the organization ID */
+  xDaytonaOrganizationID?: string;
+  /** Key-value pairs of labels */
+  labels: ReplaceLabelsRequestLabelsMap;
+}
+export const ReplaceLabelsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    sandboxIdOrName: S.String.pipe(T.Label()),
+    xDaytonaOrganizationID: S.optional(
+      S.String.pipe(T.Header("X-Daytona-Organization-ID")),
+    ),
+    labels: ReplaceLabelsRequestLabelsMap,
+  }).pipe(
+    T.Http({
+      method: "PUT",
+      uri: "/sandbox/{sandboxIdOrName}/labels",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "ReplaceLabelsRequest",
+}) as any as S.Schema<ReplaceLabelsRequest>;
+
+/** Key-value pairs of labels */
+export type SandboxLabelsLabelsMap = { [key: string]: string | undefined };
+export const SandboxLabelsLabelsMap = /*@__PURE__*/ S.Record(
+  S.String,
+  S.String,
+) as any as S.Schema<SandboxLabelsLabelsMap>;
+
+export interface SandboxLabels {
+  /** Key-value pairs of labels */
+  labels: SandboxLabelsLabelsMap;
+}
+export const SandboxLabels = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    labels: SandboxLabelsLabelsMap,
+  }),
+).annotate({ identifier: "SandboxLabels" }) as any as S.Schema<SandboxLabels>;
+
+export interface ResizeSandboxRequest {
+  /** ID or name of the sandbox */
+  sandboxIdOrName: string;
+  /** Use with JWT to specify the organization ID */
+  xDaytonaOrganizationID?: string;
+  /** CPU cores to allocate to the sandbox (minimum: 1) */
+  cpu?: number;
+  /** Memory in GB to allocate to the sandbox (minimum: 1) */
+  memory?: number;
+  /** Disk space in GB to allocate to the sandbox (can only be increased) */
+  disk?: number;
+}
+export const ResizeSandboxRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    sandboxIdOrName: S.String.pipe(T.Label()),
+    xDaytonaOrganizationID: S.optional(
+      S.String.pipe(T.Header("X-Daytona-Organization-ID")),
+    ),
+    cpu: S.optional(S.Number),
+    memory: S.optional(S.Number),
+    disk: S.optional(S.Number),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/sandbox/{sandboxIdOrName}/resize",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "ResizeSandboxRequest",
+}) as any as S.Schema<ResizeSandboxRequest>;
+
+export interface ResolveSandboxSecretsRequest {
+  /** Sandbox ID */
+  sandboxId: string;
+  /** Use with JWT to specify the organization ID */
+  xDaytonaOrganizationID?: string;
+}
+export const ResolveSandboxSecretsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    sandboxId: S.String.pipe(T.Label()),
+    xDaytonaOrganizationID: S.optional(
+      S.String.pipe(T.Header("X-Daytona-Organization-ID")),
+    ),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/sandbox/{sandboxId}/secrets", code: 200 }),
+  ),
+).annotate({
+  identifier: "ResolveSandboxSecretsRequest",
+}) as any as S.Schema<ResolveSandboxSecretsRequest>;
+
+export type ResolveSandboxSecrets200ResponseInnerHostsList = Array<string>;
+export const ResolveSandboxSecrets200ResponseInnerHostsList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as S.Schema<ResolveSandboxSecrets200ResponseInnerHostsList>;
+
+export interface ResolveSandboxSecrets200ResponseInner {
+  env?: string;
+  placeholder?: string;
+  value?: string;
+  hosts?: ResolveSandboxSecrets200ResponseInnerHostsList;
+}
+export const ResolveSandboxSecrets200ResponseInner = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      env: S.optional(S.String),
+      placeholder: S.optional(S.String),
+      value: S.optional(S.String),
+      hosts: S.optional(ResolveSandboxSecrets200ResponseInnerHostsList),
+    }),
+).annotate({
+  identifier: "ResolveSandboxSecrets200ResponseInner",
+}) as any as S.Schema<ResolveSandboxSecrets200ResponseInner>;
+
+export type ResolveSandboxSecretsResponseBodyList =
+  Array<ResolveSandboxSecrets200ResponseInner>;
+export const ResolveSandboxSecretsResponseBodyList = /*@__PURE__*/ S.Array(
+  ResolveSandboxSecrets200ResponseInner,
+) as any as S.Schema<ResolveSandboxSecretsResponseBodyList>;
+
+export type ResolveSandboxSecretsResponse =
+  ResolveSandboxSecretsResponseBodyList;
+export const ResolveSandboxSecretsResponse = /*@__PURE__*/ S.suspend(() =>
+  ResolveSandboxSecretsResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ResolveSandboxSecretsResponse",
+}) as any as S.Schema<ResolveSandboxSecretsResponse>;
+
+export interface RevokeSshAccessRequest {
+  /** ID or name of the sandbox */
+  sandboxIdOrName: string;
+  /** SSH access token to revoke. If not provided, all SSH access for the sandbox will be revoked. */
+  token?: string;
+  /** Use with JWT to specify the organization ID */
+  xDaytonaOrganizationID?: string;
+}
+export const RevokeSshAccessRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    sandboxIdOrName: S.String.pipe(T.Label()),
+    token: S.optional(S.String.pipe(T.Query())),
+    xDaytonaOrganizationID: S.optional(
+      S.String.pipe(T.Header("X-Daytona-Organization-ID")),
+    ),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/sandbox/{sandboxIdOrName}/ssh-access",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "RevokeSshAccessRequest",
+}) as any as S.Schema<RevokeSshAccessRequest>;
+
+export interface RotateSigningKeyRequest {
+  /** ID of the sandbox */
+  sandboxId: string;
+  /** Use with JWT to specify the organization ID */
+  xDaytonaOrganizationID?: string;
+}
+export const RotateSigningKeyRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    sandboxId: S.String.pipe(T.Label()),
+    xDaytonaOrganizationID: S.optional(
+      S.String.pipe(T.Header("X-Daytona-Organization-ID")),
+    ),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/sandbox/{sandboxId}/signing-key/rotate",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "RotateSigningKeyRequest",
+}) as any as S.Schema<RotateSigningKeyRequest>;
+
+export type RotateSigningKeyResponse = string;
+export const RotateSigningKeyResponse = /*@__PURE__*/ S.suspend(() =>
+  S.String.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "RotateSigningKeyResponse",
+}) as any as S.Schema<RotateSigningKeyResponse>;
+
+export interface SetAutoArchiveIntervalRequest {
+  /** ID or name of the sandbox */
+  sandboxIdOrName: string;
+  /** Auto-archive interval in minutes (0 means the maximum interval will be used) */
+  interval: number;
+  /** Use with JWT to specify the organization ID */
+  xDaytonaOrganizationID?: string;
+}
+export const SetAutoArchiveIntervalRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    sandboxIdOrName: S.String.pipe(T.Label()),
+    interval: S.Number.pipe(T.Label()),
+    xDaytonaOrganizationID: S.optional(
+      S.String.pipe(T.Header("X-Daytona-Organization-ID")),
+    ),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/sandbox/{sandboxIdOrName}/autoarchive/{interval}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "SetAutoArchiveIntervalRequest",
+}) as any as S.Schema<SetAutoArchiveIntervalRequest>;
+
+export interface SetAutoDeleteIntervalRequest {
+  /** ID or name of the sandbox */
+  sandboxIdOrName: string;
+  /** Auto-delete interval in minutes (negative value means disabled, 0 means delete immediately upon stopping) */
+  interval: number;
+  /** Use with JWT to specify the organization ID */
+  xDaytonaOrganizationID?: string;
+}
+export const SetAutoDeleteIntervalRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    sandboxIdOrName: S.String.pipe(T.Label()),
+    interval: S.Number.pipe(T.Label()),
+    xDaytonaOrganizationID: S.optional(
+      S.String.pipe(T.Header("X-Daytona-Organization-ID")),
+    ),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/sandbox/{sandboxIdOrName}/autodelete/{interval}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "SetAutoDeleteIntervalRequest",
+}) as any as S.Schema<SetAutoDeleteIntervalRequest>;
+
+export interface SetAutoPauseIntervalRequest {
+  /** ID or name of the sandbox */
+  sandboxIdOrName: string;
+  /** Auto-pause interval in minutes (0 to disable) */
+  interval: number;
+  /** Use with JWT to specify the organization ID */
+  xDaytonaOrganizationID?: string;
+}
+export const SetAutoPauseIntervalRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    sandboxIdOrName: S.String.pipe(T.Label()),
+    interval: S.Number.pipe(T.Label()),
+    xDaytonaOrganizationID: S.optional(
+      S.String.pipe(T.Header("X-Daytona-Organization-ID")),
+    ),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/sandbox/{sandboxIdOrName}/autopause/{interval}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "SetAutoPauseIntervalRequest",
+}) as any as S.Schema<SetAutoPauseIntervalRequest>;
+
+export interface SetAutostopIntervalRequest {
+  /** ID or name of the sandbox */
+  sandboxIdOrName: string;
+  /** Auto-stop interval in minutes (0 to disable) */
+  interval: number;
+  /** Use with JWT to specify the organization ID */
+  xDaytonaOrganizationID?: string;
+}
+export const SetAutostopIntervalRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    sandboxIdOrName: S.String.pipe(T.Label()),
+    interval: S.Number.pipe(T.Label()),
+    xDaytonaOrganizationID: S.optional(
+      S.String.pipe(T.Header("X-Daytona-Organization-ID")),
+    ),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/sandbox/{sandboxIdOrName}/autostop/{interval}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "SetAutostopIntervalRequest",
+}) as any as S.Schema<SetAutostopIntervalRequest>;
+
+export interface SetTtlRequest {
+  /** ID or name of the sandbox */
+  sandboxIdOrName: string;
+  /** Maximum time to live in minutes, re-anchored from the current time (0 to disable). When it elapses the sandbox is destroyed, even if it is stopped, paused, or archived */
+  ttlMinutes: number;
+  /** Use with JWT to specify the organization ID */
+  xDaytonaOrganizationID?: string;
+}
+export const SetTtlRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    sandboxIdOrName: S.String.pipe(T.Label()),
+    ttlMinutes: S.Number.pipe(T.Label()),
+    xDaytonaOrganizationID: S.optional(
+      S.String.pipe(T.Header("X-Daytona-Organization-ID")),
+    ),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/sandbox/{sandboxIdOrName}/ttl/{ttlMinutes}",
+      code: 200,
+    }),
+  ),
+).annotate({ identifier: "SetTtlRequest" }) as any as S.Schema<SetTtlRequest>;
+
+export interface StartSandboxRequest {
+  /** ID or name of the sandbox */
+  sandboxIdOrName: string;
+  /** Use with JWT to specify the organization ID */
+  xDaytonaOrganizationID?: string;
+}
+export const StartSandboxRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    sandboxIdOrName: S.String.pipe(T.Label()),
+    xDaytonaOrganizationID: S.optional(
+      S.String.pipe(T.Header("X-Daytona-Organization-ID")),
+    ),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/sandbox/{sandboxIdOrName}/start",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "StartSandboxRequest",
+}) as any as S.Schema<StartSandboxRequest>;
+
+export interface StopSandboxRequest {
+  /** ID or name of the sandbox */
+  sandboxIdOrName: string;
+  /** Force stop the sandbox using SIGKILL instead of SIGTERM */
+  force?: boolean;
+  /** Use with JWT to specify the organization ID */
+  xDaytonaOrganizationID?: string;
+}
+export const StopSandboxRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    sandboxIdOrName: S.String.pipe(T.Label()),
+    force: S.optional(S.Boolean.pipe(T.Query())),
+    xDaytonaOrganizationID: S.optional(
+      S.String.pipe(T.Header("X-Daytona-Organization-ID")),
+    ),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/sandbox/{sandboxIdOrName}/stop",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "StopSandboxRequest",
+}) as any as S.Schema<StopSandboxRequest>;
+
+export interface UpdateLastActivityRequest {
+  /** ID of the sandbox */
+  sandboxId: string;
+  /** Use with JWT to specify the organization ID */
+  xDaytonaOrganizationID?: string;
+  /** Optional type of interaction that reset the activity timer. */
+  activityType?: string;
+}
+export const UpdateLastActivityRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    sandboxId: S.String.pipe(T.Label()),
+    xDaytonaOrganizationID: S.optional(
+      S.String.pipe(T.Header("X-Daytona-Organization-ID")),
+    ),
+    activityType: S.optional(S.String),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/sandbox/{sandboxId}/last-activity",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "UpdateLastActivityRequest",
+}) as any as S.Schema<UpdateLastActivityRequest>;
+
+export interface UpdateLastActivityResponse {}
+export const UpdateLastActivityResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "UpdateLastActivityResponse",
+}) as any as S.Schema<UpdateLastActivityResponse>;
+
+export interface UpdateNetworkSettingsRequest {
+  /** ID or name of the sandbox */
+  sandboxIdOrName: string;
+  /** Use with JWT to specify the organization ID */
+  xDaytonaOrganizationID?: string;
+  /** Whether to block all network access for the sandbox */
+  networkBlockAll?: boolean;
+  /** Comma-separated list of allowed CIDR network addresses for the sandbox */
+  networkAllowList?: string;
+  /** Comma-separated list of allowed domains for the sandbox */
+  domainAllowList?: string;
+}
+export const UpdateNetworkSettingsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    sandboxIdOrName: S.String.pipe(T.Label()),
+    xDaytonaOrganizationID: S.optional(
+      S.String.pipe(T.Header("X-Daytona-Organization-ID")),
+    ),
+    networkBlockAll: S.optional(S.Boolean),
+    networkAllowList: S.optional(S.String),
+    domainAllowList: S.optional(S.String),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/sandbox/{sandboxIdOrName}/network-settings",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "UpdateNetworkSettingsRequest",
+}) as any as S.Schema<UpdateNetworkSettingsRequest>;
+
+export interface UpdatePublicStatusRequest {
+  /** ID or name of the sandbox */
+  sandboxIdOrName: string;
+  /** Public status to set */
+  isPublic: boolean;
+  /** Use with JWT to specify the organization ID */
+  xDaytonaOrganizationID?: string;
+}
+export const UpdatePublicStatusRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    sandboxIdOrName: S.String.pipe(T.Label()),
+    isPublic: S.Boolean.pipe(T.Label()),
+    xDaytonaOrganizationID: S.optional(
+      S.String.pipe(T.Header("X-Daytona-Organization-ID")),
+    ),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/sandbox/{sandboxIdOrName}/public/{isPublic}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "UpdatePublicStatusRequest",
+}) as any as S.Schema<UpdatePublicStatusRequest>;
+
+export type UpdateSandboxSecretsRequestSecretsItemMap = {
+  [key: string]: string | undefined;
+};
+export const UpdateSandboxSecretsRequestSecretsItemMap = /*@__PURE__*/ S.Record(
+  S.String,
+  S.String,
+) as any as S.Schema<UpdateSandboxSecretsRequestSecretsItemMap>;
+
+/** Secrets to mount in this sandbox, replacing the previously mounted set. Each entry maps an env var name to a vault secret name. Pass an empty array to detach all secrets. */
+export type UpdateSandboxSecretsRequestSecretsList =
+  Array<UpdateSandboxSecretsRequestSecretsItemMap>;
+export const UpdateSandboxSecretsRequestSecretsList = /*@__PURE__*/ S.Array(
+  UpdateSandboxSecretsRequestSecretsItemMap,
+) as any as S.Schema<UpdateSandboxSecretsRequestSecretsList>;
+
+export interface UpdateSandboxSecretsRequest {
+  /** ID or name of the sandbox */
+  sandboxIdOrName: string;
+  /** Use with JWT to specify the organization ID */
+  xDaytonaOrganizationID?: string;
+  /** Secrets to mount in this sandbox, replacing the previously mounted set. Each entry maps an env var name to a vault secret name. Pass an empty array to detach all secrets. */
+  secrets: UpdateSandboxSecretsRequestSecretsList;
+}
+export const UpdateSandboxSecretsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    sandboxIdOrName: S.String.pipe(T.Label()),
+    xDaytonaOrganizationID: S.optional(
+      S.String.pipe(T.Header("X-Daytona-Organization-ID")),
+    ),
+    secrets: UpdateSandboxSecretsRequestSecretsList,
+  }).pipe(
+    T.Http({
+      method: "PUT",
+      uri: "/sandbox/{sandboxIdOrName}/secrets",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "UpdateSandboxSecretsRequest",
+}) as any as S.Schema<UpdateSandboxSecretsRequest>;
+
+/** The new state for the sandbox */
+export type UpdateSandboxStateRequestState =
+  | "creating"
+  | "restoring"
+  | "destroyed"
+  | "destroying"
+  | "started"
+  | "stopped"
+  | "starting"
+  | "stopping"
+  | "error"
+  | "build_failed"
+  | "pending_build"
+  | "building_snapshot"
+  | "unknown"
+  | "pulling_snapshot"
+  | "archived"
+  | "archiving"
+  | "resizing"
+  | "snapshotting"
+  | "forking"
+  | "pausing"
+  | "paused"
+  | "resuming";
+export const UpdateSandboxStateRequestState = S.String;
+
+export interface UpdateSandboxStateRequest {
+  /** ID of the sandbox */
+  sandboxId: string;
+  /** Use with JWT to specify the organization ID */
+  xDaytonaOrganizationID?: string;
+  /** The new state for the sandbox */
+  state: UpdateSandboxStateRequestState | (string & {});
+  /** Optional error message when reporting an error state */
+  errorReason?: string;
+  /** Whether the sandbox is recoverable */
+  recoverable?: boolean;
+}
+export const UpdateSandboxStateRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    sandboxId: S.String.pipe(T.Label()),
+    xDaytonaOrganizationID: S.optional(
+      S.String.pipe(T.Header("X-Daytona-Organization-ID")),
+    ),
+    state: UpdateSandboxStateRequestState,
+    errorReason: S.optional(S.String),
+    recoverable: S.optional(S.Boolean),
+  }).pipe(
+    T.Http({ method: "PUT", uri: "/sandbox/{sandboxId}/state", code: 200 }),
+  ),
+).annotate({
+  identifier: "UpdateSandboxStateRequest",
+}) as any as S.Schema<UpdateSandboxStateRequest>;
+
+export interface UpdateSandboxStateResponse {}
+export const UpdateSandboxStateResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "UpdateSandboxStateResponse",
+}) as any as S.Schema<UpdateSandboxStateResponse>;
+
+export interface ValidateSshAccessRequest {
+  /** SSH access token to validate */
+  token: string;
+  /** Use with JWT to specify the organization ID */
+  xDaytonaOrganizationID?: string;
+}
+export const ValidateSshAccessRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    token: S.String.pipe(T.Query()),
+    xDaytonaOrganizationID: S.optional(
+      S.String.pipe(T.Header("X-Daytona-Organization-ID")),
+    ),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/sandbox/ssh-access/validate", code: 200 }),
+  ),
+).annotate({
+  identifier: "ValidateSshAccessRequest",
+}) as any as S.Schema<ValidateSshAccessRequest>;
+
+export interface SshAccessValidationDto {
+  /** Whether the SSH access token is valid */
+  valid: boolean;
+  /** ID of the sandbox this SSH access is for */
+  sandboxId: string;
+}
+export const SshAccessValidationDto = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    valid: S.Boolean,
+    sandboxId: S.String,
+  }),
+).annotate({
+  identifier: "SshAccessValidationDto",
+}) as any as S.Schema<SshAccessValidationDto>;
+
+export type ArchiveSandboxError = DaytonaOpError;
+/** Archive sandbox */
+export const archiveSandbox: API.OperationMethod<
+  ArchiveSandboxRequest,
+  Sandbox2,
+  ArchiveSandboxError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ArchiveSandboxRequest,
+  output: Sandbox2,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateSandboxError = DaytonaOpError;
+/** Create a new sandbox */
+export const createSandbox: API.OperationMethod<
+  CreateSandboxRequest,
+  Sandbox2,
+  CreateSandboxError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateSandboxRequest,
+  output: Sandbox2,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateSandboxSnapshotError = DaytonaOpError;
+/** Create a snapshot from a sandbox */
+export const createSandboxSnapshot: API.OperationMethod<
+  CreateSandboxSnapshotRequest,
+  Sandbox2,
+  CreateSandboxSnapshotError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateSandboxSnapshotRequest,
+  output: Sandbox2,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateSshAccessError = DaytonaOpError;
+/** Create SSH access for sandbox */
+export const createSshAccess: API.OperationMethod<
+  CreateSshAccessRequest,
+  SshAccessDto,
+  CreateSshAccessError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateSshAccessRequest,
+  output: SshAccessDto,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteSandboxError = DaytonaOpError;
+/** Delete sandbox */
+export const deleteSandbox: API.OperationMethod<
+  DeleteSandboxRequest,
+  Sandbox2,
+  DeleteSandboxError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteSandboxRequest,
+  output: Sandbox2,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ExpireSignedPortPreviewUrlError = DaytonaOpError;
+/** Expire signed preview URL for a sandbox port */
+export const expireSignedPortPreviewUrl: API.OperationMethod<
+  ExpireSignedPortPreviewUrlRequest,
+  ExpireSignedPortPreviewUrlResponse,
+  ExpireSignedPortPreviewUrlError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ExpireSignedPortPreviewUrlRequest,
+  output: ExpireSignedPortPreviewUrlResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ForkSandboxError = DaytonaOpError;
+/** Fork a sandbox */
+export const forkSandbox: API.OperationMethod<
+  ForkSandboxRequest,
+  Sandbox2,
+  ForkSandboxError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ForkSandboxRequest,
+  output: Sandbox2,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetBuildLogsUrlError = DaytonaOpError;
+/** Get build logs URL */
+export const getBuildLogsUrl: API.OperationMethod<
+  GetBuildLogsUrlRequest,
+  Url,
+  GetBuildLogsUrlError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetBuildLogsUrlRequest,
+  output: Url,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetOrganizationBySandboxIdError = DaytonaOpError;
+/** Get organization by sandbox ID */
+export const getOrganizationBySandboxId: API.OperationMethod<
+  GetOrganizationBySandboxIdRequest,
+  Organization,
+  GetOrganizationBySandboxIdError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetOrganizationBySandboxIdRequest,
+  output: Organization,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetPortPreviewUrlError = DaytonaOpError;
+/** Get preview URL for a sandbox port */
+export const getPortPreviewUrl: API.OperationMethod<
+  GetPortPreviewUrlRequest,
+  PortPreviewUrl,
+  GetPortPreviewUrlError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetPortPreviewUrlRequest,
+  output: PortPreviewUrl,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetRegionQuotaBySandboxIdError = DaytonaOpError;
+/** Get region quota by sandbox ID */
+export const getRegionQuotaBySandboxId: API.OperationMethod<
+  GetRegionQuotaBySandboxIdRequest,
+  RegionQuota,
+  GetRegionQuotaBySandboxIdError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetRegionQuotaBySandboxIdRequest,
+  output: RegionQuota,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetSandboxError = DaytonaOpError;
+/** Get sandbox details Sandboxes destroyed by spot preemption remain retrievable for 24 hours so `spotEvictedAt` can be read. */
+export const getSandbox: API.OperationMethod<
+  GetSandboxRequest,
+  Sandbox2,
+  GetSandboxError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetSandboxRequest,
+  output: Sandbox2,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetSandboxAncestorsError = DaytonaOpError;
+/** Get sandbox fork ancestor chain */
+export const getSandboxAncestors: API.OperationMethod<
+  GetSandboxAncestorsRequest,
+  GetSandboxAncestorsResponse,
+  GetSandboxAncestorsError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetSandboxAncestorsRequest,
+  output: GetSandboxAncestorsResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetSandboxesForRunnerError = DaytonaOpError;
+/** Get sandboxes for the authenticated runner */
+export const getSandboxesForRunner: API.OperationMethod<
+  GetSandboxesForRunnerRequest,
+  GetSandboxesForRunnerResponse,
+  GetSandboxesForRunnerError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetSandboxesForRunnerRequest,
+  output: GetSandboxesForRunnerResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetSandboxForksError = DaytonaOpError;
+/** Get sandbox fork children */
+export const getSandboxForks: API.OperationMethod<
+  GetSandboxForksRequest,
+  GetSandboxForksResponse,
+  GetSandboxForksError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetSandboxForksRequest,
+  output: GetSandboxForksResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetSandboxLogsError = DaytonaOpError;
+/** Get sandbox logs Retrieve OTEL logs for a sandbox within a time range */
+export const getSandboxLogs: API.OperationMethod<
+  GetSandboxLogsRequest,
+  PaginatedLogs,
+  GetSandboxLogsError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetSandboxLogsRequest,
+  output: PaginatedLogs,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetSandboxMetricsError = DaytonaOpError;
+/** Get sandbox metrics Retrieve OTEL metrics for a sandbox within a time range */
+export const getSandboxMetrics: API.OperationMethod<
+  GetSandboxMetricsRequest,
+  MetricsResponse,
+  GetSandboxMetricsError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetSandboxMetricsRequest,
+  output: MetricsResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetSandboxParentError = DaytonaOpError;
+/** Get sandbox fork parent */
+export const getSandboxParent: API.OperationMethod<
+  GetSandboxParentRequest,
+  Sandbox2,
+  GetSandboxParentError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetSandboxParentRequest,
+  output: Sandbox2,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetSandboxSigningKeyError = DaytonaOpError;
+/** Get the signing key for a sandbox */
+export const getSandboxSigningKey: API.OperationMethod<
+  GetSandboxSigningKeyRequest,
+  GetSandboxSigningKeyResponse,
+  GetSandboxSigningKeyError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetSandboxSigningKeyRequest,
+  output: GetSandboxSigningKeyResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetSandboxTracesError = DaytonaOpError;
+/** Get sandbox traces Retrieve OTEL traces for a sandbox within a time range */
+export const getSandboxTraces: API.OperationMethod<
+  GetSandboxTracesRequest,
+  PaginatedTraces,
+  GetSandboxTracesError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetSandboxTracesRequest,
+  output: PaginatedTraces,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetSandboxTraceSpansError = DaytonaOpError;
+/** Get trace spans Retrieve all spans for a specific trace */
+export const getSandboxTraceSpans: API.OperationMethod<
+  GetSandboxTraceSpansRequest,
+  GetSandboxTraceSpansResponse,
+  GetSandboxTraceSpansError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetSandboxTraceSpansRequest,
+  output: GetSandboxTraceSpansResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetSignedPortPreviewUrlError = DaytonaOpError;
+/** Get signed preview URL for a sandbox port */
+export const getSignedPortPreviewUrl: API.OperationMethod<
+  GetSignedPortPreviewUrlRequest,
+  SignedPortPreviewUrl,
+  GetSignedPortPreviewUrlError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetSignedPortPreviewUrlRequest,
+  output: SignedPortPreviewUrl,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetToolboxProxyUrlError = DaytonaOpError;
+/** Get toolbox proxy URL for a sandbox */
+export const getToolboxProxyUrl: API.OperationMethod<
+  GetToolboxProxyUrlRequest,
+  ToolboxProxyUrl,
+  GetToolboxProxyUrlError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetToolboxProxyUrlRequest,
+  output: ToolboxProxyUrl,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListSandboxesError = DaytonaOpError;
+/** List sandboxes Advanced filtering and ordering. Eventually consistent. */
+export const listSandboxes: API.OperationMethod<
+  ListSandboxesRequest,
+  ListSandboxesResponse,
+  ListSandboxesError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListSandboxesRequest,
+  output: ListSandboxesResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PauseSandboxError = DaytonaOpError;
+/** Pause sandbox */
+export const pauseSandbox: API.OperationMethod<
+  PauseSandboxRequest,
+  Sandbox2,
+  PauseSandboxError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PauseSandboxRequest,
+  output: Sandbox2,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type RecoverSandboxError = DaytonaOpError;
+/** Recover sandbox from error state */
+export const recoverSandbox: API.OperationMethod<
+  RecoverSandboxRequest,
+  Sandbox2,
+  RecoverSandboxError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: RecoverSandboxRequest,
+  output: Sandbox2,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ReplaceLabelsError = DaytonaOpError;
+/** Replace sandbox labels */
+export const replaceLabels: API.OperationMethod<
+  ReplaceLabelsRequest,
+  SandboxLabels,
+  ReplaceLabelsError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ReplaceLabelsRequest,
+  output: SandboxLabels,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ResizeSandboxError = DaytonaOpError;
+/** Resize sandbox resources */
+export const resizeSandbox: API.OperationMethod<
+  ResizeSandboxRequest,
+  Sandbox2,
+  ResizeSandboxError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ResizeSandboxRequest,
+  output: Sandbox2,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ResolveSandboxSecretsError = DaytonaOpError;
+/** Resolve sandbox secrets */
+export const resolveSandboxSecrets: API.OperationMethod<
+  ResolveSandboxSecretsRequest,
+  ResolveSandboxSecretsResponse,
+  ResolveSandboxSecretsError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ResolveSandboxSecretsRequest,
+  output: ResolveSandboxSecretsResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type RevokeSshAccessError = DaytonaOpError;
+/** Revoke SSH access for sandbox */
+export const revokeSshAccess: API.OperationMethod<
+  RevokeSshAccessRequest,
+  Sandbox2,
+  RevokeSshAccessError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: RevokeSshAccessRequest,
+  output: Sandbox2,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type RotateSigningKeyError = DaytonaOpError;
+/** Rotate the signing key, invalidating all previously signed URLs */
+export const rotateSigningKey: API.OperationMethod<
+  RotateSigningKeyRequest,
+  RotateSigningKeyResponse,
+  RotateSigningKeyError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: RotateSigningKeyRequest,
+  output: RotateSigningKeyResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type SetAutoArchiveIntervalError = DaytonaOpError;
+/** Set sandbox auto-archive interval */
+export const setAutoArchiveInterval: API.OperationMethod<
+  SetAutoArchiveIntervalRequest,
+  Sandbox2,
+  SetAutoArchiveIntervalError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: SetAutoArchiveIntervalRequest,
+  output: Sandbox2,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type SetAutoDeleteIntervalError = DaytonaOpError;
+/** Set sandbox auto-delete interval */
+export const setAutoDeleteInterval: API.OperationMethod<
+  SetAutoDeleteIntervalRequest,
+  Sandbox2,
+  SetAutoDeleteIntervalError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: SetAutoDeleteIntervalRequest,
+  output: Sandbox2,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type SetAutoPauseIntervalError = DaytonaOpError;
+/** Set sandbox auto-pause interval */
+export const setAutoPauseInterval: API.OperationMethod<
+  SetAutoPauseIntervalRequest,
+  Sandbox2,
+  SetAutoPauseIntervalError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: SetAutoPauseIntervalRequest,
+  output: Sandbox2,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type SetAutostopIntervalError = DaytonaOpError;
+/** Set sandbox auto-stop interval */
+export const setAutostopInterval: API.OperationMethod<
+  SetAutostopIntervalRequest,
+  Sandbox2,
+  SetAutostopIntervalError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: SetAutostopIntervalRequest,
+  output: Sandbox2,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type SetTtlError = DaytonaOpError;
+/** Set sandbox TTL */
+export const setTtl: API.OperationMethod<
+  SetTtlRequest,
+  Sandbox2,
+  SetTtlError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: SetTtlRequest,
+  output: Sandbox2,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type StartSandboxError = DaytonaOpError;
+/** Start or resume sandbox Starts a stopped or archived sandbox, or resumes a paused sandbox. The transition taken depends on the current sandbox state. */
+export const startSandbox: API.OperationMethod<
+  StartSandboxRequest,
+  Sandbox2,
+  StartSandboxError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: StartSandboxRequest,
+  output: Sandbox2,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type StopSandboxError = DaytonaOpError;
+/** Stop sandbox */
+export const stopSandbox: API.OperationMethod<
+  StopSandboxRequest,
+  Sandbox2,
+  StopSandboxError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: StopSandboxRequest,
+  output: Sandbox2,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UpdateLastActivityError = DaytonaOpError;
+/** Update sandbox last activity */
+export const updateLastActivity: API.OperationMethod<
+  UpdateLastActivityRequest,
+  UpdateLastActivityResponse,
+  UpdateLastActivityError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UpdateLastActivityRequest,
+  output: UpdateLastActivityResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UpdateNetworkSettingsError = DaytonaOpError;
+/** Update sandbox network settings Changes outbound network policy on the runner for a running sandbox (for example block all traffic, restore access, or set a CIDR allow list). */
+export const updateNetworkSettings: API.OperationMethod<
+  UpdateNetworkSettingsRequest,
+  Sandbox2,
+  UpdateNetworkSettingsError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UpdateNetworkSettingsRequest,
+  output: Sandbox2,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UpdatePublicStatusError = DaytonaOpError;
+/** Update public status */
+export const updatePublicStatus: API.OperationMethod<
+  UpdatePublicStatusRequest,
+  Sandbox2,
+  UpdatePublicStatusError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UpdatePublicStatusRequest,
+  output: Sandbox2,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UpdateSandboxSecretsError = DaytonaOpError;
+/** Update sandbox secrets Replaces the set of vault secrets mounted in the sandbox. Attached, detached and rotated secrets take effect for outbound requests within seconds. New env vars become visible to processes spawned after the update; a sandbox created without any secrets must be restarted for newly attached secrets to work. */
+export const updateSandboxSecrets: API.OperationMethod<
+  UpdateSandboxSecretsRequest,
+  Sandbox2,
+  UpdateSandboxSecretsError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UpdateSandboxSecretsRequest,
+  output: Sandbox2,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UpdateSandboxStateError = DaytonaOpError;
+/** Update sandbox state */
+export const updateSandboxState: API.OperationMethod<
+  UpdateSandboxStateRequest,
+  UpdateSandboxStateResponse,
+  UpdateSandboxStateError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UpdateSandboxStateRequest,
+  output: UpdateSandboxStateResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ValidateSshAccessError = DaytonaOpError;
+/** Validate SSH access for sandbox */
+export const validateSshAccess: API.OperationMethod<
+  ValidateSshAccessRequest,
+  SshAccessValidationDto,
+  ValidateSshAccessError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ValidateSshAccessRequest,
+  output: SshAccessValidationDto,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));