v0-api 0.0.3 → 0.1.3

package/dist/effect.cjs

@@ -0,0 +1,1334 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var effect = require('@sferadev/openapi-utils/effect');
+
+function notEmpty(value) {
+    return value !== null && value !== undefined;
+}
+function compactObject(obj) {
+    return Object.fromEntries(Object.entries(obj).filter(([, value])=>notEmpty(value)));
+}
+
+async function client({ url, method, body, headers, queryParams, signal, token = null, baseUrl = "", fetchImpl = fetch }) {
+    try {
+        const requestHeaders = compactObject({
+            "Content-Type": "application/json",
+            Authorization: token ? `Bearer ${token}` : undefined,
+            ...headers
+        });
+        /**
+		 * As the fetch API is being used, when multipart/form-data is specified
+		 * the Content-Type header must be deleted so that the browser can set
+		 * the correct boundary.
+		 * https://developer.mozilla.org/en-US/docs/Web/API/FormData/Using_FormData_Objects#sending_files_using_a_formdata_object
+		 */ if (requestHeaders["Content-Type"]?.toLowerCase().includes("multipart/form-data")) {
+            delete requestHeaders["Content-Type"];
+        }
+        const payload = body instanceof FormData ? body : requestHeaders["Content-Type"] === "application/json" ? JSON.stringify(body) : body;
+        const fullUrl = `${baseUrl}${resolveUrl(url, queryParams)}`;
+        const response = await fetchImpl(fullUrl, {
+            signal,
+            method: method.toUpperCase(),
+            body: payload,
+            headers: requestHeaders
+        });
+        if (!response.ok) {
+            let error;
+            try {
+                error = await response.json();
+            } catch (e) {
+                error = {
+                    status: "unknown",
+                    payload: e instanceof Error ? `Unexpected error (${e.message})` : "Unexpected error"
+                };
+            }
+            throw error;
+        }
+        if (response.headers?.get("content-type")?.includes("json")) {
+            return await response.json();
+        } else {
+            // if it is not a json response, assume it is a blob and cast it to TData
+            return await response.text();
+        }
+    } catch (e) {
+        const errorObject = {
+            name: "unknown",
+            message: e?.message ? `${e?.message}` : "Network error"
+        };
+        throw errorObject;
+    }
+}
+const resolveUrl = (url, queryParams = {})=>{
+    let query = new URLSearchParams(queryParams).toString();
+    if (query) query = `?${query}`;
+    return url + query;
+};
+
+/**
+ * @summary Create Chat
+ * @description Creates a new chat using a user message, optional system context, and model configuration. Useful for prompting the model within the scope of a specific project.
+ * @link /chats
+ */ async function chatsCreate({ config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    const data = await request({
+        method: "POST",
+        url: `/chats`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Find Chats
+ * @description Retrieves a list of existing chats, with support for pagination and filtering by favorite status, Vercel project, or Git branch. Helps manage and navigate chat history.
+ * @link /chats
+ */ async function chatsFind({ queryParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    const data = await request({
+        method: "GET",
+        url: `/chats`,
+        queryParams,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Initialize Chat
+ * @description Initializes a new chat from source content such as files, repositories, registries, or zip archives. Enables context-rich conversations based on code or assets.
+ * @link /chats/init
+ */ async function chatsInit({ config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    const data = await request({
+        method: "POST",
+        url: `/chats/init`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Delete Chat
+ * @description Deletes a specific chat based on the provided chatId. The chat and its contents are moved to trash and stop being retrievable immediately, then retained for 30 days before being permanently removed.
+ * @link /chats/{chatId}
+ */ async function chatsDelete({ pathParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.chatId) {
+        throw new Error(`Missing required path parameter: chatId`);
+    }
+    const data = await request({
+        method: "DELETE",
+        url: `/chats/${pathParams.chatId}`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Get Chat
+ * @description Retrieves the full details of a specific chat using its `chatId`. Includes messages, metadata, and associated configuration.
+ * @link /chats/{chatId}
+ */ async function chatsGetById({ pathParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.chatId) {
+        throw new Error(`Missing required path parameter: chatId`);
+    }
+    const data = await request({
+        method: "GET",
+        url: `/chats/${pathParams.chatId}`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Update Chat
+ * @description Updates the metadata of an existing chat using its `chatId`. Supports changes to the chat name and privacy setting.
+ * @link /chats/{chatId}
+ */ async function chatsUpdate({ pathParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.chatId) {
+        throw new Error(`Missing required path parameter: chatId`);
+    }
+    const data = await request({
+        method: "PATCH",
+        url: `/chats/${pathParams.chatId}`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Favorite Chat
+ * @description Marks or unmarks a chat as a favorite using its `chatId`. This helps with organizing and quickly accessing important chats.
+ * @link /chats/{chatId}/favorite
+ */ async function chatsFavorite({ pathParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.chatId) {
+        throw new Error(`Missing required path parameter: chatId`);
+    }
+    const data = await request({
+        method: "PUT",
+        url: `/chats/${pathParams.chatId}/favorite`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Fork Chat
+ * @description Creates a new chat fork (duplicate) from a specific version within an existing chat. Useful for branching off alternate directions without modifying the original conversation.
+ * @link /chats/{chatId}/fork
+ */ async function chatsFork({ pathParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.chatId) {
+        throw new Error(`Missing required path parameter: chatId`);
+    }
+    const data = await request({
+        method: "POST",
+        url: `/chats/${pathParams.chatId}/fork`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Get Project by Chat ID
+ * @description Retrieves the v0 project associated with a given chat. Useful for determining the context or scope of a chat session.
+ * @link /chats/{chatId}/project
+ */ async function projectsGetByChatId({ pathParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.chatId) {
+        throw new Error(`Missing required path parameter: chatId`);
+    }
+    const data = await request({
+        method: "GET",
+        url: `/chats/${pathParams.chatId}/project`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Find Chat Messages
+ * @description Retrieves a list of all messages for a specific chat, ordered by creation date (newest first). Supports cursor-based pagination and includes message content, role, and type information.
+ * @link /chats/{chatId}/messages
+ */ async function chatsFindMessages({ pathParams, queryParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.chatId) {
+        throw new Error(`Missing required path parameter: chatId`);
+    }
+    const data = await request({
+        method: "GET",
+        url: `/chats/${pathParams.chatId}/messages`,
+        queryParams,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Send Message
+ * @description Creates a new message in an existing chat. Triggers a model response using the provided prompt, with optional attachments and configuration settings.
+ * @link /chats/{chatId}/messages
+ */ async function chatsSendMessage({ pathParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.chatId) {
+        throw new Error(`Missing required path parameter: chatId`);
+    }
+    const data = await request({
+        method: "POST",
+        url: `/chats/${pathParams.chatId}/messages`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Get Chat Message
+ * @description Retrieves detailed information about a specific message within a chat, including content, files, model configuration, and demo URLs.
+ * @link /chats/{chatId}/messages/{messageId}
+ */ async function chatsGetMessage({ pathParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.chatId) {
+        throw new Error(`Missing required path parameter: chatId`);
+    }
+    if (!pathParams.messageId) {
+        throw new Error(`Missing required path parameter: messageId`);
+    }
+    const data = await request({
+        method: "GET",
+        url: `/chats/${pathParams.chatId}/messages/${pathParams.messageId}`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Find Chat Versions
+ * @description Retrieves a list of all versions (iterations) for a specific chat, ordered by creation date (newest first). Supports cursor-based pagination and includes version status and demo URLs.
+ * @link /chats/{chatId}/versions
+ */ async function chatsFindVersions({ pathParams, queryParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.chatId) {
+        throw new Error(`Missing required path parameter: chatId`);
+    }
+    const data = await request({
+        method: "GET",
+        url: `/chats/${pathParams.chatId}/versions`,
+        queryParams,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Get Chat Version
+ * @description Retrieves detailed information about a specific version of a chat, including all files with their content and lock status.
+ * @link /chats/{chatId}/versions/{versionId}
+ */ async function chatsGetVersion({ pathParams, queryParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.chatId) {
+        throw new Error(`Missing required path parameter: chatId`);
+    }
+    if (!pathParams.versionId) {
+        throw new Error(`Missing required path parameter: versionId`);
+    }
+    const data = await request({
+        method: "GET",
+        url: `/chats/${pathParams.chatId}/versions/${pathParams.versionId}`,
+        queryParams,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Update Chat Version Files
+ * @description Updates the source files of a specific chat version (block) manually. This allows editing generated files directly through the API.
+ * @link /chats/{chatId}/versions/{versionId}
+ */ async function chatsUpdateVersion({ pathParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.chatId) {
+        throw new Error(`Missing required path parameter: chatId`);
+    }
+    if (!pathParams.versionId) {
+        throw new Error(`Missing required path parameter: versionId`);
+    }
+    const data = await request({
+        method: "PATCH",
+        url: `/chats/${pathParams.chatId}/versions/${pathParams.versionId}`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Download version files
+ * @description Download all files for a specific chat version as a zip or tarball archive. Use includeDefaultFiles=true to include all deployment files (package.json, configuration files, etc.) or false/omitted to return only the generated source files.
+ * @link /chats/{chatId}/versions/{versionId}/download
+ */ async function chatsDownloadVersion({ pathParams, queryParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.chatId) {
+        throw new Error(`Missing required path parameter: chatId`);
+    }
+    if (!pathParams.versionId) {
+        throw new Error(`Missing required path parameter: versionId`);
+    }
+    const data = await request({
+        method: "GET",
+        url: `/chats/${pathParams.chatId}/versions/${pathParams.versionId}/download`,
+        queryParams,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Delete Chat Version Files
+ * @description Deletes source files from a specific chat version (block). Files are removed from the version and a new source version is created.
+ * @link /chats/{chatId}/versions/{versionId}/files/delete
+ */ async function chatsDeleteVersionFiles({ pathParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.chatId) {
+        throw new Error(`Missing required path parameter: chatId`);
+    }
+    if (!pathParams.versionId) {
+        throw new Error(`Missing required path parameter: versionId`);
+    }
+    const data = await request({
+        method: "POST",
+        url: `/chats/${pathParams.chatId}/versions/${pathParams.versionId}/files/delete`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Resume Message
+ * @description Reconnects to an active assistant message stream and returns it as Server-Sent Events. This does not restart or continue a stopped generation.
+ * @link /chats/{chatId}/messages/{messageId}/resume
+ */ async function chatsResume({ pathParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.chatId) {
+        throw new Error(`Missing required path parameter: chatId`);
+    }
+    if (!pathParams.messageId) {
+        throw new Error(`Missing required path parameter: messageId`);
+    }
+    const data = await request({
+        method: "POST",
+        url: `/chats/${pathParams.chatId}/messages/${pathParams.messageId}/resume`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Stop Message
+ * @description Stops an in-flight message generation in a chat. Useful for cancelling a streaming response that is still being generated.
+ * @link /chats/{chatId}/messages/{messageId}/stop
+ */ async function chatsStop({ pathParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.chatId) {
+        throw new Error(`Missing required path parameter: chatId`);
+    }
+    if (!pathParams.messageId) {
+        throw new Error(`Missing required path parameter: messageId`);
+    }
+    const data = await request({
+        method: "POST",
+        url: `/chats/${pathParams.chatId}/messages/${pathParams.messageId}/stop`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Resolve Task
+ * @description Resolves a pending task in a chat, continuing the conversation. The latest message in the active chat fork must be an assistant message currently blocked on a matching task (integration setup, plan approval, question answers, or permission grants).
+ * @link /chats/{chatId}/tasks/resolve
+ */ async function chatsResolveTask({ pathParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.chatId) {
+        throw new Error(`Missing required path parameter: chatId`);
+    }
+    const data = await request({
+        method: "POST",
+        url: `/chats/${pathParams.chatId}/tasks/resolve`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Find Deployments
+ * @description Find deployments by project and chat IDs. This will return a list of deployments for the given project and chat IDs.
+ * @link /deployments
+ */ async function deploymentsFind({ queryParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    const data = await request({
+        method: "GET",
+        url: `/deployments`,
+        queryParams,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Create Deployment
+ * @description Create a new deployment for a specific chat and version. This will trigger a deployment to Vercel.
+ * @link /deployments
+ */ async function deploymentsCreate({ config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    const data = await request({
+        method: "POST",
+        url: `/deployments`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Get Deployment
+ * @description Get a deployment by ID. This will return the details of the deployment, including the inspector URL, chat ID, project ID, version ID, API URL, and web URL.
+ * @link /deployments/{deploymentId}
+ */ async function deploymentsGetById({ pathParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.deploymentId) {
+        throw new Error(`Missing required path parameter: deploymentId`);
+    }
+    const data = await request({
+        method: "GET",
+        url: `/deployments/${pathParams.deploymentId}`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Delete Deployment
+ * @description Delete a deployment by ID. This will delete the deployment from Vercel.
+ * @link /deployments/{deploymentId}
+ */ async function deploymentsDelete({ pathParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.deploymentId) {
+        throw new Error(`Missing required path parameter: deploymentId`);
+    }
+    const data = await request({
+        method: "DELETE",
+        url: `/deployments/${pathParams.deploymentId}`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Find Deployment Logs
+ * @description Retrieves logs for a specific deployment. Supports filtering by timestamp to fetch only recent logs.
+ * @link /deployments/{deploymentId}/logs
+ */ async function deploymentsFindLogs({ pathParams, queryParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.deploymentId) {
+        throw new Error(`Missing required path parameter: deploymentId`);
+    }
+    const data = await request({
+        method: "GET",
+        url: `/deployments/${pathParams.deploymentId}/logs`,
+        queryParams,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Find Deployment Errors
+ * @description Retrieves a list of errors that occurred during a specific deployment. Useful for diagnosing and debugging deployment issues.
+ * @link /deployments/{deploymentId}/errors
+ */ async function deploymentsFindErrors({ pathParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.deploymentId) {
+        throw new Error(`Missing required path parameter: deploymentId`);
+    }
+    const data = await request({
+        method: "GET",
+        url: `/deployments/${pathParams.deploymentId}/errors`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Find Hooks
+ * @description Retrieves a list of existing hooks in your workspace. Useful for managing active webhooks tied to chat events or deployments.
+ * @link /hooks
+ */ async function hooksFind({ config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    const data = await request({
+        method: "GET",
+        url: `/hooks`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Create Hook
+ * @description Creates a new webhook that listens for specific events. Supports optional association with a chat.
+ * @link /hooks
+ */ async function hooksCreate({ config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    const data = await request({
+        method: "POST",
+        url: `/hooks`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Get Hook
+ * @description Retrieves the details of a specific webhook using its ID.
+ * @link /hooks/{hookId}
+ */ async function hooksGetById({ pathParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.hookId) {
+        throw new Error(`Missing required path parameter: hookId`);
+    }
+    const data = await request({
+        method: "GET",
+        url: `/hooks/${pathParams.hookId}`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Update Hook
+ * @description Updates the configuration of an existing webhook, including its name, event subscriptions, or target URL.
+ * @link /hooks/{hookId}
+ */ async function hooksUpdate({ pathParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.hookId) {
+        throw new Error(`Missing required path parameter: hookId`);
+    }
+    const data = await request({
+        method: "PATCH",
+        url: `/hooks/${pathParams.hookId}`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Delete Hook
+ * @description Deletes a webhook based on its ID. This action is irreversible.
+ * @link /hooks/{hookId}
+ */ async function hooksDelete({ pathParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.hookId) {
+        throw new Error(`Missing required path parameter: hookId`);
+    }
+    const data = await request({
+        method: "DELETE",
+        url: `/hooks/${pathParams.hookId}`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Find Vercel Projects
+ * @description Retrieves a list of Vercel projects linked to your integration. Useful for associating chats, deployments, or hooks with specific Vercel projects.
+ * @link /integrations/vercel/projects
+ */ async function integrationsVercelProjectsFind({ config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    const data = await request({
+        method: "GET",
+        url: `/integrations/vercel/projects`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Create Vercel Project
+ * @description Links a Vercel project to an existing v0 project. Enables Vercel-related features and deployment integration within the v0 workspace.
+ * @link /integrations/vercel/projects
+ */ async function integrationsVercelProjectsCreate({ config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    const data = await request({
+        method: "POST",
+        url: `/integrations/vercel/projects`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Find Projects
+ * @description Returns a list of all v0 projects in your workspace. Useful for browsing or managing projects across different chats or use cases.
+ * @link /projects
+ */ async function projectsFind({ config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    const data = await request({
+        method: "GET",
+        url: `/projects`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Create Project
+ * @description Creates a new v0 project with an optional description, icon, environment variables, and instructions. Projects help organize chats and manage context.
+ * @link /projects
+ */ async function projectsCreate({ config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    const data = await request({
+        method: "POST",
+        url: `/projects`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Get Project by ID
+ * @description Retrieves the details of a specific v0 project by its ID.
+ * @link /projects/{projectId}
+ */ async function projectsGetById({ pathParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.projectId) {
+        throw new Error(`Missing required path parameter: projectId`);
+    }
+    const data = await request({
+        method: "GET",
+        url: `/projects/${pathParams.projectId}`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Update Project
+ * @description Updates the metadata of an existing project using its `projectId`. Supports changes to the project name and privacy setting.
+ * @link /projects/{projectId}
+ */ async function projectsUpdate({ pathParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.projectId) {
+        throw new Error(`Missing required path parameter: projectId`);
+    }
+    const data = await request({
+        method: "PATCH",
+        url: `/projects/${pathParams.projectId}`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Delete Project
+ * @description Deletes a specific project based on the provided projectId. This operation marks the project as deleted and is irreversible.
+ * @link /projects/{projectId}
+ */ async function projectsDelete({ pathParams, queryParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.projectId) {
+        throw new Error(`Missing required path parameter: projectId`);
+    }
+    const data = await request({
+        method: "DELETE",
+        url: `/projects/${pathParams.projectId}`,
+        queryParams,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Assign Project to Chat
+ * @description Links an existing v0 project to a specific chat. Helps group conversations under a shared project context.
+ * @link /projects/{projectId}/assign
+ */ async function projectsAssign({ pathParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.projectId) {
+        throw new Error(`Missing required path parameter: projectId`);
+    }
+    const data = await request({
+        method: "POST",
+        url: `/projects/${pathParams.projectId}/assign`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Find Environment Variables
+ * @description Retrieves all environment variables for a given project.
+ * @link /projects/{projectId}/env-vars
+ */ async function projectsFindEnvVars({ pathParams, queryParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.projectId) {
+        throw new Error(`Missing required path parameter: projectId`);
+    }
+    const data = await request({
+        method: "GET",
+        url: `/projects/${pathParams.projectId}/env-vars`,
+        queryParams,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Create Environment Variables
+ * @description Creates new environment variables for a given project. This endpoint will fail if any of the specified environment variable keys already exist, unless upsert is set to true.
+ * @link /projects/{projectId}/env-vars
+ */ async function projectsCreateEnvVars({ pathParams, queryParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.projectId) {
+        throw new Error(`Missing required path parameter: projectId`);
+    }
+    const data = await request({
+        method: "POST",
+        url: `/projects/${pathParams.projectId}/env-vars`,
+        queryParams,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Update Environment Variables
+ * @description Updates multiple environment variables for a given project. Only the value of each environment variable can be updated.
+ * @link /projects/{projectId}/env-vars
+ */ async function projectsUpdateEnvVars({ pathParams, queryParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.projectId) {
+        throw new Error(`Missing required path parameter: projectId`);
+    }
+    const data = await request({
+        method: "PATCH",
+        url: `/projects/${pathParams.projectId}/env-vars`,
+        queryParams,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Delete Environment Variables
+ * @description Deletes multiple environment variables for a given project by their IDs.
+ * @link /projects/{projectId}/env-vars/delete
+ */ async function projectsDeleteEnvVars({ pathParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.projectId) {
+        throw new Error(`Missing required path parameter: projectId`);
+    }
+    const data = await request({
+        method: "POST",
+        url: `/projects/${pathParams.projectId}/env-vars/delete`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Get Environment Variable
+ * @description Retrieves a specific environment variable for a given project by its ID, including its value.
+ * @link /projects/{projectId}/env-vars/{environmentVariableId}
+ */ async function projectsGetEnvVar({ pathParams, queryParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.projectId) {
+        throw new Error(`Missing required path parameter: projectId`);
+    }
+    if (!pathParams.environmentVariableId) {
+        throw new Error(`Missing required path parameter: environmentVariableId`);
+    }
+    const data = await request({
+        method: "GET",
+        url: `/projects/${pathParams.projectId}/env-vars/${pathParams.environmentVariableId}`,
+        queryParams,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Find Rate Limit
+ * @description Retrieves rate limit information for a given scope. Useful for monitoring usage limits and avoiding throttling.
+ * @link /rate-limits
+ */ async function rateLimitsFind({ queryParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    const data = await request({
+        method: "GET",
+        url: `/rate-limits`,
+        queryParams,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Get User
+ * @description Retrieves information about the authenticated user, including their ID, name, email, and account metadata.
+ * @link /user
+ */ async function userGet({ config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    const data = await request({
+        method: "GET",
+        url: `/user`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Get Billing
+ * @description Fetches billing usage and quota information for the authenticated user. Can be scoped to a specific context (e.g. project or namespace).
+ * @link /user/billing
+ */ async function userGetBilling({ queryParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    const data = await request({
+        method: "GET",
+        url: `/user/billing`,
+        queryParams,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Get Plan
+ * @description Returns the current subscription plan for the authenticated user, including tier details and feature limits.
+ * @link /user/plan
+ */ async function userGetPlan({ config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    const data = await request({
+        method: "GET",
+        url: `/user/plan`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Get User Scopes
+ * @description Retrieves all accessible scopes for the authenticated user, such as personal workspaces or shared teams.
+ * @link /user/scopes
+ */ async function userGetScopes({ config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    const data = await request({
+        method: "GET",
+        url: `/user/scopes`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Restore Block
+ * @description Restores a block to a specific version.
+ * @link /chats/{chatId}/versions/{versionId}/restore
+ */ async function chatsRestore({ pathParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.chatId) {
+        throw new Error(`Missing required path parameter: chatId`);
+    }
+    if (!pathParams.versionId) {
+        throw new Error(`Missing required path parameter: versionId`);
+    }
+    const data = await request({
+        method: "POST",
+        url: `/chats/${pathParams.chatId}/versions/${pathParams.versionId}/restore`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Get Usage Report
+ * @description Retrieves detailed usage events for the authenticated user or team, including costs, event types, models used, and metadata. Shows the same data as displayed in the usage dashboard. Can be filtered by chatId to show usage for a specific chat, or by userId to show usage for a specific user.
+ * @link /reports/usage
+ */ async function reportsGetUsage({ queryParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    const data = await request({
+        method: "GET",
+        url: `/reports/usage`,
+        queryParams,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Get AI Usage Report
+ * @description Retrieves v0 AI usage events for the authenticated user or active team scope.
+ * @link /reports/usage/ai
+ */ async function reportsGetAIUsage({ queryParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    const data = await request({
+        method: "GET",
+        url: `/reports/usage/ai`,
+        queryParams,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Get User Activity Report
+ * @description Retrieves aggregated user activity data for team members, including chat counts, message counts, and activity timestamps. Only available for Enterprise teams with OWNER or BILLING role. Shows the same data as displayed in the Usage settings for Enterprise teams.
+ * @link /reports/user-activity
+ */ async function reportsGetUserActivity({ queryParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    const data = await request({
+        method: "GET",
+        url: `/reports/user-activity`,
+        queryParams,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary List MCP Servers
+ * @description Retrieves all MCP servers configured for the authenticated user.
+ * @link /mcp-servers
+ */ async function mcpServersFind({ config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    const data = await request({
+        method: "GET",
+        url: `/mcp-servers`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Create MCP Server
+ * @description Creates a new MCP server configuration for the authenticated user. Supports OAuth, bearer token, custom headers, and unauthenticated servers.
+ * @link /mcp-servers
+ */ async function mcpServersCreate({ config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    const data = await request({
+        method: "POST",
+        url: `/mcp-servers`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Get MCP Server
+ * @description Retrieves the details of a specific MCP server by its ID.
+ * @link /mcp-servers/{mcpServerId}
+ */ async function mcpServersGetById({ pathParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.mcpServerId) {
+        throw new Error(`Missing required path parameter: mcpServerId`);
+    }
+    const data = await request({
+        method: "GET",
+        url: `/mcp-servers/${pathParams.mcpServerId}`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Update MCP Server
+ * @description Updates the configuration of an existing MCP server, including its name, URL, description, enabled status, and authentication settings.
+ * @link /mcp-servers/{mcpServerId}
+ */ async function mcpServersUpdate({ pathParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.mcpServerId) {
+        throw new Error(`Missing required path parameter: mcpServerId`);
+    }
+    const data = await request({
+        method: "PATCH",
+        url: `/mcp-servers/${pathParams.mcpServerId}`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Delete MCP Server
+ * @description Deletes an MCP server based on its ID. This action is irreversible and will also remove any associated OAuth tokens.
+ * @link /mcp-servers/{mcpServerId}
+ */ async function mcpServersDelete({ pathParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.mcpServerId) {
+        throw new Error(`Missing required path parameter: mcpServerId`);
+    }
+    const data = await request({
+        method: "DELETE",
+        url: `/mcp-servers/${pathParams.mcpServerId}`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+/**
+ * @summary Create MCP Server OAuth Authorization URL
+ * @description Creates an OAuth authorization URL for an OAuth MCP server. Redirect the user to the returned URL, and the Platform API OAuth callback will store the resulting tokens before redirecting to your returnUrl.
+ * @link /mcp-servers/{mcpServerId}/oauth/authorize
+ */ async function mcpServersCreateOAuthAuthorizationUrl({ pathParams, config } = {}) {
+    const { client: request = client, ...requestConfig } = config ?? {};
+    if (!pathParams.mcpServerId) {
+        throw new Error(`Missing required path parameter: mcpServerId`);
+    }
+    const data = await request({
+        method: "POST",
+        url: `/mcp-servers/${pathParams.mcpServerId}/oauth/authorize`,
+        ...requestConfig,
+        headers: {
+            ...requestConfig.headers
+        }
+    });
+    return data;
+}
+const operationsByPath = {
+    "POST /chats": chatsCreate,
+    "GET /chats": chatsFind,
+    "POST /chats/init": chatsInit,
+    "DELETE /chats/{chatId}": chatsDelete,
+    "GET /chats/{chatId}": chatsGetById,
+    "PATCH /chats/{chatId}": chatsUpdate,
+    "PUT /chats/{chatId}/favorite": chatsFavorite,
+    "POST /chats/{chatId}/fork": chatsFork,
+    "GET /chats/{chatId}/project": projectsGetByChatId,
+    "GET /chats/{chatId}/messages": chatsFindMessages,
+    "POST /chats/{chatId}/messages": chatsSendMessage,
+    "GET /chats/{chatId}/messages/{messageId}": chatsGetMessage,
+    "GET /chats/{chatId}/versions": chatsFindVersions,
+    "GET /chats/{chatId}/versions/{versionId}": chatsGetVersion,
+    "PATCH /chats/{chatId}/versions/{versionId}": chatsUpdateVersion,
+    "GET /chats/{chatId}/versions/{versionId}/download": chatsDownloadVersion,
+    "POST /chats/{chatId}/versions/{versionId}/files/delete": chatsDeleteVersionFiles,
+    "POST /chats/{chatId}/messages/{messageId}/resume": chatsResume,
+    "POST /chats/{chatId}/messages/{messageId}/stop": chatsStop,
+    "POST /chats/{chatId}/tasks/resolve": chatsResolveTask,
+    "GET /deployments": deploymentsFind,
+    "POST /deployments": deploymentsCreate,
+    "GET /deployments/{deploymentId}": deploymentsGetById,
+    "DELETE /deployments/{deploymentId}": deploymentsDelete,
+    "GET /deployments/{deploymentId}/logs": deploymentsFindLogs,
+    "GET /deployments/{deploymentId}/errors": deploymentsFindErrors,
+    "GET /hooks": hooksFind,
+    "POST /hooks": hooksCreate,
+    "GET /hooks/{hookId}": hooksGetById,
+    "PATCH /hooks/{hookId}": hooksUpdate,
+    "DELETE /hooks/{hookId}": hooksDelete,
+    "GET /integrations/vercel/projects": integrationsVercelProjectsFind,
+    "POST /integrations/vercel/projects": integrationsVercelProjectsCreate,
+    "GET /projects": projectsFind,
+    "POST /projects": projectsCreate,
+    "GET /projects/{projectId}": projectsGetById,
+    "PATCH /projects/{projectId}": projectsUpdate,
+    "DELETE /projects/{projectId}": projectsDelete,
+    "POST /projects/{projectId}/assign": projectsAssign,
+    "GET /projects/{projectId}/env-vars": projectsFindEnvVars,
+    "POST /projects/{projectId}/env-vars": projectsCreateEnvVars,
+    "PATCH /projects/{projectId}/env-vars": projectsUpdateEnvVars,
+    "POST /projects/{projectId}/env-vars/delete": projectsDeleteEnvVars,
+    "GET /projects/{projectId}/env-vars/{environmentVariableId}": projectsGetEnvVar,
+    "GET /rate-limits": rateLimitsFind,
+    "GET /user": userGet,
+    "GET /user/billing": userGetBilling,
+    "GET /user/plan": userGetPlan,
+    "GET /user/scopes": userGetScopes,
+    "POST /chats/{chatId}/versions/{versionId}/restore": chatsRestore,
+    "GET /reports/usage": reportsGetUsage,
+    "GET /reports/usage/ai": reportsGetAIUsage,
+    "GET /reports/user-activity": reportsGetUserActivity,
+    "GET /mcp-servers": mcpServersFind,
+    "POST /mcp-servers": mcpServersCreate,
+    "GET /mcp-servers/{mcpServerId}": mcpServersGetById,
+    "PATCH /mcp-servers/{mcpServerId}": mcpServersUpdate,
+    "DELETE /mcp-servers/{mcpServerId}": mcpServersDelete,
+    "POST /mcp-servers/{mcpServerId}/oauth/authorize": mcpServersCreateOAuthAuthorizationUrl
+};
+const operationsByTag = {
+    "chats": {
+        chatsCreate,
+        chatsFind,
+        chatsInit,
+        chatsDelete,
+        chatsGetById,
+        chatsUpdate,
+        chatsFavorite,
+        chatsFork,
+        chatsFindMessages,
+        chatsSendMessage,
+        chatsGetMessage,
+        chatsFindVersions,
+        chatsGetVersion,
+        chatsUpdateVersion,
+        chatsDownloadVersion,
+        chatsDeleteVersionFiles,
+        chatsResume,
+        chatsStop,
+        chatsResolveTask,
+        chatsRestore
+    },
+    "projects": {
+        projectsGetByChatId,
+        projectsFind,
+        projectsCreate,
+        projectsGetById,
+        projectsUpdate,
+        projectsDelete,
+        projectsAssign,
+        projectsFindEnvVars,
+        projectsCreateEnvVars,
+        projectsUpdateEnvVars,
+        projectsDeleteEnvVars,
+        projectsGetEnvVar
+    },
+    "deployments": {
+        deploymentsFind,
+        deploymentsCreate,
+        deploymentsGetById,
+        deploymentsDelete,
+        deploymentsFindLogs,
+        deploymentsFindErrors
+    },
+    "hooks": {
+        hooksFind,
+        hooksCreate,
+        hooksGetById,
+        hooksUpdate,
+        hooksDelete
+    },
+    "integrations": {
+        integrationsVercelProjectsFind,
+        integrationsVercelProjectsCreate
+    },
+    "ratelimits": {
+        rateLimitsFind
+    },
+    "user": {
+        userGet,
+        userGetBilling,
+        userGetPlan,
+        userGetScopes
+    },
+    "reports": {
+        reportsGetUsage,
+        reportsGetAIUsage,
+        reportsGetUserActivity
+    },
+    "mcpservers": {
+        mcpServersFind,
+        mcpServersCreate,
+        mcpServersGetById,
+        mcpServersUpdate,
+        mcpServersDelete,
+        mcpServersCreateOAuthAuthorizationUrl
+    }
+};
+
+const ApiService = effect.createEffectApi(operationsByTag);
+const effectByPath = effect.createEffectByPath(operationsByPath);
+
+Object.defineProperty(exports, "ApiConfig", {
+	enumerable: true,
+	get: function () { return effect.ApiConfig; }
+});
+Object.defineProperty(exports, "ApiError", {
+	enumerable: true,
+	get: function () { return effect.ApiError; }
+});
+Object.defineProperty(exports, "NetworkError", {
+	enumerable: true,
+	get: function () { return effect.NetworkError; }
+});
+Object.defineProperty(exports, "ValidationError", {
+	enumerable: true,
+	get: function () { return effect.ValidationError; }
+});
+Object.defineProperty(exports, "makeApiLayer", {
+	enumerable: true,
+	get: function () { return effect.makeApiLayer; }
+});
+exports.ApiService = ApiService;
+exports.effectByPath = effectByPath;