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

package/src/services/health.ts

@@ -0,0 +1,116 @@
+// AUTO-GENERATED by scripts/generate.ts from .generated-specs (specs/spec-mirror-daytona/specs/{openapi,toolbox-openapi,analytics-openapi}.json). Do not edit.
+import * as S from "@distilled.cloud/core/schema";
+import * as API from "@distilled.cloud/core/api";
+import * as T from "../traits.ts";
+import {
+  DaytonaProtocol,
+  type DaytonaOpError,
+  type DaytonaOpContext,
+} from "../protocol.ts";
+import { UnknownDaytonaError } from "../errors.ts";
+import * as Retry from "../retry.ts";
+
+export type { DaytonaOpError, DaytonaOpContext };
+
+export interface CheckHealthControllerRequest {}
+export const CheckHealthControllerRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}).pipe(T.Http({ method: "GET", uri: "/health/ready", code: 200 })),
+).annotate({
+  identifier: "CheckHealthControllerRequest",
+}) as any as S.Schema<CheckHealthControllerRequest>;
+
+export interface HealthControllerCheck200ResponseInfoValue {
+  status: string;
+}
+export const HealthControllerCheck200ResponseInfoValue =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      status: S.String,
+    }),
+  ).annotate({
+    identifier: "HealthControllerCheck200ResponseInfoValue",
+  }) as any as S.Schema<HealthControllerCheck200ResponseInfoValue>;
+
+export type HealthControllerCheck200ResponseInfoMap = {
+  [key: string]: HealthControllerCheck200ResponseInfoValue | undefined;
+};
+export const HealthControllerCheck200ResponseInfoMap = /*@__PURE__*/ S.Record(
+  S.String,
+  HealthControllerCheck200ResponseInfoValue,
+) as any as S.Schema<HealthControllerCheck200ResponseInfoMap>;
+
+export type HealthControllerCheck200ResponseErrorMap = {
+  [key: string]: HealthControllerCheck200ResponseInfoValue | undefined;
+};
+export const HealthControllerCheck200ResponseErrorMap = /*@__PURE__*/ S.Record(
+  S.String,
+  HealthControllerCheck200ResponseInfoValue,
+) as any as S.Schema<HealthControllerCheck200ResponseErrorMap>;
+
+export type HealthControllerCheck200ResponseDetailsMap = {
+  [key: string]: HealthControllerCheck200ResponseInfoValue | undefined;
+};
+export const HealthControllerCheck200ResponseDetailsMap =
+  /*@__PURE__*/ S.Record(
+    S.String,
+    HealthControllerCheck200ResponseInfoValue,
+  ) as any as S.Schema<HealthControllerCheck200ResponseDetailsMap>;
+
+export interface HealthControllerCheck200Response {
+  status?: string;
+  info?: HealthControllerCheck200ResponseInfoMap | null;
+  error?: HealthControllerCheck200ResponseErrorMap | null;
+  details?: HealthControllerCheck200ResponseDetailsMap;
+}
+export const HealthControllerCheck200Response = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    status: S.optional(S.String),
+    info: S.optional(S.NullOr(HealthControllerCheck200ResponseInfoMap)),
+    error: S.optional(S.NullOr(HealthControllerCheck200ResponseErrorMap)),
+    details: S.optional(HealthControllerCheck200ResponseDetailsMap),
+  }),
+).annotate({
+  identifier: "HealthControllerCheck200Response",
+}) as any as S.Schema<HealthControllerCheck200Response>;
+
+export interface HealthControllerLiveRequest {}
+export const HealthControllerLiveRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}).pipe(T.Http({ method: "GET", uri: "/health", code: 200 })),
+).annotate({
+  identifier: "HealthControllerLiveRequest",
+}) as any as S.Schema<HealthControllerLiveRequest>;
+
+export interface HealthControllerLiveResponse {}
+export const HealthControllerLiveResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "HealthControllerLiveResponse",
+}) as any as S.Schema<HealthControllerLiveResponse>;
+
+export type CheckHealthControllerError = DaytonaOpError;
+export const checkHealthController: API.OperationMethod<
+  CheckHealthControllerRequest,
+  HealthControllerCheck200Response,
+  CheckHealthControllerError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CheckHealthControllerRequest,
+  output: HealthControllerCheck200Response,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type HealthControllerLiveError = DaytonaOpError;
+export const healthControllerLive: API.OperationMethod<
+  HealthControllerLiveRequest,
+  HealthControllerLiveResponse,
+  HealthControllerLiveError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: HealthControllerLiveRequest,
+  output: HealthControllerLiveResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));

