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

package/lib/services/sandbox.d.ts

@@ -0,0 +1,1276 @@
+import * as S from "@distilled.cloud/core/schema";
+import * as API from "@distilled.cloud/core/api";
+import { type DaytonaOpError, type DaytonaOpContext } from "../protocol.ts";
+export type { DaytonaOpError, DaytonaOpContext };
+export interface ArchiveSandboxRequest {
+    sandboxIdOrName: string;
+    /** Use with JWT to specify the organization ID */
+    xDaytonaOrganizationID?: string;
+}
+export declare const ArchiveSandboxRequest: S.Schema<ArchiveSandboxRequest>;
+/** Environment variables for the sandbox */
+export type SandboxEnvMap = {
+    [key: string]: string | undefined;
+};
+export declare const SandboxEnvMap: S.Schema<SandboxEnvMap>;
+/** Labels for the sandbox */
+export type SandboxLabelsMap = {
+    [key: string]: string | undefined;
+};
+export declare const SandboxLabelsMap: S.Schema<SandboxLabelsMap>;
+export type GpuType = "H100" | "H200" | "RTX-PRO-6000" | "RTX-4090" | "RTX-5090" | "MI355X";
+export declare const GpuType: any;
+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 declare const SandboxState: any;
+/** The desired state of the sandbox */
+export type SandboxDesiredState = "destroyed" | "started" | "stopped" | "resized" | "archived" | "paused";
+export declare const SandboxDesiredState: any;
+/** The state of the backup */
+export type SandboxBackupState = "None" | "Pending" | "InProgress" | "Completed" | "Error";
+export declare const SandboxBackupState: any;
+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 declare const SandboxVolume: S.Schema<SandboxVolume>;
+/** Array of volumes attached to the sandbox */
+export type SandboxVolumesList = Array<SandboxVolume>;
+export declare const SandboxVolumesList: S.Schema<SandboxVolumesList>;
+/** The context hashes used for the build */
+export type BuildInfoContextHashesList = Array<string>;
+export declare const BuildInfoContextHashesList: 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 declare const BuildInfo: S.Schema<BuildInfo>;
+/** The class of the sandbox */
+export type SandboxSandboxClass = "linux-vm" | "container" | "android" | "windows";
+export declare const SandboxSandboxClass: any;
+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 declare const Sandbox2: S.Schema<Sandbox2>;
+/** Environment variables for the sandbox */
+export type CreateSandboxRequestEnvMap = {
+    [key: string]: string | undefined;
+};
+export declare const CreateSandboxRequestEnvMap: S.Schema<CreateSandboxRequestEnvMap>;
+/** Labels for the sandbox */
+export type CreateSandboxRequestLabelsMap = {
+    [key: string]: string | undefined;
+};
+export declare const CreateSandboxRequestLabelsMap: 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 declare const CreateSandboxRequestGpuTypeList: S.Schema<CreateSandboxRequestGpuTypeList>;
+/** Array of volumes to attach to the sandbox */
+export type CreateSandboxRequestVolumesList = Array<SandboxVolume>;
+export declare const CreateSandboxRequestVolumesList: S.Schema<CreateSandboxRequestVolumesList>;
+/** The context hashes used for the build */
+export type CreateBuildInfoContextHashesList = Array<string>;
+export declare const CreateBuildInfoContextHashesList: 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 declare const CreateBuildInfo: S.Schema<CreateBuildInfo>;
+export type CreateSandboxRequestSecretsItemMap = {
+    [key: string]: string | undefined;
+};
+export declare const CreateSandboxRequestSecretsItemMap: 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 declare const CreateSandboxRequestSecretsList: 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 declare const CreateSandboxRequest: 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 declare const CreateSandboxSnapshotRequest: 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 declare const CreateSshAccessRequest: 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 declare const SshAccessDto: 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 declare const DeleteSandboxRequest: 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 declare const ExpireSignedPortPreviewUrlRequest: S.Schema<ExpireSignedPortPreviewUrlRequest>;
+export interface ExpireSignedPortPreviewUrlResponse {
+}
+export declare const ExpireSignedPortPreviewUrlResponse: 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 declare const ForkSandboxRequest: 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 declare const GetBuildLogsUrlRequest: S.Schema<GetBuildLogsUrlRequest>;
+export interface Url {
+    /** URL response */
+    url: string;
+}
+export declare const Url: S.Schema<Url>;
+export interface GetOrganizationBySandboxIdRequest {
+    /** ID of the sandbox */
+    sandboxId: string;
+    /** Use with JWT to specify the organization ID */
+    xDaytonaOrganizationID?: string;
+}
+export declare const GetOrganizationBySandboxIdRequest: S.Schema<GetOrganizationBySandboxIdRequest>;
+/** Headers */
+export type OtelConfigHeadersMap = {
+    [key: string]: string | undefined;
+};
+export declare const OtelConfigHeadersMap: S.Schema<OtelConfigHeadersMap>;
+export interface OtelConfig {
+    /** Endpoint */
+    endpoint: string;
+    /** Headers */
+    headers?: OtelConfigHeadersMap | null;
+    /** Organization ID the config belongs to */
+    organizationId?: string;
+}
+export declare const OtelConfig: 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 declare const Organization: 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 declare const GetPortPreviewUrlRequest: S.Schema<GetPortPreviewUrlRequest>;
+export interface PortPreviewUrl {
+    /** ID of the sandbox */
+    sandboxId: string;
+    /** Preview url */
+    url: string;
+    /** Access token */
+    token: string;
+}
+export declare const PortPreviewUrl: S.Schema<PortPreviewUrl>;
+export interface GetRegionQuotaBySandboxIdRequest {
+    /** ID of the sandbox */
+    sandboxId: string;
+    /** Use with JWT to specify the organization ID */
+    xDaytonaOrganizationID?: string;
+}
+export declare const GetRegionQuotaBySandboxIdRequest: S.Schema<GetRegionQuotaBySandboxIdRequest>;
+export type SandboxClass = "linux-vm" | "container" | "android" | "windows";
+export declare const SandboxClass: any;
+export type RegionQuotaAllowedGpuTypesList = Array<GpuType>;
+export declare const RegionQuotaAllowedGpuTypesList: 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 declare const RegionQuota: 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 declare const GetSandboxRequest: S.Schema<GetSandboxRequest>;
+export interface GetSandboxAncestorsRequest {
+    sandboxIdOrName: string;
+    /** Use with JWT to specify the organization ID */
+    xDaytonaOrganizationID?: string;
+}
+export declare const GetSandboxAncestorsRequest: S.Schema<GetSandboxAncestorsRequest>;
+export type GetSandboxAncestorsResponseBodyList = Array<Sandbox2>;
+export declare const GetSandboxAncestorsResponseBodyList: S.Schema<GetSandboxAncestorsResponseBodyList>;
+export type GetSandboxAncestorsResponse = GetSandboxAncestorsResponseBodyList;
+export declare const GetSandboxAncestorsResponse: 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 declare const GetSandboxesForRunnerRequest: S.Schema<GetSandboxesForRunnerRequest>;
+export type GetSandboxesForRunnerResponseBodyList = Array<Sandbox2>;
+export declare const GetSandboxesForRunnerResponseBodyList: S.Schema<GetSandboxesForRunnerResponseBodyList>;
+export type GetSandboxesForRunnerResponse = GetSandboxesForRunnerResponseBodyList;
+export declare const GetSandboxesForRunnerResponse: S.Schema<GetSandboxesForRunnerResponse>;
+export interface GetSandboxForksRequest {
+    sandboxIdOrName: string;
+    includeDestroyed?: boolean;
+    /** Use with JWT to specify the organization ID */
+    xDaytonaOrganizationID?: string;
+}
+export declare const GetSandboxForksRequest: S.Schema<GetSandboxForksRequest>;
+export type GetSandboxForksResponseBodyList = Array<Sandbox2>;
+export declare const GetSandboxForksResponseBodyList: S.Schema<GetSandboxForksResponseBodyList>;
+export type GetSandboxForksResponse = GetSandboxForksResponseBodyList;
+export declare const GetSandboxForksResponse: S.Schema<GetSandboxForksResponse>;
+export type GetSandboxLogsRequestSeveritiesList = Array<string>;
+export declare const GetSandboxLogsRequestSeveritiesList: 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 declare const GetSandboxLogsRequest: S.Schema<GetSandboxLogsRequest>;
+/** Resource attributes from OTEL */
+export type LogEntryResourceAttributesMap = {
+    [key: string]: string | undefined;
+};
+export declare const LogEntryResourceAttributesMap: S.Schema<LogEntryResourceAttributesMap>;
+/** Log-specific attributes */
+export type LogEntryLogAttributesMap = {
+    [key: string]: string | undefined;
+};
+export declare const LogEntryLogAttributesMap: 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 declare const LogEntry: S.Schema<LogEntry>;
+/** List of log entries */
+export type PaginatedLogsItemsList = Array<LogEntry>;
+export declare const PaginatedLogsItemsList: 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 declare const PaginatedLogs: S.Schema<PaginatedLogs>;
+export type GetSandboxMetricsRequestMetricNamesList = Array<string>;
+export declare const GetSandboxMetricsRequestMetricNamesList: 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 declare const GetSandboxMetricsRequest: S.Schema<GetSandboxMetricsRequest>;
+export interface MetricDataPoint {
+    /** Timestamp of the data point */
+    timestamp: string;
+    /** Value at this timestamp */
+    value: number;
+}
+export declare const MetricDataPoint: S.Schema<MetricDataPoint>;
+/** Data points for this metric */
+export type MetricSeriesDataPointsList = Array<MetricDataPoint>;
+export declare const MetricSeriesDataPointsList: S.Schema<MetricSeriesDataPointsList>;
+export interface MetricSeries {
+    /** Name of the metric */
+    metricName: string;
+    /** Data points for this metric */
+    dataPoints: MetricSeriesDataPointsList;
+}
+export declare const MetricSeries: S.Schema<MetricSeries>;
+/** List of metric series */
+export type MetricsResponseSeriesList = Array<MetricSeries>;
+export declare const MetricsResponseSeriesList: S.Schema<MetricsResponseSeriesList>;
+export interface MetricsResponse {
+    /** List of metric series */
+    series: MetricsResponseSeriesList;
+}
+export declare const MetricsResponse: S.Schema<MetricsResponse>;
+export interface GetSandboxParentRequest {
+    sandboxIdOrName: string;
+    /** Use with JWT to specify the organization ID */
+    xDaytonaOrganizationID?: string;
+}
+export declare const GetSandboxParentRequest: S.Schema<GetSandboxParentRequest>;
+export interface GetSandboxSigningKeyRequest {
+    /** ID of the sandbox */
+    sandboxId: string;
+    /** Use with JWT to specify the organization ID */
+    xDaytonaOrganizationID?: string;
+}
+export declare const GetSandboxSigningKeyRequest: S.Schema<GetSandboxSigningKeyRequest>;
+export type GetSandboxSigningKeyResponse = string;
+export declare const GetSandboxSigningKeyResponse: 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 declare const GetSandboxTracesRequest: 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 declare const TraceSummary: S.Schema<TraceSummary>;
+/** List of trace summaries */
+export type PaginatedTracesItemsList = Array<TraceSummary>;
+export declare const PaginatedTracesItemsList: 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 declare const PaginatedTraces: 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 declare const GetSandboxTraceSpansRequest: S.Schema<GetSandboxTraceSpansRequest>;
+/** Span attributes */
+export type TraceSpanSpanAttributesMap = {
+    [key: string]: string | undefined;
+};
+export declare const TraceSpanSpanAttributesMap: 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 declare const TraceSpan: S.Schema<TraceSpan>;
+export type GetSandboxTraceSpansResponseBodyList = Array<TraceSpan>;
+export declare const GetSandboxTraceSpansResponseBodyList: S.Schema<GetSandboxTraceSpansResponseBodyList>;
+export type GetSandboxTraceSpansResponse = GetSandboxTraceSpansResponseBodyList;
+export declare const GetSandboxTraceSpansResponse: 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 declare const GetSignedPortPreviewUrlRequest: 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 declare const SignedPortPreviewUrl: S.Schema<SignedPortPreviewUrl>;
+export interface GetToolboxProxyUrlRequest {
+    /** ID of the sandbox */
+    sandboxId: string;
+    /** Use with JWT to specify the organization ID */
+    xDaytonaOrganizationID?: string;
+}
+export declare const GetToolboxProxyUrlRequest: S.Schema<GetToolboxProxyUrlRequest>;
+export interface ToolboxProxyUrl {
+    /** The toolbox proxy URL for the sandbox */
+    url: string;
+}
+export declare const ToolboxProxyUrl: S.Schema<ToolboxProxyUrl>;
+export type ListSandboxesRequestStatesList = Array<SandboxState | (string & {})>;
+export declare const ListSandboxesRequestStatesList: S.Schema<ListSandboxesRequestStatesList>;
+export type ListSandboxesRequestSnapshotsList = Array<string>;
+export declare const ListSandboxesRequestSnapshotsList: S.Schema<ListSandboxesRequestSnapshotsList>;
+export type ListSandboxesRequestRegionIdsList = Array<string>;
+export declare const ListSandboxesRequestRegionIdsList: S.Schema<ListSandboxesRequestRegionIdsList>;
+export type ListSandboxesRequestSandboxClassesList = Array<SandboxClass | (string & {})>;
+export declare const ListSandboxesRequestSandboxClassesList: S.Schema<ListSandboxesRequestSandboxClassesList>;
+export type SandboxListSortField = "name" | "cpu" | "memoryGib" | "diskGib" | "lastActivityAt" | "createdAt";
+export declare const SandboxListSortField: any;
+export type SandboxListSortDirection = "asc" | "desc";
+export declare const SandboxListSortDirection: any;
+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 declare const ListSandboxesRequest: S.Schema<ListSandboxesRequest>;
+/** Labels for the sandbox */
+export type SandboxListItemLabelsMap = {
+    [key: string]: string | undefined;
+};
+export declare const SandboxListItemLabelsMap: S.Schema<SandboxListItemLabelsMap>;
+/** The state of the backup */
+export type SandboxListItemBackupState = "None" | "Pending" | "InProgress" | "Completed" | "Error";
+export declare const SandboxListItemBackupState: any;
+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 declare const SandboxListItem: S.Schema<SandboxListItem>;
+/** List of results for the current page */
+export type ListSandboxesResponseItemsList = Array<SandboxListItem>;
+export declare const ListSandboxesResponseItemsList: 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 declare const ListSandboxesResponse: 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 declare const PauseSandboxRequest: 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 declare const RecoverSandboxRequest: S.Schema<RecoverSandboxRequest>;
+/** Key-value pairs of labels */
+export type ReplaceLabelsRequestLabelsMap = {
+    [key: string]: string | undefined;
+};
+export declare const ReplaceLabelsRequestLabelsMap: 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 declare const ReplaceLabelsRequest: S.Schema<ReplaceLabelsRequest>;
+/** Key-value pairs of labels */
+export type SandboxLabelsLabelsMap = {
+    [key: string]: string | undefined;
+};
+export declare const SandboxLabelsLabelsMap: S.Schema<SandboxLabelsLabelsMap>;
+export interface SandboxLabels {
+    /** Key-value pairs of labels */
+    labels: SandboxLabelsLabelsMap;
+}
+export declare const SandboxLabels: 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 declare const ResizeSandboxRequest: S.Schema<ResizeSandboxRequest>;
+export interface ResolveSandboxSecretsRequest {
+    /** Sandbox ID */
+    sandboxId: string;
+    /** Use with JWT to specify the organization ID */
+    xDaytonaOrganizationID?: string;
+}
+export declare const ResolveSandboxSecretsRequest: S.Schema<ResolveSandboxSecretsRequest>;
+export type ResolveSandboxSecrets200ResponseInnerHostsList = Array<string>;
+export declare const ResolveSandboxSecrets200ResponseInnerHostsList: S.Schema<ResolveSandboxSecrets200ResponseInnerHostsList>;
+export interface ResolveSandboxSecrets200ResponseInner {
+    env?: string;
+    placeholder?: string;
+    value?: string;
+    hosts?: ResolveSandboxSecrets200ResponseInnerHostsList;
+}
+export declare const ResolveSandboxSecrets200ResponseInner: S.Schema<ResolveSandboxSecrets200ResponseInner>;
+export type ResolveSandboxSecretsResponseBodyList = Array<ResolveSandboxSecrets200ResponseInner>;
+export declare const ResolveSandboxSecretsResponseBodyList: S.Schema<ResolveSandboxSecretsResponseBodyList>;
+export type ResolveSandboxSecretsResponse = ResolveSandboxSecretsResponseBodyList;
+export declare const ResolveSandboxSecretsResponse: 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 declare const RevokeSshAccessRequest: S.Schema<RevokeSshAccessRequest>;
+export interface RotateSigningKeyRequest {
+    /** ID of the sandbox */
+    sandboxId: string;
+    /** Use with JWT to specify the organization ID */
+    xDaytonaOrganizationID?: string;
+}
+export declare const RotateSigningKeyRequest: S.Schema<RotateSigningKeyRequest>;
+export type RotateSigningKeyResponse = string;
+export declare const RotateSigningKeyResponse: 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 declare const SetAutoArchiveIntervalRequest: 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 declare const SetAutoDeleteIntervalRequest: 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 declare const SetAutoPauseIntervalRequest: 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 declare const SetAutostopIntervalRequest: 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 declare const SetTtlRequest: 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 declare const StartSandboxRequest: 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 declare const StopSandboxRequest: 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 declare const UpdateLastActivityRequest: S.Schema<UpdateLastActivityRequest>;
+export interface UpdateLastActivityResponse {
+}
+export declare const UpdateLastActivityResponse: 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 declare const UpdateNetworkSettingsRequest: 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 declare const UpdatePublicStatusRequest: S.Schema<UpdatePublicStatusRequest>;
+export type UpdateSandboxSecretsRequestSecretsItemMap = {
+    [key: string]: string | undefined;
+};
+export declare const UpdateSandboxSecretsRequestSecretsItemMap: 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 declare const UpdateSandboxSecretsRequestSecretsList: 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 declare const UpdateSandboxSecretsRequest: 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 declare const UpdateSandboxStateRequestState: any;
+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 declare const UpdateSandboxStateRequest: S.Schema<UpdateSandboxStateRequest>;
+export interface UpdateSandboxStateResponse {
+}
+export declare const UpdateSandboxStateResponse: S.Schema<UpdateSandboxStateResponse>;
+export interface ValidateSshAccessRequest {
+    /** SSH access token to validate */
+    token: string;
+    /** Use with JWT to specify the organization ID */
+    xDaytonaOrganizationID?: string;
+}
+export declare const ValidateSshAccessRequest: 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 declare const SshAccessValidationDto: S.Schema<SshAccessValidationDto>;
+export type ArchiveSandboxError = DaytonaOpError;
+/** Archive sandbox */
+export declare const archiveSandbox: API.OperationMethod<ArchiveSandboxRequest, Sandbox2, ArchiveSandboxError, DaytonaOpContext>;
+export type CreateSandboxError = DaytonaOpError;
+/** Create a new sandbox */
+export declare const createSandbox: API.OperationMethod<CreateSandboxRequest, Sandbox2, CreateSandboxError, DaytonaOpContext>;
+export type CreateSandboxSnapshotError = DaytonaOpError;
+/** Create a snapshot from a sandbox */
+export declare const createSandboxSnapshot: API.OperationMethod<CreateSandboxSnapshotRequest, Sandbox2, CreateSandboxSnapshotError, DaytonaOpContext>;
+export type CreateSshAccessError = DaytonaOpError;
+/** Create SSH access for sandbox */
+export declare const createSshAccess: API.OperationMethod<CreateSshAccessRequest, SshAccessDto, CreateSshAccessError, DaytonaOpContext>;
+export type DeleteSandboxError = DaytonaOpError;
+/** Delete sandbox */
+export declare const deleteSandbox: API.OperationMethod<DeleteSandboxRequest, Sandbox2, DeleteSandboxError, DaytonaOpContext>;
+export type ExpireSignedPortPreviewUrlError = DaytonaOpError;
+/** Expire signed preview URL for a sandbox port */
+export declare const expireSignedPortPreviewUrl: API.OperationMethod<ExpireSignedPortPreviewUrlRequest, ExpireSignedPortPreviewUrlResponse, ExpireSignedPortPreviewUrlError, DaytonaOpContext>;
+export type ForkSandboxError = DaytonaOpError;
+/** Fork a sandbox */
+export declare const forkSandbox: API.OperationMethod<ForkSandboxRequest, Sandbox2, ForkSandboxError, DaytonaOpContext>;
+export type GetBuildLogsUrlError = DaytonaOpError;
+/** Get build logs URL */
+export declare const getBuildLogsUrl: API.OperationMethod<GetBuildLogsUrlRequest, Url, GetBuildLogsUrlError, DaytonaOpContext>;
+export type GetOrganizationBySandboxIdError = DaytonaOpError;
+/** Get organization by sandbox ID */
+export declare const getOrganizationBySandboxId: API.OperationMethod<GetOrganizationBySandboxIdRequest, Organization, GetOrganizationBySandboxIdError, DaytonaOpContext>;
+export type GetPortPreviewUrlError = DaytonaOpError;
+/** Get preview URL for a sandbox port */
+export declare const getPortPreviewUrl: API.OperationMethod<GetPortPreviewUrlRequest, PortPreviewUrl, GetPortPreviewUrlError, DaytonaOpContext>;
+export type GetRegionQuotaBySandboxIdError = DaytonaOpError;
+/** Get region quota by sandbox ID */
+export declare const getRegionQuotaBySandboxId: API.OperationMethod<GetRegionQuotaBySandboxIdRequest, RegionQuota, GetRegionQuotaBySandboxIdError, DaytonaOpContext>;
+export type GetSandboxError = DaytonaOpError;
+/** Get sandbox details Sandboxes destroyed by spot preemption remain retrievable for 24 hours so `spotEvictedAt` can be read. */
+export declare const getSandbox: API.OperationMethod<GetSandboxRequest, Sandbox2, GetSandboxError, DaytonaOpContext>;
+export type GetSandboxAncestorsError = DaytonaOpError;
+/** Get sandbox fork ancestor chain */
+export declare const getSandboxAncestors: API.OperationMethod<GetSandboxAncestorsRequest, GetSandboxAncestorsResponse, GetSandboxAncestorsError, DaytonaOpContext>;
+export type GetSandboxesForRunnerError = DaytonaOpError;
+/** Get sandboxes for the authenticated runner */
+export declare const getSandboxesForRunner: API.OperationMethod<GetSandboxesForRunnerRequest, GetSandboxesForRunnerResponse, GetSandboxesForRunnerError, DaytonaOpContext>;
+export type GetSandboxForksError = DaytonaOpError;
+/** Get sandbox fork children */
+export declare const getSandboxForks: API.OperationMethod<GetSandboxForksRequest, GetSandboxForksResponse, GetSandboxForksError, DaytonaOpContext>;
+export type GetSandboxLogsError = DaytonaOpError;
+/** Get sandbox logs Retrieve OTEL logs for a sandbox within a time range */
+export declare const getSandboxLogs: API.OperationMethod<GetSandboxLogsRequest, PaginatedLogs, GetSandboxLogsError, DaytonaOpContext>;
+export type GetSandboxMetricsError = DaytonaOpError;
+/** Get sandbox metrics Retrieve OTEL metrics for a sandbox within a time range */
+export declare const getSandboxMetrics: API.OperationMethod<GetSandboxMetricsRequest, MetricsResponse, GetSandboxMetricsError, DaytonaOpContext>;
+export type GetSandboxParentError = DaytonaOpError;
+/** Get sandbox fork parent */
+export declare const getSandboxParent: API.OperationMethod<GetSandboxParentRequest, Sandbox2, GetSandboxParentError, DaytonaOpContext>;
+export type GetSandboxSigningKeyError = DaytonaOpError;
+/** Get the signing key for a sandbox */
+export declare const getSandboxSigningKey: API.OperationMethod<GetSandboxSigningKeyRequest, GetSandboxSigningKeyResponse, GetSandboxSigningKeyError, DaytonaOpContext>;
+export type GetSandboxTracesError = DaytonaOpError;
+/** Get sandbox traces Retrieve OTEL traces for a sandbox within a time range */
+export declare const getSandboxTraces: API.OperationMethod<GetSandboxTracesRequest, PaginatedTraces, GetSandboxTracesError, DaytonaOpContext>;
+export type GetSandboxTraceSpansError = DaytonaOpError;
+/** Get trace spans Retrieve all spans for a specific trace */
+export declare const getSandboxTraceSpans: API.OperationMethod<GetSandboxTraceSpansRequest, GetSandboxTraceSpansResponse, GetSandboxTraceSpansError, DaytonaOpContext>;
+export type GetSignedPortPreviewUrlError = DaytonaOpError;
+/** Get signed preview URL for a sandbox port */
+export declare const getSignedPortPreviewUrl: API.OperationMethod<GetSignedPortPreviewUrlRequest, SignedPortPreviewUrl, GetSignedPortPreviewUrlError, DaytonaOpContext>;
+export type GetToolboxProxyUrlError = DaytonaOpError;
+/** Get toolbox proxy URL for a sandbox */
+export declare const getToolboxProxyUrl: API.OperationMethod<GetToolboxProxyUrlRequest, ToolboxProxyUrl, GetToolboxProxyUrlError, DaytonaOpContext>;
+export type ListSandboxesError = DaytonaOpError;
+/** List sandboxes Advanced filtering and ordering. Eventually consistent. */
+export declare const listSandboxes: API.OperationMethod<ListSandboxesRequest, ListSandboxesResponse, ListSandboxesError, DaytonaOpContext>;
+export type PauseSandboxError = DaytonaOpError;
+/** Pause sandbox */
+export declare const pauseSandbox: API.OperationMethod<PauseSandboxRequest, Sandbox2, PauseSandboxError, DaytonaOpContext>;
+export type RecoverSandboxError = DaytonaOpError;
+/** Recover sandbox from error state */
+export declare const recoverSandbox: API.OperationMethod<RecoverSandboxRequest, Sandbox2, RecoverSandboxError, DaytonaOpContext>;
+export type ReplaceLabelsError = DaytonaOpError;
+/** Replace sandbox labels */
+export declare const replaceLabels: API.OperationMethod<ReplaceLabelsRequest, SandboxLabels, ReplaceLabelsError, DaytonaOpContext>;
+export type ResizeSandboxError = DaytonaOpError;
+/** Resize sandbox resources */
+export declare const resizeSandbox: API.OperationMethod<ResizeSandboxRequest, Sandbox2, ResizeSandboxError, DaytonaOpContext>;
+export type ResolveSandboxSecretsError = DaytonaOpError;
+/** Resolve sandbox secrets */
+export declare const resolveSandboxSecrets: API.OperationMethod<ResolveSandboxSecretsRequest, ResolveSandboxSecretsResponse, ResolveSandboxSecretsError, DaytonaOpContext>;
+export type RevokeSshAccessError = DaytonaOpError;
+/** Revoke SSH access for sandbox */
+export declare const revokeSshAccess: API.OperationMethod<RevokeSshAccessRequest, Sandbox2, RevokeSshAccessError, DaytonaOpContext>;
+export type RotateSigningKeyError = DaytonaOpError;
+/** Rotate the signing key, invalidating all previously signed URLs */
+export declare const rotateSigningKey: API.OperationMethod<RotateSigningKeyRequest, RotateSigningKeyResponse, RotateSigningKeyError, DaytonaOpContext>;
+export type SetAutoArchiveIntervalError = DaytonaOpError;
+/** Set sandbox auto-archive interval */
+export declare const setAutoArchiveInterval: API.OperationMethod<SetAutoArchiveIntervalRequest, Sandbox2, SetAutoArchiveIntervalError, DaytonaOpContext>;
+export type SetAutoDeleteIntervalError = DaytonaOpError;
+/** Set sandbox auto-delete interval */
+export declare const setAutoDeleteInterval: API.OperationMethod<SetAutoDeleteIntervalRequest, Sandbox2, SetAutoDeleteIntervalError, DaytonaOpContext>;
+export type SetAutoPauseIntervalError = DaytonaOpError;
+/** Set sandbox auto-pause interval */
+export declare const setAutoPauseInterval: API.OperationMethod<SetAutoPauseIntervalRequest, Sandbox2, SetAutoPauseIntervalError, DaytonaOpContext>;
+export type SetAutostopIntervalError = DaytonaOpError;
+/** Set sandbox auto-stop interval */
+export declare const setAutostopInterval: API.OperationMethod<SetAutostopIntervalRequest, Sandbox2, SetAutostopIntervalError, DaytonaOpContext>;
+export type SetTtlError = DaytonaOpError;
+/** Set sandbox TTL */
+export declare const setTtl: API.OperationMethod<SetTtlRequest, Sandbox2, SetTtlError, DaytonaOpContext>;
+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 declare const startSandbox: API.OperationMethod<StartSandboxRequest, Sandbox2, StartSandboxError, DaytonaOpContext>;
+export type StopSandboxError = DaytonaOpError;
+/** Stop sandbox */
+export declare const stopSandbox: API.OperationMethod<StopSandboxRequest, Sandbox2, StopSandboxError, DaytonaOpContext>;
+export type UpdateLastActivityError = DaytonaOpError;
+/** Update sandbox last activity */
+export declare const updateLastActivity: API.OperationMethod<UpdateLastActivityRequest, UpdateLastActivityResponse, UpdateLastActivityError, DaytonaOpContext>;
+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 declare const updateNetworkSettings: API.OperationMethod<UpdateNetworkSettingsRequest, Sandbox2, UpdateNetworkSettingsError, DaytonaOpContext>;
+export type UpdatePublicStatusError = DaytonaOpError;
+/** Update public status */
+export declare const updatePublicStatus: API.OperationMethod<UpdatePublicStatusRequest, Sandbox2, UpdatePublicStatusError, DaytonaOpContext>;
+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 declare const updateSandboxSecrets: API.OperationMethod<UpdateSandboxSecretsRequest, Sandbox2, UpdateSandboxSecretsError, DaytonaOpContext>;
+export type UpdateSandboxStateError = DaytonaOpError;
+/** Update sandbox state */
+export declare const updateSandboxState: API.OperationMethod<UpdateSandboxStateRequest, UpdateSandboxStateResponse, UpdateSandboxStateError, DaytonaOpContext>;
+export type ValidateSshAccessError = DaytonaOpError;
+/** Validate SSH access for sandbox */
+export declare const validateSshAccess: API.OperationMethod<ValidateSshAccessRequest, SshAccessValidationDto, ValidateSshAccessError, DaytonaOpContext>;
+//# sourceMappingURL=sandbox.d.ts.map