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

package/src/services/runners.ts

@@ -0,0 +1,811 @@
+// 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 Redacted from "effect/Redacted";
+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 };
+
+/** Tags to associate with the runner */
+export type CreateRunnerRequestTagsList = Array<string>;
+export const CreateRunnerRequestTagsList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<CreateRunnerRequestTagsList>;
+
+export interface CreateRunnerRequest {
+  /** Use with JWT to specify the organization ID */
+  xDaytonaOrganizationID?: string;
+  regionId: string;
+  name: string;
+  /** Tags to associate with the runner */
+  tags?: CreateRunnerRequestTagsList;
+}
+export const CreateRunnerRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    xDaytonaOrganizationID: S.optional(
+      S.String.pipe(T.Header("X-Daytona-Organization-ID")),
+    ),
+    regionId: S.String,
+    name: S.String,
+    tags: S.optional(CreateRunnerRequestTagsList),
+  }).pipe(T.Http({ method: "POST", uri: "/runners", code: 200 })),
+).annotate({
+  identifier: "CreateRunnerRequest",
+}) as any as S.Schema<CreateRunnerRequest>;
+
+export interface CreateRunnerResponse {
+  /** The ID of the runner */
+  id: string;
+  /** The API key for the runner */
+  apiKey: string | Redacted.Redacted<string>;
+}
+export const CreateRunnerResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.String,
+    apiKey: S.String.pipe(T.SensitiveValue({})),
+  }),
+).annotate({
+  identifier: "CreateRunnerResponse",
+}) as any as S.Schema<CreateRunnerResponse>;
+
+export interface DeleteRunnerRequest {
+  /** Runner ID */
+  id: string;
+  /** Delete the runner without waiting for sandboxes already marked for destruction. Requires the runner to have stopped reporting as ready. */
+  force?: boolean;
+  /** Use with JWT to specify the organization ID */
+  xDaytonaOrganizationID?: string;
+}
+export const DeleteRunnerRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: 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: "DELETE", uri: "/runners/{id}", code: 200 })),
+).annotate({
+  identifier: "DeleteRunnerRequest",
+}) as any as S.Schema<DeleteRunnerRequest>;
+
+export interface DeleteRunnerResponse {}
+export const DeleteRunnerResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "DeleteRunnerResponse",
+}) as any as S.Schema<DeleteRunnerResponse>;
+
+export interface GetInfoForAuthenticatedRunnerRequest {}
+export const GetInfoForAuthenticatedRunnerRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({}).pipe(T.Http({ method: "GET", uri: "/runners/me", code: 200 })),
+).annotate({
+  identifier: "GetInfoForAuthenticatedRunnerRequest",
+}) as any as S.Schema<GetInfoForAuthenticatedRunnerRequest>;
+
+export type SandboxClass = "linux-vm" | "container" | "android" | "windows";
+export const SandboxClass = S.String;
+
+/** The state of the runner */
+export type RunnerState =
+  | "initializing"
+  | "ready"
+  | "disabled"
+  | "decommissioned"
+  | "unresponsive";
+export const RunnerState = S.String;
+
+/** Tags associated with the runner */
+export type RunnerFullTagsList = Array<string>;
+export const RunnerFullTagsList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<RunnerFullTagsList>;
+
+/** The class of the runner. Deprecated and always returns "container" for backward compatibility - use sandboxClass instead. */
+export type RunnerClass = "container";
+export const RunnerClass = S.String;
+
+/** The type of the region */
+export type RegionType = "shared" | "dedicated" | "custom";
+export const RegionType = S.String;
+
+export interface RunnerFull {
+  /** The ID of the runner */
+  id: string;
+  /** The domain of the runner */
+  domain?: string;
+  /** The API URL of the runner */
+  apiUrl?: string;
+  /** The proxy URL of the runner */
+  proxyUrl?: string;
+  /** The CPU capacity of the runner */
+  cpu: number;
+  /** The memory capacity of the runner in GiB */
+  memory: number;
+  /** The disk capacity of the runner in GiB */
+  disk: number;
+  /** The GPU capacity of the runner */
+  gpu?: number;
+  /** The type of GPU */
+  gpuType?: string;
+  /** The sandbox class supported by this runner */
+  sandboxClass?: SandboxClass;
+  /** Current CPU usage percentage */
+  currentCpuUsagePercentage?: number;
+  /** Current RAM usage percentage */
+  currentMemoryUsagePercentage?: number;
+  /** Current disk usage percentage */
+  currentDiskUsagePercentage?: number;
+  /** Current allocated CPU */
+  currentAllocatedCpu?: number;
+  /** Current allocated memory in GiB */
+  currentAllocatedMemoryGiB?: number;
+  /** Current allocated disk in GiB */
+  currentAllocatedDiskGiB?: number;
+  /** Current snapshot count */
+  currentSnapshotCount?: number;
+  /** Current number of started sandboxes */
+  currentStartedSandboxes?: number;
+  /** Runner availability score */
+  availabilityScore?: number;
+  /** The region of the runner */
+  region: string;
+  /** The name of the runner */
+  name: string;
+  /** The state of the runner */
+  state: RunnerState;
+  /** The last time the runner was checked */
+  lastChecked?: string;
+  /** Whether the runner is unschedulable */
+  unschedulable: boolean;
+  /** Tags associated with the runner */
+  tags: RunnerFullTagsList;
+  /** The creation timestamp of the runner */
+  createdAt: string;
+  /** The last update timestamp of the runner */
+  updatedAt: string;
+  /** The version of the runner (deprecated in favor of apiVersion) */
+  version: string;
+  /** The api version of the runner */
+  apiVersion: string;
+  /** The class of the runner. Deprecated and always returns "container" for backward compatibility - use sandboxClass instead. */
+  runnerClass: RunnerClass;
+  /** The app version of the runner */
+  appVersion?: string;
+  /** Deprecated runner class property */
+  class?: string;
+  /** The API key for the runner */
+  apiKey: string | Redacted.Redacted<string>;
+  /** The region type of the runner */
+  regionType?: RegionType;
+}
+export const RunnerFull = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.String,
+    domain: S.optional(S.String),
+    apiUrl: S.optional(S.String),
+    proxyUrl: S.optional(S.String),
+    cpu: S.Number,
+    memory: S.Number,
+    disk: S.Number,
+    gpu: S.optional(S.Number),
+    gpuType: S.optional(S.String),
+    sandboxClass: S.optional(SandboxClass),
+    currentCpuUsagePercentage: S.optional(S.Number),
+    currentMemoryUsagePercentage: S.optional(S.Number),
+    currentDiskUsagePercentage: S.optional(S.Number),
+    currentAllocatedCpu: S.optional(S.Number),
+    currentAllocatedMemoryGiB: S.optional(S.Number),
+    currentAllocatedDiskGiB: S.optional(S.Number),
+    currentSnapshotCount: S.optional(S.Number),
+    currentStartedSandboxes: S.optional(S.Number),
+    availabilityScore: S.optional(S.Number),
+    region: S.String,
+    name: S.String,
+    state: RunnerState,
+    lastChecked: S.optional(S.String),
+    unschedulable: S.Boolean,
+    tags: RunnerFullTagsList,
+    createdAt: S.String,
+    updatedAt: S.String,
+    version: S.String,
+    apiVersion: S.String,
+    runnerClass: RunnerClass,
+    appVersion: S.optional(S.String),
+    class: S.optional(S.String),
+    apiKey: S.String.pipe(T.SensitiveValue({})),
+    regionType: S.optional(RegionType),
+  }),
+).annotate({ identifier: "RunnerFull" }) as any as S.Schema<RunnerFull>;
+
+export interface GetRunnerRequest {
+  /** Runner ID */
+  id: string;
+  /** Use with JWT to specify the organization ID */
+  xDaytonaOrganizationID?: string;
+}
+export const GetRunnerRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.String.pipe(T.Label()),
+    xDaytonaOrganizationID: S.optional(
+      S.String.pipe(T.Header("X-Daytona-Organization-ID")),
+    ),
+  }).pipe(T.Http({ method: "GET", uri: "/runners/{id}", code: 200 })),
+).annotate({
+  identifier: "GetRunnerRequest",
+}) as any as S.Schema<GetRunnerRequest>;
+
+/** Tags associated with the runner */
+export type RunnerTagsList = Array<string>;
+export const RunnerTagsList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<RunnerTagsList>;
+
+export interface Runner {
+  /** The ID of the runner */
+  id: string;
+  /** The domain of the runner */
+  domain?: string;
+  /** The API URL of the runner */
+  apiUrl?: string;
+  /** The proxy URL of the runner */
+  proxyUrl?: string;
+  /** The CPU capacity of the runner */
+  cpu: number;
+  /** The memory capacity of the runner in GiB */
+  memory: number;
+  /** The disk capacity of the runner in GiB */
+  disk: number;
+  /** The GPU capacity of the runner */
+  gpu?: number;
+  /** The type of GPU */
+  gpuType?: string;
+  /** The sandbox class supported by this runner */
+  sandboxClass?: SandboxClass;
+  /** Current CPU usage percentage */
+  currentCpuUsagePercentage?: number;
+  /** Current RAM usage percentage */
+  currentMemoryUsagePercentage?: number;
+  /** Current disk usage percentage */
+  currentDiskUsagePercentage?: number;
+  /** Current allocated CPU */
+  currentAllocatedCpu?: number;
+  /** Current allocated memory in GiB */
+  currentAllocatedMemoryGiB?: number;
+  /** Current allocated disk in GiB */
+  currentAllocatedDiskGiB?: number;
+  /** Current snapshot count */
+  currentSnapshotCount?: number;
+  /** Current number of started sandboxes */
+  currentStartedSandboxes?: number;
+  /** Runner availability score */
+  availabilityScore?: number;
+  /** The region of the runner */
+  region: string;
+  /** The name of the runner */
+  name: string;
+  /** The state of the runner */
+  state: RunnerState;
+  /** The last time the runner was checked */
+  lastChecked?: string;
+  /** Whether the runner is unschedulable */
+  unschedulable: boolean;
+  /** Tags associated with the runner */
+  tags: RunnerTagsList;
+  /** The creation timestamp of the runner */
+  createdAt: string;
+  /** The last update timestamp of the runner */
+  updatedAt: string;
+  /** The version of the runner (deprecated in favor of apiVersion) */
+  version: string;
+  /** The api version of the runner */
+  apiVersion: string;
+  /** The class of the runner. Deprecated and always returns "container" for backward compatibility - use sandboxClass instead. */
+  runnerClass: RunnerClass;
+  /** The app version of the runner */
+  appVersion?: string;
+  /** Deprecated runner class property */
+  class?: string;
+}
+export const Runner = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.String,
+    domain: S.optional(S.String),
+    apiUrl: S.optional(S.String),
+    proxyUrl: S.optional(S.String),
+    cpu: S.Number,
+    memory: S.Number,
+    disk: S.Number,
+    gpu: S.optional(S.Number),
+    gpuType: S.optional(S.String),
+    sandboxClass: S.optional(SandboxClass),
+    currentCpuUsagePercentage: S.optional(S.Number),
+    currentMemoryUsagePercentage: S.optional(S.Number),
+    currentDiskUsagePercentage: S.optional(S.Number),
+    currentAllocatedCpu: S.optional(S.Number),
+    currentAllocatedMemoryGiB: S.optional(S.Number),
+    currentAllocatedDiskGiB: S.optional(S.Number),
+    currentSnapshotCount: S.optional(S.Number),
+    currentStartedSandboxes: S.optional(S.Number),
+    availabilityScore: S.optional(S.Number),
+    region: S.String,
+    name: S.String,
+    state: RunnerState,
+    lastChecked: S.optional(S.String),
+    unschedulable: S.Boolean,
+    tags: RunnerTagsList,
+    createdAt: S.String,
+    updatedAt: S.String,
+    version: S.String,
+    apiVersion: S.String,
+    runnerClass: RunnerClass,
+    appVersion: S.optional(S.String),
+    class: S.optional(S.String),
+  }),
+).annotate({ identifier: "Runner" }) as any as S.Schema<Runner>;
+
+export interface GetRunnerBySandboxIdRequest {
+  sandboxId: string;
+}
+export const GetRunnerBySandboxIdRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    sandboxId: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/runners/by-sandbox/{sandboxId}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetRunnerBySandboxIdRequest",
+}) as any as S.Schema<GetRunnerBySandboxIdRequest>;
+
+export interface GetRunnerFullByIdRequest {
+  /** Runner ID */
+  id: string;
+}
+export const GetRunnerFullByIdRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.String.pipe(T.Label()),
+  }).pipe(T.Http({ method: "GET", uri: "/runners/{id}/full", code: 200 })),
+).annotate({
+  identifier: "GetRunnerFullByIdRequest",
+}) as any as S.Schema<GetRunnerFullByIdRequest>;
+
+export interface GetRunnersBySnapshotRefRequest {
+  /** Snapshot ref */
+  ref: string;
+}
+export const GetRunnersBySnapshotRefRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    ref: S.String.pipe(T.Query()),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/runners/by-snapshot-ref", code: 200 }),
+  ),
+).annotate({
+  identifier: "GetRunnersBySnapshotRefRequest",
+}) as any as S.Schema<GetRunnersBySnapshotRefRequest>;
+
+export interface RunnerSnapshotDto {
+  /** Runner snapshot ID */
+  runnerSnapshotId: string;
+  /** Runner ID */
+  runnerId: string;
+  /** Runner domain */
+  runnerDomain?: string;
+}
+export const RunnerSnapshotDto = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    runnerSnapshotId: S.String,
+    runnerId: S.String,
+    runnerDomain: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "RunnerSnapshotDto",
+}) as any as S.Schema<RunnerSnapshotDto>;
+
+export type GetRunnersBySnapshotRefResponseBodyList = Array<RunnerSnapshotDto>;
+export const GetRunnersBySnapshotRefResponseBodyList = /*@__PURE__*/ S.Array(
+  RunnerSnapshotDto,
+) as any as S.Schema<GetRunnersBySnapshotRefResponseBodyList>;
+
+export type GetRunnersBySnapshotRefResponse =
+  GetRunnersBySnapshotRefResponseBodyList;
+export const GetRunnersBySnapshotRefResponse = /*@__PURE__*/ S.suspend(() =>
+  GetRunnersBySnapshotRefResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "GetRunnersBySnapshotRefResponse",
+}) as any as S.Schema<GetRunnersBySnapshotRefResponse>;
+
+export interface GetSnapshotRefsForAuthenticatedRunnerRequest {}
+export const GetSnapshotRefsForAuthenticatedRunnerRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({}).pipe(
+      T.Http({ method: "GET", uri: "/runners/me/snapshots", code: 200 }),
+    ),
+  ).annotate({
+    identifier: "GetSnapshotRefsForAuthenticatedRunnerRequest",
+  }) as any as S.Schema<GetSnapshotRefsForAuthenticatedRunnerRequest>;
+
+export type GetSnapshotRefsForAuthenticatedRunnerResponseBodyList =
+  Array<string>;
+export const GetSnapshotRefsForAuthenticatedRunnerResponseBodyList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as S.Schema<GetSnapshotRefsForAuthenticatedRunnerResponseBodyList>;
+
+export type GetSnapshotRefsForAuthenticatedRunnerResponse =
+  GetSnapshotRefsForAuthenticatedRunnerResponseBodyList;
+export const GetSnapshotRefsForAuthenticatedRunnerResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    GetSnapshotRefsForAuthenticatedRunnerResponseBodyList.pipe(
+      T.RawResponseRoot(),
+    ),
+  ).annotate({
+    identifier: "GetSnapshotRefsForAuthenticatedRunnerResponse",
+  }) as any as S.Schema<GetSnapshotRefsForAuthenticatedRunnerResponse>;
+
+export interface ListRunnersRequest {
+  /** Filter runners by region ID */
+  regionId?: string;
+  /** Use with JWT to specify the organization ID */
+  xDaytonaOrganizationID?: string;
+}
+export const ListRunnersRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    regionId: 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: "/runners", code: 200 })),
+).annotate({
+  identifier: "ListRunnersRequest",
+}) as any as S.Schema<ListRunnersRequest>;
+
+export type ListRunnersResponseBodyList = Array<Runner>;
+export const ListRunnersResponseBodyList = /*@__PURE__*/ S.Array(
+  Runner,
+) as any as S.Schema<ListRunnersResponseBodyList>;
+
+export type ListRunnersResponse = ListRunnersResponseBodyList;
+export const ListRunnersResponse = /*@__PURE__*/ S.suspend(() =>
+  ListRunnersResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListRunnersResponse",
+}) as any as S.Schema<ListRunnersResponse>;
+
+export interface RunnerHealthMetrics {
+  /** Current CPU load average */
+  currentCpuLoadAverage: number;
+  /** Current CPU usage percentage */
+  currentCpuUsagePercentage: number;
+  /** Current memory usage percentage */
+  currentMemoryUsagePercentage: number;
+  /** Current disk usage percentage */
+  currentDiskUsagePercentage: number;
+  /** Currently allocated CPU cores */
+  currentAllocatedCpu: number;
+  /** Currently allocated memory in GiB */
+  currentAllocatedMemoryGiB: number;
+  /** Currently allocated disk in GiB */
+  currentAllocatedDiskGiB: number;
+  /** Number of snapshots currently stored */
+  currentSnapshotCount: number;
+  /** Number of started sandboxes */
+  currentStartedSandboxes: number;
+  /** Total CPU cores on the runner */
+  cpu: number;
+  /** Total RAM in GiB on the runner */
+  memoryGiB: number;
+  /** Total disk space in GiB on the runner */
+  diskGiB: number;
+  /** Total number of GPUs on the runner */
+  gpu?: number;
+  /** GPU model name */
+  gpuType?: string;
+}
+export const RunnerHealthMetrics = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    currentCpuLoadAverage: S.Number,
+    currentCpuUsagePercentage: S.Number,
+    currentMemoryUsagePercentage: S.Number,
+    currentDiskUsagePercentage: S.Number,
+    currentAllocatedCpu: S.Number,
+    currentAllocatedMemoryGiB: S.Number,
+    currentAllocatedDiskGiB: S.Number,
+    currentSnapshotCount: S.Number,
+    currentStartedSandboxes: S.Number,
+    cpu: S.Number,
+    memoryGiB: S.Number,
+    diskGiB: S.Number,
+    gpu: S.optional(S.Number),
+    gpuType: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "RunnerHealthMetrics",
+}) as any as S.Schema<RunnerHealthMetrics>;
+
+export interface RunnerServiceHealth {
+  /** Name of the service being checked */
+  serviceName: string;
+  /** Whether the service is healthy */
+  healthy: boolean;
+  /** Error reason if the service is unhealthy */
+  errorReason?: string;
+}
+export const RunnerServiceHealth = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    serviceName: S.String,
+    healthy: S.Boolean,
+    errorReason: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "RunnerServiceHealth",
+}) as any as S.Schema<RunnerServiceHealth>;
+
+/** Health status of individual services on the runner */
+export type RunnerHealthcheckRequestServiceHealthList =
+  Array<RunnerServiceHealth>;
+export const RunnerHealthcheckRequestServiceHealthList = /*@__PURE__*/ S.Array(
+  RunnerServiceHealth,
+) as any as S.Schema<RunnerHealthcheckRequestServiceHealthList>;
+
+export interface RunnerHealthcheckRequest {
+  /** Runner metrics */
+  metrics?: RunnerHealthMetrics;
+  /** Health status of individual services on the runner */
+  serviceHealth?: RunnerHealthcheckRequestServiceHealthList;
+  /** Runner domain */
+  domain?: string;
+  /** Runner proxy URL */
+  proxyUrl?: string;
+  /** Runner API URL */
+  apiUrl?: string;
+  /** Runner app version */
+  appVersion: string;
+}
+export const RunnerHealthcheckRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    metrics: S.optional(RunnerHealthMetrics),
+    serviceHealth: S.optional(RunnerHealthcheckRequestServiceHealthList),
+    domain: S.optional(S.String),
+    proxyUrl: S.optional(S.String),
+    apiUrl: S.optional(S.String),
+    appVersion: S.String,
+  }).pipe(T.Http({ method: "POST", uri: "/runners/healthcheck", code: 200 })),
+).annotate({
+  identifier: "RunnerHealthcheckRequest",
+}) as any as S.Schema<RunnerHealthcheckRequest>;
+
+export interface RunnerHealthcheckResponse {}
+export const RunnerHealthcheckResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "RunnerHealthcheckResponse",
+}) as any as S.Schema<RunnerHealthcheckResponse>;
+
+export interface UpdateRunnerDrainingRequest {
+  /** Runner ID */
+  id: string;
+  /** Use with JWT to specify the organization ID */
+  xDaytonaOrganizationID?: string;
+}
+export const UpdateRunnerDrainingRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.String.pipe(T.Label()),
+    xDaytonaOrganizationID: S.optional(
+      S.String.pipe(T.Header("X-Daytona-Organization-ID")),
+    ),
+  }).pipe(
+    T.Http({ method: "PATCH", uri: "/runners/{id}/draining", code: 200 }),
+  ),
+).annotate({
+  identifier: "UpdateRunnerDrainingRequest",
+}) as any as S.Schema<UpdateRunnerDrainingRequest>;
+
+export interface UpdateRunnerSchedulingRequest {
+  /** Runner ID */
+  id: string;
+  /** Use with JWT to specify the organization ID */
+  xDaytonaOrganizationID?: string;
+}
+export const UpdateRunnerSchedulingRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.String.pipe(T.Label()),
+    xDaytonaOrganizationID: S.optional(
+      S.String.pipe(T.Header("X-Daytona-Organization-ID")),
+    ),
+  }).pipe(
+    T.Http({ method: "PATCH", uri: "/runners/{id}/scheduling", code: 200 }),
+  ),
+).annotate({
+  identifier: "UpdateRunnerSchedulingRequest",
+}) as any as S.Schema<UpdateRunnerSchedulingRequest>;
+
+export type CreateRunnerError = DaytonaOpError;
+/** Create runner */
+export const createRunner: API.OperationMethod<
+  CreateRunnerRequest,
+  CreateRunnerResponse,
+  CreateRunnerError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateRunnerRequest,
+  output: CreateRunnerResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteRunnerError = DaytonaOpError;
+/** Delete runner */
+export const deleteRunner: API.OperationMethod<
+  DeleteRunnerRequest,
+  DeleteRunnerResponse,
+  DeleteRunnerError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteRunnerRequest,
+  output: DeleteRunnerResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetInfoForAuthenticatedRunnerError = DaytonaOpError;
+/** Get info for authenticated runner */
+export const getInfoForAuthenticatedRunner: API.OperationMethod<
+  GetInfoForAuthenticatedRunnerRequest,
+  RunnerFull,
+  GetInfoForAuthenticatedRunnerError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetInfoForAuthenticatedRunnerRequest,
+  output: RunnerFull,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetRunnerError = DaytonaOpError;
+/** Get runner by ID */
+export const getRunner: API.OperationMethod<
+  GetRunnerRequest,
+  Runner,
+  GetRunnerError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetRunnerRequest,
+  output: Runner,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetRunnerBySandboxIdError = DaytonaOpError;
+/** Get runner by sandbox ID */
+export const getRunnerBySandboxId: API.OperationMethod<
+  GetRunnerBySandboxIdRequest,
+  RunnerFull,
+  GetRunnerBySandboxIdError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetRunnerBySandboxIdRequest,
+  output: RunnerFull,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetRunnerFullByIdError = DaytonaOpError;
+/** Get runner by ID */
+export const getRunnerFullById: API.OperationMethod<
+  GetRunnerFullByIdRequest,
+  RunnerFull,
+  GetRunnerFullByIdError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetRunnerFullByIdRequest,
+  output: RunnerFull,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetRunnersBySnapshotRefError = DaytonaOpError;
+/** Get runners by snapshot ref */
+export const getRunnersBySnapshotRef: API.OperationMethod<
+  GetRunnersBySnapshotRefRequest,
+  GetRunnersBySnapshotRefResponse,
+  GetRunnersBySnapshotRefError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetRunnersBySnapshotRefRequest,
+  output: GetRunnersBySnapshotRefResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetSnapshotRefsForAuthenticatedRunnerError = DaytonaOpError;
+/** Get snapshot refs for authenticated runner */
+export const getSnapshotRefsForAuthenticatedRunner: API.OperationMethod<
+  GetSnapshotRefsForAuthenticatedRunnerRequest,
+  GetSnapshotRefsForAuthenticatedRunnerResponse,
+  GetSnapshotRefsForAuthenticatedRunnerError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetSnapshotRefsForAuthenticatedRunnerRequest,
+  output: GetSnapshotRefsForAuthenticatedRunnerResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListRunnersError = DaytonaOpError;
+/** List all runners */
+export const listRunners: API.OperationMethod<
+  ListRunnersRequest,
+  ListRunnersResponse,
+  ListRunnersError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListRunnersRequest,
+  output: ListRunnersResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type RunnerHealthcheckError = DaytonaOpError;
+/** Runner healthcheck Endpoint for version 2 runners to send healthcheck and metrics. Updates lastChecked timestamp and runner metrics. */
+export const runnerHealthcheck: API.OperationMethod<
+  RunnerHealthcheckRequest,
+  RunnerHealthcheckResponse,
+  RunnerHealthcheckError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: RunnerHealthcheckRequest,
+  output: RunnerHealthcheckResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UpdateRunnerDrainingError = DaytonaOpError;
+/** Update runner draining status */
+export const updateRunnerDraining: API.OperationMethod<
+  UpdateRunnerDrainingRequest,
+  Runner,
+  UpdateRunnerDrainingError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UpdateRunnerDrainingRequest,
+  output: Runner,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UpdateRunnerSchedulingError = DaytonaOpError;
+/** Update runner scheduling status */
+export const updateRunnerScheduling: API.OperationMethod<
+  UpdateRunnerSchedulingRequest,
+  Runner,
+  UpdateRunnerSchedulingError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UpdateRunnerSchedulingRequest,
+  output: Runner,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));