package/src/services/index.ts

@@ -0,0 +1,31 @@
+// AUTO-GENERATED by scripts/generate.ts. Do not edit.
+export * as apiKeys from "./api_keys.ts";
+export * as audit from "./audit.ts";
+export * as computerUse from "./computer_use.ts";
+export * as config from "./config.ts";
+export * as dockerRegistry from "./docker_registry.ts";
+export * as fileSystem from "./file_system.ts";
+export * as git from "./git.ts";
+export * as health from "./health.ts";
+export * as info from "./info.ts";
+export * as interpreter from "./interpreter.ts";
+export * as jobs from "./jobs.ts";
+export * as lsp from "./lsp.ts";
+export * as objectStorage from "./object_storage.ts";
+export * as organizations from "./organizations.ts";
+export * as port from "./port.ts";
+export * as preview from "./preview.ts";
+export * as process from "./process.ts";
+export * as regions from "./regions.ts";
+export * as runners from "./runners.ts";
+export * as sandbox from "./sandbox.ts";
+export * as secret from "./secret.ts";
+export * as server from "./server.ts";
+export * as snapshots from "./snapshots.ts";
+export * as system from "./system.ts";
+export * as telemetry from "./telemetry.ts";
+export * as usage from "./usage.ts";
+export * as users from "./users.ts";
+export * as volumes from "./volumes.ts";
+export * as warmPools from "./warm_pools.ts";
+export * as webhooks from "./webhooks.ts";

package/src/services/info.ts

@@ -0,0 +1,116 @@
+// AUTO-GENERATED by scripts/generate.ts from .generated-specs (specs/spec-mirror-daytona/specs/{openapi,toolbox-openapi,analytics-openapi}.json). Do not edit.
+import * as S from "@distilled.cloud/core/schema";
+import * as API from "@distilled.cloud/core/api";
+import * as T from "../traits.ts";
+import {
+  DaytonaProtocol,
+  type DaytonaOpError,
+  type DaytonaOpContext,
+} from "../protocol.ts";
+import { UnknownDaytonaError } from "../errors.ts";
+import * as Retry from "../retry.ts";
+
+export type { DaytonaOpError, DaytonaOpContext };
+
+export interface GetUserHomeDirRequest {}
+export const GetUserHomeDirRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}).pipe(
+    T.Http({ method: "GET", uri: "/user-home-dir", code: 200 }),
+  ),
+).annotate({
+  identifier: "GetUserHomeDirRequest",
+}) as any as S.Schema<GetUserHomeDirRequest>;
+
+export interface UserHomeDirResponse {
+  dir: string;
+}
+export const UserHomeDirResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    dir: S.String,
+  }),
+).annotate({
+  identifier: "UserHomeDirResponse",
+}) as any as S.Schema<UserHomeDirResponse>;
+
+export interface GetVersionRequest {}
+export const GetVersionRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}).pipe(T.Http({ method: "GET", uri: "/version", code: 200 })),
+).annotate({
+  identifier: "GetVersionRequest",
+}) as any as S.Schema<GetVersionRequest>;
+
+export type GetVersionResponseBodyMap = { [key: string]: string | undefined };
+export const GetVersionResponseBodyMap = /*@__PURE__*/ S.Record(
+  S.String,
+  S.String,
+) as any as S.Schema<GetVersionResponseBodyMap>;
+
+export type GetVersionResponse = GetVersionResponseBodyMap;
+export const GetVersionResponse = /*@__PURE__*/ S.suspend(() =>
+  GetVersionResponseBodyMap.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "GetVersionResponse",
+}) as any as S.Schema<GetVersionResponse>;
+
+export interface GetWorkDirRequest {}
+export const GetWorkDirRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}).pipe(T.Http({ method: "GET", uri: "/work-dir", code: 200 })),
+).annotate({
+  identifier: "GetWorkDirRequest",
+}) as any as S.Schema<GetWorkDirRequest>;
+
+export interface WorkDirResponse {
+  dir: string;
+}
+export const WorkDirResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    dir: S.String,
+  }),
+).annotate({
+  identifier: "WorkDirResponse",
+}) as any as S.Schema<WorkDirResponse>;
+
+export type GetUserHomeDirError = DaytonaOpError;
+/** Get user home directory Get the current user home directory path. */
+export const getUserHomeDir: API.OperationMethod<
+  GetUserHomeDirRequest,
+  UserHomeDirResponse,
+  GetUserHomeDirError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetUserHomeDirRequest,
+  output: UserHomeDirResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetVersionError = DaytonaOpError;
+/** Get version Get the current daemon version */
+export const getVersion: API.OperationMethod<
+  GetVersionRequest,
+  GetVersionResponse,
+  GetVersionError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetVersionRequest,
+  output: GetVersionResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetWorkDirError = DaytonaOpError;
+/** Get working directory Get the current working directory path. This is default directory used for running commands. */
+export const getWorkDir: API.OperationMethod<
+  GetWorkDirRequest,
+  WorkDirResponse,
+  GetWorkDirError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetWorkDirRequest,
+  output: WorkDirResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));

