@opencode-ai/client 0.0.0-next-14944

package/dist/promise/generated/client.js

@@ -0,0 +1,970 @@
+import { ClientError } from "./client-error";
+export function make(options) {
+    const fetch = options.fetch ?? globalThis.fetch;
+    const prepare = (descriptor, requestOptions) => {
+        const url = new URL(descriptor.path, options.baseUrl);
+        for (const [key, value] of Object.entries(descriptor.query ?? {}))
+            appendQuery(url.searchParams, key, value);
+        const headers = new Headers(options.headers);
+        for (const [key, value] of Object.entries(descriptor.headers ?? {})) {
+            if (value !== undefined && value !== null)
+                headers.set(key, String(value));
+        }
+        for (const [key, value] of new Headers(requestOptions?.headers))
+            headers.set(key, value);
+        if (descriptor.body !== undefined && !headers.has("content-type"))
+            headers.set("content-type", "application/json");
+        return {
+            url,
+            init: {
+                method: descriptor.method,
+                signal: requestOptions?.signal,
+                headers,
+                body: descriptor.body === undefined ? undefined : JSON.stringify(descriptor.body),
+            },
+        };
+    };
+    const execute = async (descriptor, requestOptions) => {
+        try {
+            const prepared = prepare(descriptor, requestOptions);
+            return await fetch(prepared.url, prepared.init);
+        }
+        catch (cause) {
+            throw new ClientError("Transport", { cause });
+        }
+    };
+    const responseError = async (response, descriptor) => {
+        if (descriptor.declaredStatuses.includes(response.status))
+            throw await json(response);
+        try {
+            await response.body?.cancel();
+        }
+        catch { }
+        throw new ClientError("UnexpectedStatus", { cause: { status: response.status } });
+    };
+    const request = async (descriptor, requestOptions) => {
+        const response = await execute(descriptor, requestOptions);
+        if (response.status !== descriptor.successStatus)
+            return responseError(response, descriptor);
+        if (descriptor.binary)
+            return new Uint8Array(await response.arrayBuffer());
+        if (descriptor.empty) {
+            try {
+                await response.body?.cancel();
+            }
+            catch { }
+            return undefined;
+        }
+        return (await json(response));
+    };
+    const sse = (descriptor, requestOptions) => ({
+        async *[Symbol.asyncIterator]() {
+            const response = await execute(descriptor, requestOptions);
+            if (response.status !== descriptor.successStatus)
+                await responseError(response, descriptor);
+            if (!isContentType(response, "text/event-stream")) {
+                try {
+                    await response.body?.cancel();
+                }
+                catch { }
+                throw new ClientError("UnsupportedContentType");
+            }
+            if (response.body === null)
+                throw new ClientError("MalformedResponse");
+            const reader = response.body.getReader();
+            const decoder = new TextDecoder();
+            let buffer = "";
+            try {
+                while (true) {
+                    let next;
+                    try {
+                        next = await reader.read();
+                    }
+                    catch (cause) {
+                        throw new ClientError("Transport", { cause });
+                    }
+                    buffer += decoder.decode(next.value, { stream: !next.done });
+                    if (buffer.length > 1_048_576)
+                        throw new ClientError("MalformedResponse");
+                    const trailingCarriageReturn = !next.done && buffer.endsWith("\r");
+                    if (trailingCarriageReturn)
+                        buffer = buffer.slice(0, -1);
+                    buffer = buffer.replaceAll("\r\n", "\n").replaceAll("\r", "\n");
+                    if (trailingCarriageReturn)
+                        buffer += "\r";
+                    if (next.done && buffer !== "")
+                        buffer += "\n\n";
+                    let boundary = buffer.indexOf("\n\n");
+                    while (boundary >= 0) {
+                        const block = buffer.slice(0, boundary);
+                        buffer = buffer.slice(boundary + 2);
+                        const data = block
+                            .split("\n")
+                            .flatMap((line) => (line.startsWith("data:") ? [line.slice(5).trimStart()] : []))
+                            .join("\n");
+                        if (data !== "") {
+                            try {
+                                yield JSON.parse(data);
+                            }
+                            catch (cause) {
+                                throw new ClientError("MalformedResponse", { cause });
+                            }
+                        }
+                        boundary = buffer.indexOf("\n\n");
+                    }
+                    if (next.done)
+                        return;
+                }
+            }
+            finally {
+                try {
+                    await reader.cancel();
+                }
+                catch { }
+                reader.releaseLock();
+            }
+        },
+    });
+    return {
+        health: {
+            get: (requestOptions) => request({ method: "GET", path: `/api/health`, successStatus: 200, declaredStatuses: [401, 400], empty: false }, requestOptions),
+        },
+        location: {
+            get: (input, requestOptions) => request({
+                method: "GET",
+                path: `/api/location`,
+                query: { location: input?.["location"] },
+                successStatus: 200,
+                declaredStatuses: [401, 400],
+                empty: false,
+            }, requestOptions),
+        },
+        agent: {
+            list: (input, requestOptions) => request({
+                method: "GET",
+                path: `/api/agent`,
+                query: { location: input?.["location"] },
+                successStatus: 200,
+                declaredStatuses: [401, 400],
+                empty: false,
+            }, requestOptions),
+        },
+        plugin: {
+            list: (input, requestOptions) => request({
+                method: "GET",
+                path: `/api/plugin`,
+                query: { location: input?.["location"] },
+                successStatus: 200,
+                declaredStatuses: [401, 400],
+                empty: false,
+            }, requestOptions),
+        },
+        session: {
+            list: (input, requestOptions) => request({
+                method: "GET",
+                path: `/api/session`,
+                query: {
+                    workspace: input?.["workspace"],
+                    limit: input?.["limit"],
+                    order: input?.["order"],
+                    search: input?.["search"],
+                    parentID: input?.["parentID"],
+                    directory: input?.["directory"],
+                    project: input?.["project"],
+                    subpath: input?.["subpath"],
+                    cursor: input?.["cursor"],
+                },
+                successStatus: 200,
+                declaredStatuses: [400, 401],
+                empty: false,
+            }, requestOptions),
+            create: (input, requestOptions) => request({
+                method: "POST",
+                path: `/api/session`,
+                body: {
+                    id: input?.["id"],
+                    agent: input?.["agent"],
+                    model: input?.["model"],
+                    location: input?.["location"],
+                },
+                successStatus: 200,
+                declaredStatuses: [401, 400],
+                empty: false,
+            }, requestOptions).then((value) => value.data),
+            active: (requestOptions) => request({
+                method: "GET",
+                path: `/api/session/active`,
+                successStatus: 200,
+                declaredStatuses: [401, 400],
+                empty: false,
+            }, requestOptions),
+            get: (input, requestOptions) => request({
+                method: "GET",
+                path: `/api/session/${encodeURIComponent(input.sessionID)}`,
+                successStatus: 200,
+                declaredStatuses: [404, 400, 401],
+                empty: false,
+            }, requestOptions).then((value) => value.data),
+            fork: (input, requestOptions) => request({
+                method: "POST",
+                path: `/api/session/${encodeURIComponent(input.sessionID)}/fork`,
+                body: { messageID: input["messageID"] },
+                successStatus: 200,
+                declaredStatuses: [404, 400, 401],
+                empty: false,
+            }, requestOptions).then((value) => value.data),
+            switchAgent: (input, requestOptions) => request({
+                method: "POST",
+                path: `/api/session/${encodeURIComponent(input.sessionID)}/agent`,
+                body: { agent: input["agent"] },
+                successStatus: 204,
+                declaredStatuses: [404, 400, 401],
+                empty: true,
+            }, requestOptions),
+            switchModel: (input, requestOptions) => request({
+                method: "POST",
+                path: `/api/session/${encodeURIComponent(input.sessionID)}/model`,
+                body: { model: input["model"] },
+                successStatus: 204,
+                declaredStatuses: [404, 400, 401],
+                empty: true,
+            }, requestOptions),
+            rename: (input, requestOptions) => request({
+                method: "POST",
+                path: `/api/session/${encodeURIComponent(input.sessionID)}/rename`,
+                body: { title: input["title"] },
+                successStatus: 204,
+                declaredStatuses: [404, 400, 401],
+                empty: true,
+            }, requestOptions),
+            prompt: (input, requestOptions) => request({
+                method: "POST",
+                path: `/api/session/${encodeURIComponent(input.sessionID)}/prompt`,
+                body: { id: input["id"], prompt: input["prompt"], delivery: input["delivery"], resume: input["resume"] },
+                successStatus: 200,
+                declaredStatuses: [409, 404, 400, 401],
+                empty: false,
+            }, requestOptions).then((value) => value.data),
+            command: (input, requestOptions) => request({
+                method: "POST",
+                path: `/api/session/${encodeURIComponent(input.sessionID)}/command`,
+                body: {
+                    id: input["id"],
+                    command: input["command"],
+                    arguments: input["arguments"],
+                    agent: input["agent"],
+                    model: input["model"],
+                    files: input["files"],
+                    agents: input["agents"],
+                    delivery: input["delivery"],
+                    resume: input["resume"],
+                },
+                successStatus: 200,
+                declaredStatuses: [409, 404, 500, 400, 401],
+                empty: false,
+            }, requestOptions).then((value) => value.data),
+            skill: (input, requestOptions) => request({
+                method: "POST",
+                path: `/api/session/${encodeURIComponent(input.sessionID)}/skill`,
+                body: { id: input["id"], skill: input["skill"], resume: input["resume"] },
+                successStatus: 204,
+                declaredStatuses: [404, 400, 401],
+                empty: true,
+            }, requestOptions),
+            synthetic: (input, requestOptions) => request({
+                method: "POST",
+                path: `/api/session/${encodeURIComponent(input.sessionID)}/synthetic`,
+                body: { text: input["text"], description: input["description"], metadata: input["metadata"] },
+                successStatus: 204,
+                declaredStatuses: [404, 400, 401],
+                empty: true,
+            }, requestOptions),
+            shell: (input, requestOptions) => request({
+                method: "POST",
+                path: `/api/session/${encodeURIComponent(input.sessionID)}/shell`,
+                body: { id: input["id"], command: input["command"] },
+                successStatus: 204,
+                declaredStatuses: [404, 400, 401],
+                empty: true,
+            }, requestOptions),
+            compact: (input, requestOptions) => request({
+                method: "POST",
+                path: `/api/session/${encodeURIComponent(input.sessionID)}/compact`,
+                successStatus: 204,
+                declaredStatuses: [404, 409, 503, 500, 400, 401],
+                empty: true,
+            }, requestOptions),
+            wait: (input, requestOptions) => request({
+                method: "POST",
+                path: `/api/session/${encodeURIComponent(input.sessionID)}/wait`,
+                successStatus: 204,
+                declaredStatuses: [404, 503, 400, 401],
+                empty: true,
+            }, requestOptions),
+            revertStage: (input, requestOptions) => request({
+                method: "POST",
+                path: `/api/session/${encodeURIComponent(input.sessionID)}/revert/stage`,
+                body: { messageID: input["messageID"], files: input["files"] },
+                successStatus: 200,
+                declaredStatuses: [404, 409, 500, 400, 401],
+                empty: false,
+            }, requestOptions).then((value) => value.data),
+            revertClear: (input, requestOptions) => request({
+                method: "POST",
+                path: `/api/session/${encodeURIComponent(input.sessionID)}/revert/clear`,
+                successStatus: 204,
+                declaredStatuses: [404, 409, 500, 400, 401],
+                empty: true,
+            }, requestOptions),
+            revertCommit: (input, requestOptions) => request({
+                method: "POST",
+                path: `/api/session/${encodeURIComponent(input.sessionID)}/revert/commit`,
+                successStatus: 204,
+                declaredStatuses: [404, 409, 400, 401],
+                empty: true,
+            }, requestOptions),
+            context: (input, requestOptions) => request({
+                method: "GET",
+                path: `/api/session/${encodeURIComponent(input.sessionID)}/context`,
+                successStatus: 200,
+                declaredStatuses: [404, 500, 400, 401],
+                empty: false,
+            }, requestOptions).then((value) => value.data),
+            listContextEntries: (input, requestOptions) => request({
+                method: "GET",
+                path: `/api/session/${encodeURIComponent(input.sessionID)}/context-entry`,
+                successStatus: 200,
+                declaredStatuses: [404, 400, 401],
+                empty: false,
+            }, requestOptions).then((value) => value.data),
+            putContextEntry: (input, requestOptions) => request({
+                method: "PUT",
+                path: `/api/session/${encodeURIComponent(input.sessionID)}/context-entry/${encodeURIComponent(input.key)}`,
+                body: { value: input["value"] },
+                successStatus: 204,
+                declaredStatuses: [404, 400, 401],
+                empty: true,
+            }, requestOptions),
+            removeContextEntry: (input, requestOptions) => request({
+                method: "DELETE",
+                path: `/api/session/${encodeURIComponent(input.sessionID)}/context-entry/${encodeURIComponent(input.key)}`,
+                successStatus: 204,
+                declaredStatuses: [404, 400, 401],
+                empty: true,
+            }, requestOptions),
+            log: (input, requestOptions) => sse({
+                method: "GET",
+                path: `/api/session/${encodeURIComponent(input.sessionID)}/log`,
+                query: { after: input["after"], follow: input["follow"] },
+                successStatus: 200,
+                declaredStatuses: [404, 400, 401],
+                empty: false,
+            }, requestOptions),
+            interrupt: (input, requestOptions) => request({
+                method: "POST",
+                path: `/api/session/${encodeURIComponent(input.sessionID)}/interrupt`,
+                successStatus: 204,
+                declaredStatuses: [404, 400, 401],
+                empty: true,
+            }, requestOptions),
+            background: (input, requestOptions) => request({
+                method: "POST",
+                path: `/api/session/${encodeURIComponent(input.sessionID)}/background`,
+                successStatus: 204,
+                declaredStatuses: [404, 400, 401],
+                empty: true,
+            }, requestOptions),
+            message: (input, requestOptions) => request({
+                method: "GET",
+                path: `/api/session/${encodeURIComponent(input.sessionID)}/message/${encodeURIComponent(input.messageID)}`,
+                successStatus: 200,
+                declaredStatuses: [404, 400, 401],
+                empty: false,
+            }, requestOptions).then((value) => value.data),
+        },
+        message: {
+            list: (input, requestOptions) => request({
+                method: "GET",
+                path: `/api/session/${encodeURIComponent(input.sessionID)}/message`,
+                query: { limit: input["limit"], order: input["order"], cursor: input["cursor"] },
+                successStatus: 200,
+                declaredStatuses: [400, 404, 500, 401],
+                empty: false,
+            }, requestOptions),
+        },
+        model: {
+            list: (input, requestOptions) => request({
+                method: "GET",
+                path: `/api/model`,
+                query: { location: input?.["location"] },
+                successStatus: 200,
+                declaredStatuses: [503, 401, 400],
+                empty: false,
+            }, requestOptions),
+            default: (input, requestOptions) => request({
+                method: "GET",
+                path: `/api/model/default`,
+                query: { location: input?.["location"] },
+                successStatus: 200,
+                declaredStatuses: [503, 401, 400],
+                empty: false,
+            }, requestOptions),
+        },
+        generate: {
+            text: (input, requestOptions) => request({
+                method: "POST",
+                path: `/api/generate`,
+                query: { location: input["location"] },
+                body: { prompt: input["prompt"], model: input["model"] },
+                successStatus: 200,
+                declaredStatuses: [400, 503, 401],
+                empty: false,
+            }, requestOptions).then((value) => value.data),
+        },
+        provider: {
+            list: (input, requestOptions) => request({
+                method: "GET",
+                path: `/api/provider`,
+                query: { location: input?.["location"] },
+                successStatus: 200,
+                declaredStatuses: [503, 401, 400],
+                empty: false,
+            }, requestOptions),
+            get: (input, requestOptions) => request({
+                method: "GET",
+                path: `/api/provider/${encodeURIComponent(input.providerID)}`,
+                query: { location: input["location"] },
+                successStatus: 200,
+                declaredStatuses: [404, 503, 401, 400],
+                empty: false,
+            }, requestOptions),
+        },
+        integration: {
+            list: (input, requestOptions) => request({
+                method: "GET",
+                path: `/api/integration`,
+                query: { location: input?.["location"] },
+                successStatus: 200,
+                declaredStatuses: [401, 400],
+                empty: false,
+            }, requestOptions),
+            get: (input, requestOptions) => request({
+                method: "GET",
+                path: `/api/integration/${encodeURIComponent(input.integrationID)}`,
+                query: { location: input["location"] },
+                successStatus: 200,
+                declaredStatuses: [401, 400],
+                empty: false,
+            }, requestOptions),
+            connectKey: (input, requestOptions) => request({
+                method: "POST",
+                path: `/api/integration/${encodeURIComponent(input.integrationID)}/connect/key`,
+                query: { location: input["location"] },
+                body: { key: input["key"], label: input["label"] },
+                successStatus: 204,
+                declaredStatuses: [400, 401],
+                empty: true,
+            }, requestOptions),
+            connectOauth: (input, requestOptions) => request({
+                method: "POST",
+                path: `/api/integration/${encodeURIComponent(input.integrationID)}/connect/oauth`,
+                query: { location: input["location"] },
+                body: { methodID: input["methodID"], inputs: input["inputs"], label: input["label"] },
+                successStatus: 200,
+                declaredStatuses: [400, 401],
+                empty: false,
+            }, requestOptions),
+            attemptStatus: (input, requestOptions) => request({
+                method: "GET",
+                path: `/api/integration/attempt/${encodeURIComponent(input.attemptID)}`,
+                query: { location: input["location"] },
+                successStatus: 200,
+                declaredStatuses: [401, 400],
+                empty: false,
+            }, requestOptions),
+            attemptComplete: (input, requestOptions) => request({
+                method: "POST",
+                path: `/api/integration/attempt/${encodeURIComponent(input.attemptID)}/complete`,
+                query: { location: input["location"] },
+                body: { code: input["code"] },
+                successStatus: 204,
+                declaredStatuses: [400, 401],
+                empty: true,
+            }, requestOptions),
+            attemptCancel: (input, requestOptions) => request({
+                method: "DELETE",
+                path: `/api/integration/attempt/${encodeURIComponent(input.attemptID)}`,
+                query: { location: input["location"] },
+                successStatus: 204,
+                declaredStatuses: [401, 400],
+                empty: true,
+            }, requestOptions),
+        },
+        "server.mcp": {
+            list: (input, requestOptions) => request({
+                method: "GET",
+                path: `/api/mcp`,
+                query: { location: input?.["location"] },
+                successStatus: 200,
+                declaredStatuses: [401, 400],
+                empty: false,
+            }, requestOptions),
+        },
+        credential: {
+            update: (input, requestOptions) => request({
+                method: "PATCH",
+                path: `/api/credential/${encodeURIComponent(input.credentialID)}`,
+                query: { location: input["location"] },
+                body: { label: input["label"] },
+                successStatus: 204,
+                declaredStatuses: [401, 400],
+                empty: true,
+            }, requestOptions),
+            remove: (input, requestOptions) => request({
+                method: "DELETE",
+                path: `/api/credential/${encodeURIComponent(input.credentialID)}`,
+                query: { location: input["location"] },
+                successStatus: 204,
+                declaredStatuses: [401, 400],
+                empty: true,
+            }, requestOptions),
+        },
+        project: {
+            current: (input, requestOptions) => request({
+                method: "GET",
+                path: `/api/project/current`,
+                query: { location: input?.["location"] },
+                successStatus: 200,
+                declaredStatuses: [401, 400],
+                empty: false,
+            }, requestOptions),
+            directories: (input, requestOptions) => request({
+                method: "GET",
+                path: `/api/project/${encodeURIComponent(input.projectID)}/directories`,
+                query: { location: input["location"] },
+                successStatus: 200,
+                declaredStatuses: [401, 400],
+                empty: false,
+            }, requestOptions),
+        },
+        form: {
+            listRequests: (input, requestOptions) => request({
+                method: "GET",
+                path: `/api/form/request`,
+                query: { location: input?.["location"] },
+                successStatus: 200,
+                declaredStatuses: [401, 400],
+                empty: false,
+            }, requestOptions),
+            list: (input, requestOptions) => request({
+                method: "GET",
+                path: `/api/session/${encodeURIComponent(input.sessionID)}/form`,
+                successStatus: 200,
+                declaredStatuses: [404, 400, 401],
+                empty: false,
+            }, requestOptions).then((value) => value.data),
+            create: (input, requestOptions) => request({
+                method: "POST",
+                path: `/api/session/${encodeURIComponent(input.sessionID)}/form`,
+                body: {
+                    id: input["id"],
+                    title: input["title"],
+                    metadata: input["metadata"],
+                    mode: input["mode"],
+                    fields: input["fields"],
+                    url: input["url"],
+                },
+                successStatus: 200,
+                declaredStatuses: [404, 409, 400, 401],
+                empty: false,
+            }, requestOptions).then((value) => value.data),
+            get: (input, requestOptions) => request({
+                method: "GET",
+                path: `/api/session/${encodeURIComponent(input.sessionID)}/form/${encodeURIComponent(input.formID)}`,
+                successStatus: 200,
+                declaredStatuses: [404, 400, 401],
+                empty: false,
+            }, requestOptions).then((value) => value.data),
+            state: (input, requestOptions) => request({
+                method: "GET",
+                path: `/api/session/${encodeURIComponent(input.sessionID)}/form/${encodeURIComponent(input.formID)}/state`,
+                successStatus: 200,
+                declaredStatuses: [404, 400, 401],
+                empty: false,
+            }, requestOptions).then((value) => value.data),
+            reply: (input, requestOptions) => request({
+                method: "POST",
+                path: `/api/session/${encodeURIComponent(input.sessionID)}/form/${encodeURIComponent(input.formID)}/reply`,
+                body: { answer: input["answer"] },
+                successStatus: 204,
+                declaredStatuses: [404, 409, 400, 401],
+                empty: true,
+            }, requestOptions),
+            cancel: (input, requestOptions) => request({
+                method: "POST",
+                path: `/api/session/${encodeURIComponent(input.sessionID)}/form/${encodeURIComponent(input.formID)}/cancel`,
+                successStatus: 204,
+                declaredStatuses: [404, 409, 400, 401],
+                empty: true,
+            }, requestOptions),
+        },
+        permission: {
+            listRequests: (input, requestOptions) => request({
+                method: "GET",
+                path: `/api/permission/request`,
+                query: { location: input?.["location"] },
+                successStatus: 200,
+                declaredStatuses: [401, 400],
+                empty: false,
+            }, requestOptions),
+            listSaved: (input, requestOptions) => request({
+                method: "GET",
+                path: `/api/permission/saved`,
+                query: { projectID: input?.["projectID"] },
+                successStatus: 200,
+                declaredStatuses: [401, 400],
+                empty: false,
+            }, requestOptions).then((value) => value.data),
+            removeSaved: (input, requestOptions) => request({
+                method: "DELETE",
+                path: `/api/permission/saved/${encodeURIComponent(input.id)}`,
+                successStatus: 204,
+                declaredStatuses: [401, 400],
+                empty: true,
+            }, requestOptions),
+            create: (input, requestOptions) => request({
+                method: "POST",
+                path: `/api/session/${encodeURIComponent(input.sessionID)}/permission`,
+                body: {
+                    id: input["id"],
+                    action: input["action"],
+                    resources: input["resources"],
+                    save: input["save"],
+                    metadata: input["metadata"],
+                    source: input["source"],
+                    agent: input["agent"],
+                },
+                successStatus: 200,
+                declaredStatuses: [404, 400, 401],
+                empty: false,
+            }, requestOptions).then((value) => value.data),
+            list: (input, requestOptions) => request({
+                method: "GET",
+                path: `/api/session/${encodeURIComponent(input.sessionID)}/permission`,
+                successStatus: 200,
+                declaredStatuses: [404, 400, 401],
+                empty: false,
+            }, requestOptions).then((value) => value.data),
+            get: (input, requestOptions) => request({
+                method: "GET",
+                path: `/api/session/${encodeURIComponent(input.sessionID)}/permission/${encodeURIComponent(input.requestID)}`,
+                successStatus: 200,
+                declaredStatuses: [404, 400, 401],
+                empty: false,
+            }, requestOptions).then((value) => value.data),
+            reply: (input, requestOptions) => request({
+                method: "POST",
+                path: `/api/session/${encodeURIComponent(input.sessionID)}/permission/${encodeURIComponent(input.requestID)}/reply`,
+                body: { reply: input["reply"], message: input["message"] },
+                successStatus: 204,
+                declaredStatuses: [404, 400, 401],
+                empty: true,
+            }, requestOptions),
+        },
+        file: {
+            read: (input, requestOptions) => request({
+                method: "GET",
+                path: `/api/fs/read/${encodePath(input.path)}`,
+                query: { location: input["location"] },
+                successStatus: 200,
+                declaredStatuses: [401, 400],
+                empty: false,
+                binary: true,
+            }, requestOptions),
+            list: (input, requestOptions) => request({
+                method: "GET",
+                path: `/api/fs/list`,
+                query: { location: input?.["location"], path: input?.["path"] },
+                successStatus: 200,
+                declaredStatuses: [401, 400],
+                empty: false,
+            }, requestOptions),
+            find: (input, requestOptions) => request({
+                method: "GET",
+                path: `/api/fs/find`,
+                query: { location: input["location"], query: input["query"], type: input["type"], limit: input["limit"] },
+                successStatus: 200,
+                declaredStatuses: [401, 400],
+                empty: false,
+            }, requestOptions),
+        },
+        command: {
+            list: (input, requestOptions) => request({
+                method: "GET",
+                path: `/api/command`,
+                query: { location: input?.["location"] },
+                successStatus: 200,
+                declaredStatuses: [401, 400],
+                empty: false,
+            }, requestOptions),
+        },
+        skill: {
+            list: (input, requestOptions) => request({
+                method: "GET",
+                path: `/api/skill`,
+                query: { location: input?.["location"] },
+                successStatus: 200,
+                declaredStatuses: [401, 400],
+                empty: false,
+            }, requestOptions),
+        },
+        event: {
+            subscribe: (requestOptions) => sse({ method: "GET", path: `/api/event`, successStatus: 200, declaredStatuses: [401, 400], empty: false }, requestOptions),
+            changes: (requestOptions) => sse({ method: "GET", path: `/api/event/changes`, successStatus: 200, declaredStatuses: [401, 400], empty: false }, requestOptions),
+        },
+        pty: {
+            list: (input, requestOptions) => request({
+                method: "GET",
+                path: `/api/pty`,
+                query: { location: input?.["location"] },
+                successStatus: 200,
+                declaredStatuses: [401, 400],
+                empty: false,
+            }, requestOptions),
+            create: (input, requestOptions) => request({
+                method: "POST",
+                path: `/api/pty`,
+                query: { location: input?.["location"] },
+                body: {
+                    command: input?.["command"],
+                    args: input?.["args"],
+                    cwd: input?.["cwd"],
+                    title: input?.["title"],
+                    env: input?.["env"],
+                },
+                successStatus: 200,
+                declaredStatuses: [401, 400],
+                empty: false,
+            }, requestOptions),
+            get: (input, requestOptions) => request({
+                method: "GET",
+                path: `/api/pty/${encodeURIComponent(input.ptyID)}`,
+                query: { location: input["location"] },
+                successStatus: 200,
+                declaredStatuses: [404, 401, 400],
+                empty: false,
+            }, requestOptions),
+            update: (input, requestOptions) => request({
+                method: "PUT",
+                path: `/api/pty/${encodeURIComponent(input.ptyID)}`,
+                query: { location: input["location"] },
+                body: { title: input["title"], size: input["size"] },
+                successStatus: 200,
+                declaredStatuses: [404, 401, 400],
+                empty: false,
+            }, requestOptions),
+            remove: (input, requestOptions) => request({
+                method: "DELETE",
+                path: `/api/pty/${encodeURIComponent(input.ptyID)}`,
+                query: { location: input["location"] },
+                successStatus: 204,
+                declaredStatuses: [404, 401, 400],
+                empty: true,
+            }, requestOptions),
+        },
+        shell: {
+            list: (input, requestOptions) => request({
+                method: "GET",
+                path: `/api/shell`,
+                query: { location: input?.["location"] },
+                successStatus: 200,
+                declaredStatuses: [401, 400],
+                empty: false,
+            }, requestOptions),
+            create: (input, requestOptions) => request({
+                method: "POST",
+                path: `/api/shell`,
+                query: { location: input["location"] },
+                body: {
+                    command: input["command"],
+                    cwd: input["cwd"],
+                    timeout: input["timeout"],
+                    metadata: input["metadata"],
+                },
+                successStatus: 200,
+                declaredStatuses: [401, 400],
+                empty: false,
+            }, requestOptions),
+            get: (input, requestOptions) => request({
+                method: "GET",
+                path: `/api/shell/${encodeURIComponent(input.id)}`,
+                query: { location: input["location"] },
+                successStatus: 200,
+                declaredStatuses: [404, 401, 400],
+                empty: false,
+            }, requestOptions),
+            output: (input, requestOptions) => request({
+                method: "GET",
+                path: `/api/shell/${encodeURIComponent(input.id)}/output`,
+                query: { location: input["location"], cursor: input["cursor"], limit: input["limit"] },
+                successStatus: 200,
+                declaredStatuses: [404, 401, 400],
+                empty: false,
+            }, requestOptions),
+            remove: (input, requestOptions) => request({
+                method: "DELETE",
+                path: `/api/shell/${encodeURIComponent(input.id)}`,
+                query: { location: input["location"] },
+                successStatus: 204,
+                declaredStatuses: [404, 401, 400],
+                empty: true,
+            }, requestOptions),
+        },
+        question: {
+            listRequests: (input, requestOptions) => request({
+                method: "GET",
+                path: `/api/question/request`,
+                query: { location: input?.["location"] },
+                successStatus: 200,
+                declaredStatuses: [401, 400],
+                empty: false,
+            }, requestOptions),
+            list: (input, requestOptions) => request({
+                method: "GET",
+                path: `/api/session/${encodeURIComponent(input.sessionID)}/question`,
+                successStatus: 200,
+                declaredStatuses: [404, 400, 401],
+                empty: false,
+            }, requestOptions).then((value) => value.data),
+            reply: (input, requestOptions) => request({
+                method: "POST",
+                path: `/api/session/${encodeURIComponent(input.sessionID)}/question/${encodeURIComponent(input.requestID)}/reply`,
+                body: { answers: input["answers"] },
+                successStatus: 204,
+                declaredStatuses: [404, 400, 401],
+                empty: true,
+            }, requestOptions),
+            reject: (input, requestOptions) => request({
+                method: "POST",
+                path: `/api/session/${encodeURIComponent(input.sessionID)}/question/${encodeURIComponent(input.requestID)}/reject`,
+                successStatus: 204,
+                declaredStatuses: [404, 400, 401],
+                empty: true,
+            }, requestOptions),
+        },
+        reference: {
+            list: (input, requestOptions) => request({
+                method: "GET",
+                path: `/api/reference`,
+                query: { location: input?.["location"] },
+                successStatus: 200,
+                declaredStatuses: [401, 400],
+                empty: false,
+            }, requestOptions),
+        },
+        projectCopy: {
+            create: (input, requestOptions) => request({
+                method: "POST",
+                path: `/experimental/project/${encodeURIComponent(input.projectID)}/copy`,
+                query: { location: input["location"] },
+                body: { strategy: input["strategy"], directory: input["directory"], name: input["name"] },
+                successStatus: 200,
+                declaredStatuses: [400, 401],
+                empty: false,
+            }, requestOptions),
+            remove: (input, requestOptions) => request({
+                method: "DELETE",
+                path: `/experimental/project/${encodeURIComponent(input.projectID)}/copy`,
+                query: { location: input["location"] },
+                body: { directory: input["directory"], force: input["force"] },
+                successStatus: 204,
+                declaredStatuses: [400, 401],
+                empty: true,
+            }, requestOptions),
+            refresh: (input, requestOptions) => request({
+                method: "POST",
+                path: `/experimental/project/${encodeURIComponent(input.projectID)}/copy/refresh`,
+                query: { location: input["location"] },
+                successStatus: 204,
+                declaredStatuses: [400, 401],
+                empty: true,
+            }, requestOptions),
+        },
+        vcs: {
+            status: (input, requestOptions) => request({
+                method: "GET",
+                path: `/api/vcs/status`,
+                query: { location: input?.["location"] },
+                successStatus: 200,
+                declaredStatuses: [401, 400],
+                empty: false,
+            }, requestOptions),
+            diff: (input, requestOptions) => request({
+                method: "GET",
+                path: `/api/vcs/diff`,
+                query: { location: input["location"], mode: input["mode"], context: input["context"] },
+                successStatus: 200,
+                declaredStatuses: [401, 400],
+                empty: false,
+            }, requestOptions),
+        },
+        debug: {
+            location: (requestOptions) => request({
+                method: "GET",
+                path: `/api/debug/location`,
+                successStatus: 200,
+                declaredStatuses: [401, 400],
+                empty: false,
+            }, requestOptions),
+        },
+    };
+}
+function encodePath(value) {
+    return value.split("/").map(encodeURIComponent).join("/");
+}
+function appendQuery(params, key, value) {
+    if (value === undefined)
+        return;
+    if (value === null) {
+        params.append(key, "null");
+        return;
+    }
+    if (Array.isArray(value)) {
+        for (const item of value)
+            appendQuery(params, key, item);
+        return;
+    }
+    if (typeof value === "object") {
+        for (const [child, item] of Object.entries(value))
+            appendQuery(params, `${key}[${child}]`, item);
+        return;
+    }
+    params.append(key, String(value));
+}
+async function json(response) {
+    if (!isContentType(response, "application/json") && !response.headers.get("content-type")?.includes("+json")) {
+        try {
+            await response.body?.cancel();
+        }
+        catch { }
+        throw new ClientError("UnsupportedContentType");
+    }
+    let text;
+    try {
+        text = await response.text();
+    }
+    catch (cause) {
+        throw new ClientError("Transport", { cause });
+    }
+    if (text === "")
+        throw new ClientError("MalformedResponse");
+    try {
+        return JSON.parse(text);
+    }
+    catch (cause) {
+        throw new ClientError("MalformedResponse", { cause });
+    }
+}
+function isContentType(response, expected) {
+    return response.headers.get("content-type")?.split(";", 1)[0]?.trim().toLowerCase() === expected;
+}