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

package/src/services/process.ts

@@ -0,0 +1,948 @@
+// 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 ConnectPtySessionRequest {
+  /** PTY session ID */
+  sessionId: string;
+}
+export const ConnectPtySessionRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    sessionId: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/process/pty/{sessionId}/connect",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "ConnectPtySessionRequest",
+}) as any as S.Schema<ConnectPtySessionRequest>;
+
+export interface ConnectPtySessionResponse {}
+export const ConnectPtySessionResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "ConnectPtySessionResponse",
+}) as any as S.Schema<ConnectPtySessionResponse>;
+
+export type CreatePtySessionRequestEnvsMap = {
+  [key: string]: string | undefined;
+};
+export const CreatePtySessionRequestEnvsMap = /*@__PURE__*/ S.Record(
+  S.String,
+  S.String,
+) as any as S.Schema<CreatePtySessionRequestEnvsMap>;
+
+export interface CreatePtySessionRequest {
+  cols?: number;
+  cwd?: string;
+  envs?: CreatePtySessionRequestEnvsMap;
+  id?: string;
+  /** Don't start PTY until first client connects */
+  lazyStart?: boolean;
+  rows?: number;
+}
+export const CreatePtySessionRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    cols: S.optional(S.Number),
+    cwd: S.optional(S.String),
+    envs: S.optional(CreatePtySessionRequestEnvsMap),
+    id: S.optional(S.String),
+    lazyStart: S.optional(S.Boolean),
+    rows: S.optional(S.Number),
+  }).pipe(T.Http({ method: "POST", uri: "/process/pty", code: 200 })),
+).annotate({
+  identifier: "CreatePtySessionRequest",
+}) as any as S.Schema<CreatePtySessionRequest>;
+
+export interface PtyCreateResponse {
+  sessionId: string;
+}
+export const PtyCreateResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    sessionId: S.String,
+  }),
+).annotate({
+  identifier: "PtyCreateResponse",
+}) as any as S.Schema<PtyCreateResponse>;
+
+export interface CreateSessionRequest {
+  sessionId: string;
+}
+export const CreateSessionRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    sessionId: S.String,
+  }).pipe(T.Http({ method: "POST", uri: "/process/session", code: 200 })),
+).annotate({
+  identifier: "CreateSessionRequest",
+}) as any as S.Schema<CreateSessionRequest>;
+
+export interface CreateSessionResponse {}
+export const CreateSessionResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "CreateSessionResponse",
+}) as any as S.Schema<CreateSessionResponse>;
+
+export interface DeletePtySessionRequest {
+  /** PTY session ID */
+  sessionId: string;
+}
+export const DeletePtySessionRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    sessionId: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({ method: "DELETE", uri: "/process/pty/{sessionId}", code: 200 }),
+  ),
+).annotate({
+  identifier: "DeletePtySessionRequest",
+}) as any as S.Schema<DeletePtySessionRequest>;
+
+export type GinH = { [key: string]: unknown | undefined };
+export const GinH = /*@__PURE__*/ S.Record(
+  S.String,
+  S.Unknown,
+) as any as S.Schema<GinH>;
+
+export type DeletePtySessionResponse = GinH;
+export const DeletePtySessionResponse = /*@__PURE__*/ S.suspend(() =>
+  GinH.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "DeletePtySessionResponse",
+}) as any as S.Schema<DeletePtySessionResponse>;
+
+export interface DeleteSessionRequest {
+  /** Session ID */
+  sessionId: string;
+}
+export const DeleteSessionRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    sessionId: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/process/session/{sessionId}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "DeleteSessionRequest",
+}) as any as S.Schema<DeleteSessionRequest>;
+
+export interface DeleteSessionResponse {}
+export const DeleteSessionResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "DeleteSessionResponse",
+}) as any as S.Schema<DeleteSessionResponse>;
+
+/** Environment variables to set for the command */
+export type ExecuteCommandRequestEnvsMap = {
+  [key: string]: string | undefined;
+};
+export const ExecuteCommandRequestEnvsMap = /*@__PURE__*/ S.Record(
+  S.String,
+  S.String,
+) as any as S.Schema<ExecuteCommandRequestEnvsMap>;
+
+export interface ExecuteCommandRequest {
+  command: string;
+  /** Current working directory */
+  cwd?: string;
+  /** Environment variables to set for the command */
+  envs?: ExecuteCommandRequestEnvsMap;
+  /** Timeout in seconds, defaults to 10 seconds */
+  timeout?: number;
+}
+export const ExecuteCommandRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    command: S.String,
+    cwd: S.optional(S.String),
+    envs: S.optional(ExecuteCommandRequestEnvsMap),
+    timeout: S.optional(S.Number),
+  }).pipe(T.Http({ method: "POST", uri: "/process/execute", code: 200 })),
+).annotate({
+  identifier: "ExecuteCommandRequest",
+}) as any as S.Schema<ExecuteCommandRequest>;
+
+export interface ExecuteResponse {
+  exitCode?: number;
+  result: string;
+}
+export const ExecuteResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    exitCode: S.optional(S.Number),
+    result: S.String,
+  }),
+).annotate({
+  identifier: "ExecuteResponse",
+}) as any as S.Schema<ExecuteResponse>;
+
+export interface GetEntrypointLogsRequest {
+  /** Follow logs in real-time (WebSocket only) */
+  follow?: boolean;
+}
+export const GetEntrypointLogsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    follow: S.optional(S.Boolean.pipe(T.Query())),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/process/session/entrypoint/logs",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetEntrypointLogsRequest",
+}) as any as S.Schema<GetEntrypointLogsRequest>;
+
+export interface SessionCommandLogsResponse {
+  output: string;
+  stderr: string;
+  stdout: string;
+}
+export const SessionCommandLogsResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    output: S.String,
+    stderr: S.String,
+    stdout: S.String,
+  }),
+).annotate({
+  identifier: "SessionCommandLogsResponse",
+}) as any as S.Schema<SessionCommandLogsResponse>;
+
+export interface GetEntrypointSessionRequest {}
+export const GetEntrypointSessionRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}).pipe(
+    T.Http({ method: "GET", uri: "/process/session/entrypoint", code: 200 }),
+  ),
+).annotate({
+  identifier: "GetEntrypointSessionRequest",
+}) as any as S.Schema<GetEntrypointSessionRequest>;
+
+export interface Command {
+  command: string;
+  exitCode?: number;
+  id: string;
+}
+export const Command = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    command: S.String,
+    exitCode: S.optional(S.Number),
+    id: S.String,
+  }),
+).annotate({ identifier: "Command" }) as any as S.Schema<Command>;
+
+export type SessionCommandsList = Array<Command>;
+export const SessionCommandsList = /*@__PURE__*/ S.Array(
+  Command,
+) as any as S.Schema<SessionCommandsList>;
+
+export interface Session {
+  commands: SessionCommandsList;
+  sessionId: string;
+}
+export const Session = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    commands: SessionCommandsList,
+    sessionId: S.String,
+  }),
+).annotate({ identifier: "Session" }) as any as S.Schema<Session>;
+
+export interface GetPtySessionRequest {
+  /** PTY session ID */
+  sessionId: string;
+}
+export const GetPtySessionRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    sessionId: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/process/pty/{sessionId}", code: 200 }),
+  ),
+).annotate({
+  identifier: "GetPtySessionRequest",
+}) as any as S.Schema<GetPtySessionRequest>;
+
+export type PtySessionInfoEnvsMap = { [key: string]: string | undefined };
+export const PtySessionInfoEnvsMap = /*@__PURE__*/ S.Record(
+  S.String,
+  S.String,
+) as any as S.Schema<PtySessionInfoEnvsMap>;
+
+export interface PtySessionInfo {
+  active: boolean;
+  cols: number;
+  createdAt: string;
+  cwd: string;
+  envs: PtySessionInfoEnvsMap;
+  id: string;
+  /** Whether this session uses lazy start */
+  lazyStart: boolean;
+  rows: number;
+}
+export const PtySessionInfo = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    active: S.Boolean,
+    cols: S.Number,
+    createdAt: S.String,
+    cwd: S.String,
+    envs: PtySessionInfoEnvsMap,
+    id: S.String,
+    lazyStart: S.Boolean,
+    rows: S.Number,
+  }),
+).annotate({ identifier: "PtySessionInfo" }) as any as S.Schema<PtySessionInfo>;
+
+export interface GetSessionRequest {
+  /** Session ID */
+  sessionId: string;
+}
+export const GetSessionRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    sessionId: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/process/session/{sessionId}", code: 200 }),
+  ),
+).annotate({
+  identifier: "GetSessionRequest",
+}) as any as S.Schema<GetSessionRequest>;
+
+export interface GetSessionCommandRequest {
+  /** Session ID */
+  sessionId: string;
+  /** Command ID */
+  commandId: string;
+}
+export const GetSessionCommandRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    sessionId: S.String.pipe(T.Label()),
+    commandId: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/process/session/{sessionId}/command/{commandId}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetSessionCommandRequest",
+}) as any as S.Schema<GetSessionCommandRequest>;
+
+export interface GetSessionCommandLogsRequest {
+  /** Session ID */
+  sessionId: string;
+  /** Command ID */
+  commandId: string;
+  /** Follow logs in real-time (WebSocket only) */
+  follow?: boolean;
+}
+export const GetSessionCommandLogsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    sessionId: S.String.pipe(T.Label()),
+    commandId: S.String.pipe(T.Label()),
+    follow: S.optional(S.Boolean.pipe(T.Query())),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/process/session/{sessionId}/command/{commandId}/logs",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetSessionCommandLogsRequest",
+}) as any as S.Schema<GetSessionCommandLogsRequest>;
+
+export interface ListPtySessionsRequest {}
+export const ListPtySessionsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}).pipe(T.Http({ method: "GET", uri: "/process/pty", code: 200 })),
+).annotate({
+  identifier: "ListPtySessionsRequest",
+}) as any as S.Schema<ListPtySessionsRequest>;
+
+export type PtyListResponseSessionsList = Array<PtySessionInfo>;
+export const PtyListResponseSessionsList = /*@__PURE__*/ S.Array(
+  PtySessionInfo,
+) as any as S.Schema<PtyListResponseSessionsList>;
+
+export interface PtyListResponse {
+  sessions: PtyListResponseSessionsList;
+}
+export const PtyListResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    sessions: PtyListResponseSessionsList,
+  }),
+).annotate({
+  identifier: "PtyListResponse",
+}) as any as S.Schema<PtyListResponse>;
+
+export interface ListSessionsRequest {}
+export const ListSessionsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}).pipe(
+    T.Http({ method: "GET", uri: "/process/session", code: 200 }),
+  ),
+).annotate({
+  identifier: "ListSessionsRequest",
+}) as any as S.Schema<ListSessionsRequest>;
+
+export type ListSessionsResponseBodyList = Array<Session>;
+export const ListSessionsResponseBodyList = /*@__PURE__*/ S.Array(
+  Session,
+) as any as S.Schema<ListSessionsResponseBodyList>;
+
+export type ListSessionsResponse = ListSessionsResponseBodyList;
+export const ListSessionsResponse = /*@__PURE__*/ S.suspend(() =>
+  ListSessionsResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListSessionsResponse",
+}) as any as S.Schema<ListSessionsResponse>;
+
+export interface ResizePtySessionRequest {
+  /** PTY session ID */
+  sessionId: string;
+  cols: number;
+  rows: number;
+}
+export const ResizePtySessionRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    sessionId: S.String.pipe(T.Label()),
+    cols: S.Number,
+    rows: S.Number,
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/process/pty/{sessionId}/resize",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "ResizePtySessionRequest",
+}) as any as S.Schema<ResizePtySessionRequest>;
+
+export type RunCodeRequestArgvList = Array<string>;
+export const RunCodeRequestArgvList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<RunCodeRequestArgvList>;
+
+export type RunCodeRequestEnvsMap = { [key: string]: string | undefined };
+export const RunCodeRequestEnvsMap = /*@__PURE__*/ S.Record(
+  S.String,
+  S.String,
+) as any as S.Schema<RunCodeRequestEnvsMap>;
+
+export interface RunCodeRequest {
+  argv?: RunCodeRequestArgvList;
+  code: string;
+  envs?: RunCodeRequestEnvsMap;
+  /** python, javascript, typescript */
+  language: string;
+  timeout?: number;
+}
+export const RunCodeRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    argv: S.optional(RunCodeRequestArgvList),
+    code: S.String,
+    envs: S.optional(RunCodeRequestEnvsMap),
+    language: S.String,
+    timeout: S.optional(S.Number),
+  }).pipe(T.Http({ method: "POST", uri: "/process/code-run", code: 200 })),
+).annotate({ identifier: "RunCodeRequest" }) as any as S.Schema<RunCodeRequest>;
+
+export type ChartElementOutliersList = Array<number>;
+export const ChartElementOutliersList = /*@__PURE__*/ S.Array(
+  S.Number,
+) as any as S.Schema<ChartElementOutliersList>;
+
+export type ChartElementPointsItemList = Array<number>;
+export const ChartElementPointsItemList = /*@__PURE__*/ S.Array(
+  S.Number,
+) as any as S.Schema<ChartElementPointsItemList>;
+
+export type ChartElementPointsList = Array<ChartElementPointsItemList>;
+export const ChartElementPointsList = /*@__PURE__*/ S.Array(
+  ChartElementPointsItemList,
+) as any as S.Schema<ChartElementPointsList>;
+
+export interface ChartElement {
+  angle?: number;
+  first_quartile?: number;
+  group?: string;
+  label?: string;
+  max?: number;
+  median?: number;
+  min?: number;
+  outliers?: ChartElementOutliersList;
+  png?: string;
+  points?: ChartElementPointsList;
+  radius?: number;
+  third_quartile?: number;
+  title?: string;
+  type?: string;
+  value?: string;
+  x_label?: string;
+  y_label?: string;
+}
+export const ChartElement = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    angle: S.optional(S.Number),
+    first_quartile: S.optional(S.Number),
+    group: S.optional(S.String),
+    label: S.optional(S.String),
+    max: S.optional(S.Number),
+    median: S.optional(S.Number),
+    min: S.optional(S.Number),
+    outliers: S.optional(ChartElementOutliersList),
+    png: S.optional(S.String),
+    points: S.optional(ChartElementPointsList),
+    radius: S.optional(S.Number),
+    third_quartile: S.optional(S.Number),
+    title: S.optional(S.String),
+    type: S.optional(S.String),
+    value: S.optional(S.String),
+    x_label: S.optional(S.String),
+    y_label: S.optional(S.String),
+  }),
+).annotate({ identifier: "ChartElement" }) as any as S.Schema<ChartElement>;
+
+export type ChartElementsList = Array<ChartElement>;
+export const ChartElementsList = /*@__PURE__*/ S.Array(
+  ChartElement,
+) as any as S.Schema<ChartElementsList>;
+
+export type ChartXTickLabelsList = Array<string>;
+export const ChartXTickLabelsList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<ChartXTickLabelsList>;
+
+export type ChartXTicksList = Array<number>;
+export const ChartXTicksList = /*@__PURE__*/ S.Array(
+  S.Number,
+) as any as S.Schema<ChartXTicksList>;
+
+export type ChartYTickLabelsList = Array<string>;
+export const ChartYTickLabelsList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<ChartYTickLabelsList>;
+
+export type ChartYTicksList = Array<number>;
+export const ChartYTicksList = /*@__PURE__*/ S.Array(
+  S.Number,
+) as any as S.Schema<ChartYTicksList>;
+
+export interface Chart {
+  elements?: ChartElementsList;
+  png?: string;
+  title?: string;
+  type?: string;
+  x_label?: string;
+  x_scale?: string;
+  x_tick_labels?: ChartXTickLabelsList;
+  x_ticks?: ChartXTicksList;
+  y_label?: string;
+  y_scale?: string;
+  y_tick_labels?: ChartYTickLabelsList;
+  y_ticks?: ChartYTicksList;
+}
+export const Chart = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    elements: S.optional(ChartElementsList),
+    png: S.optional(S.String),
+    title: S.optional(S.String),
+    type: S.optional(S.String),
+    x_label: S.optional(S.String),
+    x_scale: S.optional(S.String),
+    x_tick_labels: S.optional(ChartXTickLabelsList),
+    x_ticks: S.optional(ChartXTicksList),
+    y_label: S.optional(S.String),
+    y_scale: S.optional(S.String),
+    y_tick_labels: S.optional(ChartYTickLabelsList),
+    y_ticks: S.optional(ChartYTicksList),
+  }),
+).annotate({ identifier: "Chart" }) as any as S.Schema<Chart>;
+
+export type CodeRunArtifactsChartsList = Array<Chart>;
+export const CodeRunArtifactsChartsList = /*@__PURE__*/ S.Array(
+  Chart,
+) as any as S.Schema<CodeRunArtifactsChartsList>;
+
+export interface CodeRunArtifacts {
+  charts?: CodeRunArtifactsChartsList;
+}
+export const CodeRunArtifacts = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    charts: S.optional(CodeRunArtifactsChartsList),
+  }),
+).annotate({
+  identifier: "CodeRunArtifacts",
+}) as any as S.Schema<CodeRunArtifacts>;
+
+export interface CodeRunResponse {
+  artifacts?: CodeRunArtifacts;
+  exitCode?: number;
+  result?: string;
+}
+export const CodeRunResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    artifacts: S.optional(CodeRunArtifacts),
+    exitCode: S.optional(S.Number),
+    result: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "CodeRunResponse",
+}) as any as S.Schema<CodeRunResponse>;
+
+export interface SendInputRequest {
+  /** Session ID */
+  sessionId: string;
+  /** Command ID */
+  commandId: string;
+  data: string;
+}
+export const SendInputRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    sessionId: S.String.pipe(T.Label()),
+    commandId: S.String.pipe(T.Label()),
+    data: S.String,
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/process/session/{sessionId}/command/{commandId}/input",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "SendInputRequest",
+}) as any as S.Schema<SendInputRequest>;
+
+export interface SendInputResponse {}
+export const SendInputResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "SendInputResponse",
+}) as any as S.Schema<SendInputResponse>;
+
+export interface SessionExecuteCommandRequest {
+  /** Session ID */
+  sessionId: string;
+  async?: boolean;
+  command: string;
+  runAsync?: boolean;
+  suppressInputEcho?: boolean;
+}
+export const SessionExecuteCommandRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    sessionId: S.String.pipe(T.Label()),
+    async: S.optional(S.Boolean),
+    command: S.String,
+    runAsync: S.optional(S.Boolean),
+    suppressInputEcho: S.optional(S.Boolean),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/process/session/{sessionId}/exec",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "SessionExecuteCommandRequest",
+}) as any as S.Schema<SessionExecuteCommandRequest>;
+
+export interface SessionExecuteResponse {
+  cmdId: string;
+  exitCode?: number;
+  output?: string;
+  stderr?: string;
+  stdout?: string;
+}
+export const SessionExecuteResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    cmdId: S.String,
+    exitCode: S.optional(S.Number),
+    output: S.optional(S.String),
+    stderr: S.optional(S.String),
+    stdout: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "SessionExecuteResponse",
+}) as any as S.Schema<SessionExecuteResponse>;
+
+export type ConnectPtySessionError = DaytonaOpError;
+/** Connect to PTY session via WebSocket Establish a WebSocket connection to interact with a pseudo-terminal session */
+export const connectPtySession: API.OperationMethod<
+  ConnectPtySessionRequest,
+  ConnectPtySessionResponse,
+  ConnectPtySessionError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ConnectPtySessionRequest,
+  output: ConnectPtySessionResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreatePtySessionError = DaytonaOpError;
+/** Create a new PTY session Create a new pseudo-terminal session with specified configuration */
+export const createPtySession: API.OperationMethod<
+  CreatePtySessionRequest,
+  PtyCreateResponse,
+  CreatePtySessionError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreatePtySessionRequest,
+  output: PtyCreateResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateSessionError = DaytonaOpError;
+/** Create a new session Create a new shell session for command execution */
+export const createSession: API.OperationMethod<
+  CreateSessionRequest,
+  CreateSessionResponse,
+  CreateSessionError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateSessionRequest,
+  output: CreateSessionResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeletePtySessionError = DaytonaOpError;
+/** Delete a PTY session Delete a pseudo-terminal session and terminate its process */
+export const deletePtySession: API.OperationMethod<
+  DeletePtySessionRequest,
+  DeletePtySessionResponse,
+  DeletePtySessionError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeletePtySessionRequest,
+  output: DeletePtySessionResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteSessionError = DaytonaOpError;
+/** Delete a session Delete an existing shell session */
+export const deleteSession: API.OperationMethod<
+  DeleteSessionRequest,
+  DeleteSessionResponse,
+  DeleteSessionError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteSessionRequest,
+  output: DeleteSessionResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ExecuteCommandError = DaytonaOpError;
+/** Execute a command Execute a shell command and return the output and exit code */
+export const executeCommand: API.OperationMethod<
+  ExecuteCommandRequest,
+  ExecuteResponse,
+  ExecuteCommandError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ExecuteCommandRequest,
+  output: ExecuteResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetEntrypointLogsError = DaytonaOpError;
+/** Get entrypoint logs Get logs for a sandbox entrypoint session. Returns JSON with separated stdout/stderr for SDK >= 0.161.0, plain text otherwise. Supports WebSocket streaming. */
+export const getEntrypointLogs: API.OperationMethod<
+  GetEntrypointLogsRequest,
+  SessionCommandLogsResponse,
+  GetEntrypointLogsError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetEntrypointLogsRequest,
+  output: SessionCommandLogsResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetEntrypointSessionError = DaytonaOpError;
+/** Get entrypoint session details Get details of an entrypoint session including its commands */
+export const getEntrypointSession: API.OperationMethod<
+  GetEntrypointSessionRequest,
+  Session,
+  GetEntrypointSessionError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetEntrypointSessionRequest,
+  output: Session,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetPtySessionError = DaytonaOpError;
+/** Get PTY session information Get detailed information about a specific pseudo-terminal session */
+export const getPtySession: API.OperationMethod<
+  GetPtySessionRequest,
+  PtySessionInfo,
+  GetPtySessionError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetPtySessionRequest,
+  output: PtySessionInfo,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetSessionError = DaytonaOpError;
+/** Get session details Get details of a specific session including its commands */
+export const getSession: API.OperationMethod<
+  GetSessionRequest,
+  Session,
+  GetSessionError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetSessionRequest,
+  output: Session,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetSessionCommandError = DaytonaOpError;
+/** Get session command details Get details of a specific command within a session */
+export const getSessionCommand: API.OperationMethod<
+  GetSessionCommandRequest,
+  Command,
+  GetSessionCommandError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetSessionCommandRequest,
+  output: Command,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetSessionCommandLogsError = DaytonaOpError;
+/** Get session command logs Get logs for a specific command within a session. Returns JSON with separated stdout/stderr for SDK >= 0.167.0, plain text otherwise. Supports WebSocket streaming. */
+export const getSessionCommandLogs: API.OperationMethod<
+  GetSessionCommandLogsRequest,
+  SessionCommandLogsResponse,
+  GetSessionCommandLogsError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetSessionCommandLogsRequest,
+  output: SessionCommandLogsResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListPtySessionsError = DaytonaOpError;
+/** List all PTY sessions Get a list of all active pseudo-terminal sessions */
+export const listPtySessions: API.OperationMethod<
+  ListPtySessionsRequest,
+  PtyListResponse,
+  ListPtySessionsError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListPtySessionsRequest,
+  output: PtyListResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListSessionsError = DaytonaOpError;
+/** List all sessions Get a list of all active shell sessions */
+export const listSessions: API.OperationMethod<
+  ListSessionsRequest,
+  ListSessionsResponse,
+  ListSessionsError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListSessionsRequest,
+  output: ListSessionsResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ResizePtySessionError = DaytonaOpError;
+/** Resize a PTY session Resize the terminal dimensions of a pseudo-terminal session */
+export const resizePtySession: API.OperationMethod<
+  ResizePtySessionRequest,
+  PtySessionInfo,
+  ResizePtySessionError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ResizePtySessionRequest,
+  output: PtySessionInfo,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type RunCodeError = DaytonaOpError;
+/** Execute code Execute Python, JavaScript, or TypeScript code and return output, exit code, and artifacts */
+export const runCode: API.OperationMethod<
+  RunCodeRequest,
+  CodeRunResponse,
+  RunCodeError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: RunCodeRequest,
+  output: CodeRunResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type SendInputError = DaytonaOpError;
+/** Send input to command Send input data to a running command in a session for interactive execution */
+export const sendInput: API.OperationMethod<
+  SendInputRequest,
+  SendInputResponse,
+  SendInputError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: SendInputRequest,
+  output: SendInputResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type SessionExecuteCommandError = DaytonaOpError;
+/** Execute command in session Execute a command within an existing shell session */
+export const sessionExecuteCommand: API.OperationMethod<
+  SessionExecuteCommandRequest,
+  SessionExecuteResponse,
+  SessionExecuteCommandError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: SessionExecuteCommandRequest,
+  output: SessionExecuteResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));