package/src/services/interpreter.ts

@@ -0,0 +1,182 @@
+// AUTO-GENERATED by scripts/generate.ts from .generated-specs (specs/spec-mirror-daytona/specs/{openapi,toolbox-openapi,analytics-openapi}.json). Do not edit.
+import * as S from "@distilled.cloud/core/schema";
+import * as API from "@distilled.cloud/core/api";
+import * as T from "../traits.ts";
+import {
+  DaytonaProtocol,
+  type DaytonaOpError,
+  type DaytonaOpContext,
+} from "../protocol.ts";
+import { UnknownDaytonaError } from "../errors.ts";
+import * as Retry from "../retry.ts";
+
+export type { DaytonaOpError, DaytonaOpContext };
+
+export interface CreateInterpreterContextRequest {
+  cwd?: string;
+  language?: string;
+}
+export const CreateInterpreterContextRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    cwd: S.optional(S.String),
+    language: S.optional(S.String),
+  }).pipe(
+    T.Http({ method: "POST", uri: "/process/interpreter/context", code: 200 }),
+  ),
+).annotate({
+  identifier: "CreateInterpreterContextRequest",
+}) as any as S.Schema<CreateInterpreterContextRequest>;
+
+export interface InterpreterContext {
+  active: boolean;
+  createdAt: string;
+  cwd: string;
+  id: string;
+  language: string;
+}
+export const InterpreterContext = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    active: S.Boolean,
+    createdAt: S.String,
+    cwd: S.String,
+    id: S.String,
+    language: S.String,
+  }),
+).annotate({
+  identifier: "InterpreterContext",
+}) as any as S.Schema<InterpreterContext>;
+
+export interface DeleteInterpreterContextRequest {
+  /** Context ID */
+  id: string;
+}
+export const DeleteInterpreterContextRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/process/interpreter/context/{id}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "DeleteInterpreterContextRequest",
+}) as any as S.Schema<DeleteInterpreterContextRequest>;
+
+export type DeleteInterpreterContextResponseBodyMap = {
+  [key: string]: string | undefined;
+};
+export const DeleteInterpreterContextResponseBodyMap = /*@__PURE__*/ S.Record(
+  S.String,
+  S.String,
+) as any as S.Schema<DeleteInterpreterContextResponseBodyMap>;
+
+export type DeleteInterpreterContextResponse =
+  DeleteInterpreterContextResponseBodyMap;
+export const DeleteInterpreterContextResponse = /*@__PURE__*/ S.suspend(() =>
+  DeleteInterpreterContextResponseBodyMap.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "DeleteInterpreterContextResponse",
+}) as any as S.Schema<DeleteInterpreterContextResponse>;
+
+export interface ExecuteInterpreterCodeRequest {}
+export const ExecuteInterpreterCodeRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}).pipe(
+    T.Http({ method: "GET", uri: "/process/interpreter/execute", code: 200 }),
+  ),
+).annotate({
+  identifier: "ExecuteInterpreterCodeRequest",
+}) as any as S.Schema<ExecuteInterpreterCodeRequest>;
+
+export interface ExecuteInterpreterCodeResponse {}
+export const ExecuteInterpreterCodeResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "ExecuteInterpreterCodeResponse",
+}) as any as S.Schema<ExecuteInterpreterCodeResponse>;
+
+export interface ListInterpreterContextsRequest {}
+export const ListInterpreterContextsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}).pipe(
+    T.Http({ method: "GET", uri: "/process/interpreter/context", code: 200 }),
+  ),
+).annotate({
+  identifier: "ListInterpreterContextsRequest",
+}) as any as S.Schema<ListInterpreterContextsRequest>;
+
+export type ListContextsResponseContextsList = Array<InterpreterContext>;
+export const ListContextsResponseContextsList = /*@__PURE__*/ S.Array(
+  InterpreterContext,
+) as any as S.Schema<ListContextsResponseContextsList>;
+
+export interface ListContextsResponse {
+  contexts: ListContextsResponseContextsList;
+}
+export const ListContextsResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    contexts: ListContextsResponseContextsList,
+  }),
+).annotate({
+  identifier: "ListContextsResponse",
+}) as any as S.Schema<ListContextsResponse>;
+
+export type CreateInterpreterContextError = DaytonaOpError;
+/** Create a new interpreter context Creates a new isolated interpreter context with optional working directory and language */
+export const createInterpreterContext: API.OperationMethod<
+  CreateInterpreterContextRequest,
+  InterpreterContext,
+  CreateInterpreterContextError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateInterpreterContextRequest,
+  output: InterpreterContext,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteInterpreterContextError = DaytonaOpError;
+/** Delete an interpreter context Deletes an interpreter context and shuts down its worker process */
+export const deleteInterpreterContext: API.OperationMethod<
+  DeleteInterpreterContextRequest,
+  DeleteInterpreterContextResponse,
+  DeleteInterpreterContextError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteInterpreterContextRequest,
+  output: DeleteInterpreterContextResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ExecuteInterpreterCodeError = DaytonaOpError;
+/** Execute code in an interpreter context Executes code in a specified context (or default context if not specified) via WebSocket streaming */
+export const executeInterpreterCode: API.OperationMethod<
+  ExecuteInterpreterCodeRequest,
+  ExecuteInterpreterCodeResponse,
+  ExecuteInterpreterCodeError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ExecuteInterpreterCodeRequest,
+  output: ExecuteInterpreterCodeResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListInterpreterContextsError = DaytonaOpError;
+/** List all user-created interpreter contexts Returns information about all user-created interpreter contexts (excludes default context) */
+export const listInterpreterContexts: API.OperationMethod<
+  ListInterpreterContextsRequest,
+  ListContextsResponse,
+  ListInterpreterContextsError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListInterpreterContextsRequest,
+  output: ListContextsResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));

