@qwen-code/web-shell 0.24.6 → 0.24.7

package/dist/types/components/managed/generated/managed-agent-api.d.ts

@@ -0,0 +1,1074 @@
+export interface paths {
+    "/api/agent/web-shell/v1/sessions/query": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post: operations["webShellListSessions"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/agent/web-shell/v1/sessions/get": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post: operations["webShellGetSession"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/agent/web-shell/v1/transcript/query": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** @description Without a cursor, a Session that has a Snapshot returns all of its Items, the events up to the Snapshot other than turn.accepted, item.output_text.delta, item.reasoning.delta and item.tool_call.updated, which the Items already hold, and every event after it. Otherwise, and for an olderCursor, limit bounds the page of events. */
+        post: operations["webShellTranscript"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/agent/web-shell/v1/events/stream": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** @description POST SSE consumed through fetch response.body. An afterSequence below the replay floor ends the stream with one agent.session.resync_required frame instead of a 409; reload the transcript and resume after its lastSequence. */
+        post: operations["webShellStreamEvents"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/agent/web-shell/v1/sessions/create": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** @description W0 maps workspaceId/cwdRelative to the public selection without using environmentId or absolute cwd. Freeze selection with the original idempotency key; admission does not prove physical directory readiness. */
+        post: operations["webShellCreateSession"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/agent/web-shell/v1/turns/submit": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post: operations["webShellSubmitTurn"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/agent/web-shell/v1/turns/cancel": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post: operations["webShellCancelTurn"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/agent/web-shell/v1/workspaces/query": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** @description Same authorization, paging, explicit default and pre-Session capability discovery as listWorkspaces, with camelCase fields. Listing errors must not cause silent fallback to a default directory. */
+        post: operations["webShellQueryWorkspaces"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/agent/web-shell/v1/operations/query": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post: operations["webShellQueryCwdOperation"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/agent/web-shell/v1/sessions/close": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post: operations["closeWebShellSession"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/agent/web-shell/v1/sessions/archive": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post: operations["archiveWebShellSession"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/agent/web-shell/v1/sessions/delete": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post: operations["deleteWebShellSession"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/agent/web-shell/v1/workspaces/get": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** @description Read one authorized Workspace by its logical ID; absent or unreadable Workspaces return 404. No Runtime is started. */
+        post: operations["webShellGetWorkspace"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/agent/web-shell/v1/tasks/query": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post: operations["queryWebShellTasks"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/agent/web-shell/v1/tasks/get": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post: operations["getWebShellTask"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+}
+export type webhooks = Record<string, never>;
+export interface components {
+    schemas: {
+        InputBlock: {
+            /** @enum {string} */
+            type: "input_text";
+            text: string;
+        };
+        WebShellListRequest: {
+            cursor?: string | null;
+            /** @default 20 */
+            limit?: number | null;
+        };
+        WebShellSessionRequest: {
+            /** Format: uuid */
+            sessionId: string;
+        };
+        WebShellTranscriptRequest: {
+            /** Format: uuid */
+            sessionId: string;
+            cursor?: string | null;
+            /** @default 100 */
+            limit?: number | null;
+        };
+        WebShellStreamRequest: {
+            /** Format: uuid */
+            sessionId: string;
+            /**
+             * Format: int64
+             * @default 0
+             */
+            afterSequence?: number | null;
+        };
+        WebShellCreateRequest: {
+            /** @description Trace correlation only. */
+            requestId?: string | null;
+            idempotencyKey: string;
+            agentId: string;
+            /** @description Planned; phase one rejects non-blank values. */
+            environmentId?: string | null;
+            title?: string | null;
+            input?: components["schemas"]["InputBlock"][];
+            metadata?: components["schemas"]["WebShellMetadata"];
+            workspace?: components["schemas"]["WebShellWorkspaceSelection"];
+        };
+        WebShellSubmitRequest: {
+            /** @description Trace correlation only. */
+            requestId?: string | null;
+            idempotencyKey: string;
+            /** Format: uuid */
+            sessionId: string;
+            input?: components["schemas"]["InputBlock"][];
+            metadata?: components["schemas"]["WebShellMetadata"];
+        };
+        WebShellCancelRequest: {
+            /** @description Trace correlation only. */
+            requestId?: string | null;
+            idempotencyKey: string;
+            /** Format: uuid */
+            sessionId: string;
+            turnId: string;
+        };
+        WebShellMetadata: {
+            clientId?: string;
+        } | null;
+        /** @description With durable_operations enabled, all three target fields are returned. accepted means Java durable delivery responsibility, not model execution. Missing fields retain the deployed legacy response semantics. */
+        WebShellAdmission: {
+            /** Format: uuid */
+            sessionId: string;
+            turnId?: string | null;
+            status: string;
+            replayed: boolean;
+        };
+        WebShellTurn: {
+            turnId: string;
+            /** Format: uuid */
+            sessionId: string;
+            status: string;
+            /** Format: int64 */
+            submittedAt: number;
+            /** Format: int64 */
+            completedAt?: number | null;
+            errorCode?: string | null;
+            usage?: {
+                [key: string]: unknown;
+            } | null;
+        };
+        WebShellSession: {
+            /** Format: uuid */
+            sessionId: string;
+            title?: string | null;
+            agentId: string;
+            status: string;
+            /** Format: int64 */
+            createdAt: number;
+            /** Format: int64 */
+            updatedAt: number;
+            activeTurn?: components["schemas"]["WebShellTurn"] | null;
+            environment?: {
+                [key: string]: unknown;
+            } | null;
+            /** Format: int64 */
+            lastSequence: number;
+            workspace?: components["schemas"]["WebShellWorkspaceContext"];
+            capabilities?: components["schemas"]["WebShellSessionCapabilities"];
+        };
+        WebShellSessionCapabilities: {
+            tasks: boolean;
+        };
+        WebShellSessionPage: {
+            data: components["schemas"]["WebShellSession"][];
+            nextCursor?: string | null;
+            hasMore: boolean;
+        };
+        WebShellTranscript: {
+            items: components["schemas"]["WebShellItem"][];
+            events: components["schemas"]["WebShellEvent"][];
+            /** Format: int64 */
+            coveredSequence: number;
+            olderCursor?: string | null;
+            hasMore: boolean;
+            /** Format: int64 */
+            lastSequence: number;
+        };
+        WebShellContentPart: {
+            partId: string;
+            type: string;
+            text: string;
+            /** Format: int64 */
+            firstSequence: number;
+            /** Format: int64 */
+            lastSequence: number;
+        };
+        WebShellItem: {
+            itemId: string;
+            /** Format: uuid */
+            sessionId: string;
+            turnId: string;
+            type: string;
+            role?: string | null;
+            status: string;
+            content: components["schemas"]["WebShellContentPart"][];
+            attributes: {
+                [key: string]: unknown;
+            };
+            /** Format: int64 */
+            firstSequence: number;
+            /** Format: int64 */
+            lastSequence: number;
+            /** Format: int64 */
+            createdAt: number;
+            /** Format: int64 */
+            updatedAt: number;
+        };
+        /** @description A committed event, replayed with the versions and identity it was accepted with. A stream.reconciled event is the exception: it means that Harness recovery retracted earlier deltas of its Turn, which now have empty text and no itemId or contentPartId, and that later deltas may name other Parts. Reload the transcript and resume after its lastSequence. */
+        WebShellEvent: {
+            /** @default 1 */
+            schemaVersion?: number;
+            /** @default 1 */
+            projectionVersion?: number;
+            /** Format: int64 */
+            sequence: number;
+            eventId: string;
+            /** Format: uuid */
+            sessionId: string;
+            turnId?: string | null;
+            itemId?: string | null;
+            contentPartId?: string | null;
+            type: string;
+            /** Format: int64 */
+            createdAt: number;
+            data: {
+                [key: string]: unknown;
+            };
+            terminal: boolean;
+        };
+        /** @description Data of the agent.session.resync_required SSE frame. Reload the transcript, then resume after its lastSequence. */
+        WebShellResyncRequired: {
+            /** @constant */
+            type: "agent.session.resync_required";
+            /** Format: uuid */
+            sessionId: string;
+            /** Format: int64 */
+            replayFloorSequence: number;
+            /** Format: int64 */
+            snapshotThroughSequence: number;
+            /** @constant */
+            action: "reload_snapshot";
+        };
+        ErrorEnvelope: {
+            error: {
+                code: string;
+                message: string;
+                request_id: string;
+                /** Format: int64 */
+                replay_floor_sequence?: number | null;
+                /** Format: int64 */
+                snapshot_through_sequence?: number | null;
+            };
+        };
+        /**
+         * @description Logical directory relative to the authorized workspace root; dot denotes root. Use slash separators. Reject absolute paths, drive prefixes, backslashes, NUL and parent segments. Runtime must verify directory existence, realpath containment and symlink safety before activation; schema validation alone is insufficient. Preserve spaces and case, normalize repeated separators and dot segments, and never percent-decode JSON values.
+         * @example .
+         * @example services/api
+         */
+        WorkspaceRelativePath: string;
+        WebShellWorkspaceSelection: {
+            workspaceId: string;
+            /** @default . */
+            cwdRelative?: components["schemas"]["WorkspaceRelativePath"];
+        };
+        WebShellWorkspaceContext: {
+            workspaceId: string;
+            cwdRelative: components["schemas"]["WorkspaceRelativePath"];
+            /** Format: int64 */
+            contextRevision: number;
+            /** @enum {string} */
+            state: "ready" | "changing" | "recovery_blocked";
+        };
+        WebShellWorkspace: {
+            workspaceId: string;
+            displayName: string;
+            /** @description Current actor permission hint only; creation rechecks ACL, state and Agent/config compatibility. */
+            canCreateSession: boolean;
+            /** @enum {string} */
+            state: "active" | "draining" | "removed";
+        };
+        WebShellWorkspacePage: {
+            data: components["schemas"]["WebShellWorkspace"][];
+            hasMore: boolean;
+            nextCursor?: string | null;
+            capabilities: {
+                /**
+                 * @description Same end-to-end W0 readiness as public workspace_context; missing means unsupported.
+                 * @default false
+                 */
+                workspaceContext: boolean;
+                /** @description Supports authorized Workspace discovery, empty Session creation, and saved binding read-back; does not enable execution. */
+                workspaceBinding: boolean;
+            };
+            /** @description Same authorized explicit default as default_workspace, including when outside this page; null if absent or not creatable. A non-null default is active and has canCreateSession=true. */
+            defaultWorkspace: (components["schemas"]["WebShellWorkspace"] & {
+                /** @constant */
+                state?: "active";
+                /** @constant */
+                canCreateSession?: true;
+            }) | null;
+        };
+        WebShellOperationRequest: {
+            /** Format: uuid */
+            sessionId: string;
+            operationId: string;
+        };
+        /** @description Receipt IDs are opaque authorized product handles, not private journal or storage refs. Input/cancel completion is command acceptance, not Turn completion or physical stop. Action completion may only record one vote. Lifecycle completion requires its cleanup facts; archive may remain java_durable because Java is its authority. Task cancel completion means that the authority recorded the cancel, not that the task stopped: the task becomes cancelled only after its physical execution settles. */
+        WebShellCommandOperation: {
+            operationId: string;
+            /** Format: uuid */
+            sessionId: string;
+            /** @enum {unknown} */
+            type: "create_session" | "submit_input" | "cancel" | "action_response" | "close" | "archive" | "delete" | "task_cancel";
+            /** @enum {unknown} */
+            status: "pending" | "running" | "completed" | "failed" | "cancelled" | "recovery_blocked";
+            /** @enum {unknown} */
+            admissionStage: "java_durable" | "harness_confirmed";
+            /** @enum {unknown} */
+            deliveryState: "pending" | "leased" | "confirmed" | "blocked";
+            receiptId?: string;
+            replayed: boolean;
+        } & (unknown & unknown & unknown & unknown);
+        WebShellOperation: components["schemas"]["WebShellCommandOperation"];
+        WebShellLifecycleRequest: {
+            /** Format: uuid */
+            sessionId: string;
+            idempotencyKey: string;
+        };
+        WebShellWorkspaceQueryRequest: {
+            cursor?: string | null;
+            /** @default 50 */
+            limit?: number | null;
+        };
+        WebShellWorkspaceGetRequest: {
+            workspaceId: string;
+        };
+        /** @enum {string} */
+        TaskKind: "child_agent" | "workflow" | "background_shell" | "monitor" | "automation_run";
+        /**
+         * @description Logical run state. completed, failed and cancelled are terminal and are set only after the physical execution has settled. degraded means that the task still runs with reduced guarantees, such as a Monitor that lost its observation source. recovery_blocked means that recovery cannot prove the physical outcome: it is not settled, is never reported as success and is never re-run automatically.
+         * @enum {string}
+         */
+        TaskState: "pending" | "running" | "waiting" | "completed" | "failed" | "cancelled" | "degraded" | "recovery_blocked";
+        /**
+         * @description Redacted state of the Runtime that hosts the task, without binding identity or generation.
+         * @enum {string}
+         */
+        TaskRuntimeState: "unbound" | "provisioning" | "ready" | "draining" | "lost";
+        /**
+         * @description Actions the task supports now, the same for every caller. cancel: the cancel route accepts a new command for this task; whether a caller may use it is an authorization check (403 on the cancel route). send_input: reserved for a later capability route. read_output: the task events route returns output events for this task to any caller that can read it. read_output does not change during the task's life, and a task without it produces no output events: its output goes only to Artifacts, so the events route never filters out events that exist.
+         * @enum {string}
+         */
+        TaskActionCapability: "cancel" | "send_input" | "read_output";
+        /** @description Read-only projection of one asynchronous task of a Session (SessionTaskView). It is rebuilt from the Session's durable domain records and is never their source of truth. It never carries a Runtime binding ID, generation, Runtime endpoint, Pod, absolute path, raw PID, SecretHandle or local sidecar; diagnostics are authorized Artifact references. */
+        WebShellTask: {
+            taskId: string;
+            /** Format: uuid */
+            sessionId: string;
+            kind: components["schemas"]["TaskKind"];
+            state: components["schemas"]["TaskState"];
+            /**
+             * Format: int64
+             * @description Immutable definition revision this run is pinned to, when the kind has a definition.
+             */
+            definitionRevision?: number;
+            runtimeState?: components["schemas"]["TaskRuntimeState"];
+            /**
+             * Format: int64
+             * @description Unix epoch milliseconds.
+             */
+            createdAt: number;
+            /**
+             * Format: int64
+             * @description Unix epoch milliseconds.
+             */
+            startedAt?: number;
+            /**
+             * Format: int64
+             * @description Unix epoch milliseconds.
+             */
+            settledAt?: number;
+            /** @description The newest Artifacts that hold durable task output, at most 100, oldest first; older Artifacts stay readable through the Session artifact routes. */
+            artifactRefs: string[];
+            actionCapabilities: components["schemas"]["TaskActionCapability"][];
+        } & (unknown & unknown & unknown & unknown);
+        WebShellTaskPage: {
+            data: components["schemas"]["WebShellTask"][];
+            hasMore: boolean;
+            nextCursor?: string | null;
+        } & unknown;
+        WebShellTaskQueryRequest: {
+            /** Format: uuid */
+            sessionId: string;
+            cursor?: string;
+            /** @default 20 */
+            limit?: number;
+        };
+        WebShellTaskGetRequest: {
+            /** Format: uuid */
+            sessionId: string;
+            taskId: string;
+        };
+    };
+    responses: {
+        /** @description The authenticated actor belongs to another tenant than X-Qwen-Tenant-Id or has an invalid ID (actor_scope_mismatch, which the tenant filter answers on every /v1/agents/ and WebShell route), or the resource is readable but the actor lacks this operation or the original Action responder permission. */
+        Forbidden: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": components["schemas"]["ErrorEnvelope"];
+            };
+        };
+        /** @description A trusted actor is required for this request but none was supplied. */
+        Unauthorized: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": components["schemas"]["ErrorEnvelope"];
+            };
+        };
+        /** @description Invalid request. */
+        BadRequest: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": components["schemas"]["ErrorEnvelope"];
+            };
+        };
+        /** @description State, idempotency, or recovery conflict. */
+        Conflict: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": components["schemas"]["ErrorEnvelope"];
+            };
+        };
+        /** @description Resource absent or outside the caller tenant scope. */
+        NotFound: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": components["schemas"]["ErrorEnvelope"];
+            };
+        };
+        /** @description A dependency such as the Hosted Harness is unavailable; retry later. */
+        Unavailable: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": components["schemas"]["ErrorEnvelope"];
+            };
+        };
+    };
+    parameters: never;
+    requestBodies: never;
+    headers: {
+        /** @description Trace-only correlation identifier; never an idempotency key. */
+        RequestId: string;
+    };
+    pathItems: never;
+}
+export type $defs = Record<string, never>;
+export interface operations {
+    webShellListSessions: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["WebShellListRequest"];
+            };
+        };
+        responses: {
+            /** @description WebShell session page. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["WebShellSessionPage"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            403: components["responses"]["Forbidden"];
+        };
+    };
+    webShellGetSession: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["WebShellSessionRequest"];
+            };
+        };
+        responses: {
+            /** @description WebShell session. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["WebShellSession"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+        };
+    };
+    webShellTranscript: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["WebShellTranscriptRequest"];
+            };
+        };
+        responses: {
+            /** @description Event transcript page. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["WebShellTranscript"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            404: components["responses"]["NotFound"];
+        };
+    };
+    webShellStreamEvents: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["WebShellStreamRequest"];
+            };
+        };
+        responses: {
+            /** @description SSE stream. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "text/event-stream": string;
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            404: components["responses"]["NotFound"];
+        };
+    };
+    webShellCreateSession: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["WebShellCreateRequest"];
+            };
+        };
+        responses: {
+            /** @description Session admitted. */
+            202: {
+                headers: {
+                    "X-Request-Id": components["headers"]["RequestId"];
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["WebShellAdmission"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+            409: components["responses"]["Conflict"];
+            503: components["responses"]["Unavailable"];
+        };
+    };
+    webShellSubmitTurn: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["WebShellSubmitRequest"];
+            };
+        };
+        responses: {
+            /** @description Turn admitted. */
+            202: {
+                headers: {
+                    "X-Request-Id": components["headers"]["RequestId"];
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["WebShellAdmission"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            404: components["responses"]["NotFound"];
+            409: components["responses"]["Conflict"];
+        };
+    };
+    webShellCancelTurn: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["WebShellCancelRequest"];
+            };
+        };
+        responses: {
+            /** @description Cancellation durably admitted. */
+            202: {
+                headers: {
+                    "X-Request-Id": components["headers"]["RequestId"];
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["WebShellAdmission"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            404: components["responses"]["NotFound"];
+            409: components["responses"]["Conflict"];
+        };
+    };
+    webShellQueryWorkspaces: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["WebShellWorkspaceQueryRequest"];
+            };
+        };
+        responses: {
+            /** @description Authorized durable resource view; no Runtime startup required. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["WebShellWorkspacePage"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            404: components["responses"]["NotFound"];
+        };
+    };
+    webShellQueryCwdOperation: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["WebShellOperationRequest"];
+            };
+        };
+        responses: {
+            /** @description Same authorized operation semantics as the public API. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["WebShellOperation"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+            409: components["responses"]["Conflict"];
+        };
+    };
+    closeWebShellSession: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["WebShellLifecycleRequest"];
+            };
+        };
+        responses: {
+            /** @description Same authorized operation semantics as the public API. */
+            202: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["WebShellCommandOperation"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+            409: components["responses"]["Conflict"];
+        };
+    };
+    archiveWebShellSession: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["WebShellLifecycleRequest"];
+            };
+        };
+        responses: {
+            /** @description Same authorized operation semantics as the public API. */
+            202: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["WebShellCommandOperation"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+            409: components["responses"]["Conflict"];
+        };
+    };
+    deleteWebShellSession: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["WebShellLifecycleRequest"];
+            };
+        };
+        responses: {
+            /** @description Same authorized operation semantics as the public API. */
+            202: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["WebShellCommandOperation"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+            409: components["responses"]["Conflict"];
+        };
+    };
+    webShellGetWorkspace: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["WebShellWorkspaceGetRequest"];
+            };
+        };
+        responses: {
+            /** @description Authorized durable resource view; no Runtime startup required. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["WebShellWorkspace"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            404: components["responses"]["NotFound"];
+        };
+    };
+    queryWebShellTasks: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["WebShellTaskQueryRequest"];
+            };
+        };
+        responses: {
+            /** @description Same authorized task semantics as the public API. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["WebShellTaskPage"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+        };
+    };
+    getWebShellTask: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["WebShellTaskGetRequest"];
+            };
+        };
+        responses: {
+            /** @description Same authorized task semantics as the public API. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["WebShellTask"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+        };
+    };
+}