package/src/services/jobs.ts

@@ -0,0 +1,249 @@
+// AUTO-GENERATED by scripts/generate.ts from .generated-specs (specs/spec-mirror-daytona/specs/{openapi,toolbox-openapi,analytics-openapi}.json). Do not edit.
+import * as S from "@distilled.cloud/core/schema";
+import * as API from "@distilled.cloud/core/api";
+import * as T from "../traits.ts";
+import {
+  DaytonaProtocol,
+  type DaytonaOpError,
+  type DaytonaOpContext,
+} from "../protocol.ts";
+import { UnknownDaytonaError } from "../errors.ts";
+import * as Retry from "../retry.ts";
+
+export type { DaytonaOpError, DaytonaOpContext };
+
+export interface GetJobRequest {
+  /** ID of the job */
+  jobId: string;
+}
+export const GetJobRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    jobId: S.String.pipe(T.Label()),
+  }).pipe(T.Http({ method: "GET", uri: "/jobs/{jobId}", code: 200 })),
+).annotate({ identifier: "GetJobRequest" }) as any as S.Schema<GetJobRequest>;
+
+/** The type of the job */
+export type JobType =
+  | "CREATE_SANDBOX"
+  | "START_SANDBOX"
+  | "STOP_SANDBOX"
+  | "DESTROY_SANDBOX"
+  | "RESIZE_SANDBOX"
+  | "CREATE_BACKUP"
+  | "BUILD_SNAPSHOT"
+  | "PULL_SNAPSHOT"
+  | "RECOVER_SANDBOX"
+  | "INSPECT_SNAPSHOT_IN_REGISTRY"
+  | "REMOVE_SNAPSHOT"
+  | "UPDATE_SANDBOX_NETWORK_SETTINGS"
+  | "UPDATE_SANDBOX_SECRETS"
+  | "SNAPSHOT_SANDBOX"
+  | "FORK_SANDBOX"
+  | "PAUSE_SANDBOX";
+export const JobType = S.String;
+
+export type JobStatus = "PENDING" | "IN_PROGRESS" | "COMPLETED" | "FAILED";
+export const JobStatus = S.String;
+
+/** The type of resource this job operates on */
+export type JobResourceType = "SANDBOX" | "SNAPSHOT" | "BACKUP";
+export const JobResourceType = S.String;
+
+/** OpenTelemetry trace context for distributed tracing (W3C Trace Context format) */
+export type JobTraceContextMap = { [key: string]: unknown | undefined };
+export const JobTraceContextMap = /*@__PURE__*/ S.Record(
+  S.String,
+  S.Unknown,
+) as any as S.Schema<JobTraceContextMap>;
+
+export interface Job {
+  /** The ID of the job */
+  id: string;
+  /** The type of the job */
+  type: JobType;
+  /** The status of the job */
+  status: JobStatus;
+  /** The type of resource this job operates on */
+  resourceType: JobResourceType;
+  /** The ID of the resource this job operates on (sandboxId, snapshotRef, etc.) */
+  resourceId: string;
+  /** Job-specific JSON-encoded payload data (operational metadata) */
+  payload?: string;
+  /** OpenTelemetry trace context for distributed tracing (W3C Trace Context format) */
+  traceContext?: JobTraceContextMap;
+  /** Error message if the job failed */
+  errorMessage?: string;
+  /** The creation timestamp of the job */
+  createdAt: string;
+  /** The last update timestamp of the job */
+  updatedAt?: string;
+}
+export const Job = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.String,
+    type: JobType,
+    status: JobStatus,
+    resourceType: JobResourceType,
+    resourceId: S.String,
+    payload: S.optional(S.String),
+    traceContext: S.optional(JobTraceContextMap),
+    errorMessage: S.optional(S.String),
+    createdAt: S.String,
+    updatedAt: S.optional(S.String),
+  }),
+).annotate({ identifier: "Job" }) as any as S.Schema<Job>;
+
+export interface ListJobsRequest {
+  /** Page number of the results */
+  page?: number;
+  /** Maximum number of jobs to return (default: 100, max: 500) */
+  limit?: number;
+  /** Filter jobs by status */
+  status?: JobStatus | (string & {});
+  /** Number of jobs to skip for pagination (default: 0) */
+  offset?: number;
+}
+export const ListJobsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    page: S.optional(S.Number.pipe(T.Query())),
+    limit: S.optional(S.Number.pipe(T.Query())),
+    status: S.optional(JobStatus.pipe(T.Query())),
+    offset: S.optional(S.Number.pipe(T.Query())),
+  }).pipe(T.Http({ method: "GET", uri: "/jobs", code: 200 })),
+).annotate({
+  identifier: "ListJobsRequest",
+}) as any as S.Schema<ListJobsRequest>;
+
+export type PaginatedJobsItemsList = Array<Job>;
+export const PaginatedJobsItemsList = /*@__PURE__*/ S.Array(
+  Job,
+) as any as S.Schema<PaginatedJobsItemsList>;
+
+export interface PaginatedJobs {
+  items: PaginatedJobsItemsList;
+  total: number;
+  page: number;
+  totalPages: number;
+}
+export const PaginatedJobs = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    items: PaginatedJobsItemsList,
+    total: S.Number,
+    page: S.Number,
+    totalPages: S.Number,
+  }),
+).annotate({ identifier: "PaginatedJobs" }) as any as S.Schema<PaginatedJobs>;
+
+export interface PollJobsRequest {
+  /** Timeout in seconds for long polling (default: 30, max: 60) */
+  timeout?: number;
+  /** Maximum number of jobs to return (default: 10, max: 100) */
+  limit?: number;
+}
+export const PollJobsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    timeout: S.optional(S.Number.pipe(T.Query())),
+    limit: S.optional(S.Number.pipe(T.Query())),
+  }).pipe(T.Http({ method: "GET", uri: "/jobs/poll", code: 200 })),
+).annotate({
+  identifier: "PollJobsRequest",
+}) as any as S.Schema<PollJobsRequest>;
+
+/** List of jobs */
+export type PollJobsResponseJobsList = Array<Job>;
+export const PollJobsResponseJobsList = /*@__PURE__*/ S.Array(
+  Job,
+) as any as S.Schema<PollJobsResponseJobsList>;
+
+export interface PollJobsResponse {
+  /** List of jobs */
+  jobs: PollJobsResponseJobsList;
+}
+export const PollJobsResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    jobs: PollJobsResponseJobsList,
+  }),
+).annotate({
+  identifier: "PollJobsResponse",
+}) as any as S.Schema<PollJobsResponse>;
+
+export interface UpdateJobStatusRequest {
+  /** ID of the job */
+  jobId: string;
+  /** The new status of the job */
+  status: JobStatus | (string & {});
+  /** Error message if the job failed */
+  errorMessage?: string;
+  /** Result metadata for the job */
+  resultMetadata?: string;
+}
+export const UpdateJobStatusRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    jobId: S.String.pipe(T.Label()),
+    status: JobStatus,
+    errorMessage: S.optional(S.String),
+    resultMetadata: S.optional(S.String),
+  }).pipe(T.Http({ method: "POST", uri: "/jobs/{jobId}/status", code: 200 })),
+).annotate({
+  identifier: "UpdateJobStatusRequest",
+}) as any as S.Schema<UpdateJobStatusRequest>;
+
+export type GetJobError = DaytonaOpError;
+/** Get job details */
+export const getJob: API.OperationMethod<
+  GetJobRequest,
+  Job,
+  GetJobError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetJobRequest,
+  output: Job,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListJobsError = DaytonaOpError;
+/** List jobs for the runner Returns a paginated list of jobs for the runner, optionally filtered by status. */
+export const listJobs: API.OperationMethod<
+  ListJobsRequest,
+  PaginatedJobs,
+  ListJobsError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListJobsRequest,
+  output: PaginatedJobs,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PollJobsError = DaytonaOpError;
+/** Long poll for jobs Long poll endpoint for runners to fetch pending jobs. Returns immediately if jobs are available, otherwise waits up to timeout seconds. */
+export const pollJobs: API.OperationMethod<
+  PollJobsRequest,
+  PollJobsResponse,
+  PollJobsError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PollJobsRequest,
+  output: PollJobsResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UpdateJobStatusError = DaytonaOpError;
+/** Update job status */
+export const updateJobStatus: API.OperationMethod<
+  UpdateJobStatusRequest,
+  Job,
+  UpdateJobStatusError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UpdateJobStatusRequest,
+  output: Job,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));