v0-api 0.0.3 → 0.0.4

package/dist/index.cjs

@@ -0,0 +1,548 @@
+'use strict';
+
+const schemas = require('./shared/v0-api.D3CFh7k4.cjs');
+require('zod');
+
+async function chatsCreate({ config = {} }) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  const data = await request({
+    method: "POST",
+    url: `/chats`,
+    ...requestConfig,
+    headers: { "Content-Type": "applicationJson", ...requestConfig.headers }
+  });
+  return data;
+}
+async function chatsFind({
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  const data = await request({ method: "GET", url: `/chats`, queryParams, ...requestConfig });
+  return data;
+}
+async function chatsInitCreate({
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  const data = await request({
+    method: "POST",
+    url: `/chats/init`,
+    ...requestConfig,
+    headers: { "Content-Type": "applicationJson", ...requestConfig.headers }
+  });
+  return data;
+}
+async function chatsDelete({
+  pathParams: { chatId },
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!chatId) {
+    throw new Error(`Missing required path parameter: chatId`);
+  }
+  const data = await request({ method: "DELETE", url: `/chats/${chatId}`, ...requestConfig });
+  return data;
+}
+async function chatsGetById({
+  pathParams: { chatId },
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!chatId) {
+    throw new Error(`Missing required path parameter: chatId`);
+  }
+  const data = await request({ method: "GET", url: `/chats/${chatId}`, ...requestConfig });
+  return data;
+}
+async function chatsUpdate({
+  pathParams: { chatId },
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!chatId) {
+    throw new Error(`Missing required path parameter: chatId`);
+  }
+  const data = await request({
+    method: "PATCH",
+    url: `/chats/${chatId}`,
+    ...requestConfig,
+    headers: { "Content-Type": "applicationJson", ...requestConfig.headers }
+  });
+  return data;
+}
+async function chatsFavorite({
+  pathParams: { chatId },
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!chatId) {
+    throw new Error(`Missing required path parameter: chatId`);
+  }
+  const data = await request({
+    method: "PUT",
+    url: `/chats/${chatId}/favorite`,
+    ...requestConfig,
+    headers: { "Content-Type": "applicationJson", ...requestConfig.headers }
+  });
+  return data;
+}
+async function chatsFork({
+  pathParams: { chatId },
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!chatId) {
+    throw new Error(`Missing required path parameter: chatId`);
+  }
+  const data = await request({
+    method: "POST",
+    url: `/chats/${chatId}/fork`,
+    ...requestConfig,
+    headers: { "Content-Type": "applicationJson", ...requestConfig.headers }
+  });
+  return data;
+}
+async function projectsGetByChatId({
+  pathParams: { chatId },
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!chatId) {
+    throw new Error(`Missing required path parameter: chatId`);
+  }
+  const data = await request({ method: "GET", url: `/chats/${chatId}/project`, ...requestConfig });
+  return data;
+}
+async function chatsSendMessage({
+  pathParams: { chatId },
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!chatId) {
+    throw new Error(`Missing required path parameter: chatId`);
+  }
+  const data = await request({
+    method: "POST",
+    url: `/chats/${chatId}/messages`,
+    ...requestConfig,
+    headers: { "Content-Type": "applicationJson", ...requestConfig.headers }
+  });
+  return data;
+}
+async function chatsGetMetadata({
+  pathParams: { chatId },
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!chatId) {
+    throw new Error(`Missing required path parameter: chatId`);
+  }
+  const data = await request({ method: "GET", url: `/chats/${chatId}/metadata`, ...requestConfig });
+  return data;
+}
+async function chatsResume({
+  pathParams: { chatId, messageId },
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!chatId) {
+    throw new Error(`Missing required path parameter: chatId`);
+  }
+  if (!messageId) {
+    throw new Error(`Missing required path parameter: messageId`);
+  }
+  const data = await request({ method: "POST", url: `/chats/${chatId}/messages/${messageId}/resume`, ...requestConfig });
+  return data;
+}
+async function deploymentsFindLogs({
+  pathParams: { deploymentId },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!deploymentId) {
+    throw new Error(`Missing required path parameter: deploymentId`);
+  }
+  const data = await request({ method: "GET", url: `/deployments/${deploymentId}/logs`, queryParams, ...requestConfig });
+  return data;
+}
+async function deploymentsFindErrors({
+  pathParams: { deploymentId },
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!deploymentId) {
+    throw new Error(`Missing required path parameter: deploymentId`);
+  }
+  const data = await request({ method: "GET", url: `/deployments/${deploymentId}/errors`, ...requestConfig });
+  return data;
+}
+async function integrationsVercelProjectsFind({
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  const data = await request({ method: "GET", url: `/integrations/vercel/projects`, ...requestConfig });
+  return data;
+}
+async function integrationsVercelProjectsCreate({
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  const data = await request({
+    method: "POST",
+    url: `/integrations/vercel/projects`,
+    ...requestConfig,
+    headers: { "Content-Type": "applicationJson", ...requestConfig.headers }
+  });
+  return data;
+}
+async function projectsFind({ config = {} }) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  const data = await request({ method: "GET", url: `/projects`, ...requestConfig });
+  return data;
+}
+async function projectsCreate({
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  const data = await request({
+    method: "POST",
+    url: `/projects`,
+    ...requestConfig,
+    headers: { "Content-Type": "applicationJson", ...requestConfig.headers }
+  });
+  return data;
+}
+async function projectsAssign({
+  pathParams: { projectId },
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!projectId) {
+    throw new Error(`Missing required path parameter: projectId`);
+  }
+  const data = await request({
+    method: "POST",
+    url: `/projects/${projectId}/assign`,
+    ...requestConfig,
+    headers: { "Content-Type": "applicationJson", ...requestConfig.headers }
+  });
+  return data;
+}
+async function rateLimitsFind({
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  const data = await request({ method: "GET", url: `/rate-limits`, queryParams, ...requestConfig });
+  return data;
+}
+async function userGet({ config = {} }) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  const data = await request({ method: "GET", url: `/user`, ...requestConfig });
+  return data;
+}
+async function userGetBilling({
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  const data = await request({ method: "GET", url: `/user/billing`, queryParams, ...requestConfig });
+  return data;
+}
+async function userGetPlan({ config = {} }) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  const data = await request({ method: "GET", url: `/user/plan`, ...requestConfig });
+  return data;
+}
+async function userGetScopes({ config = {} }) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  const data = await request({ method: "GET", url: `/user/scopes`, ...requestConfig });
+  return data;
+}
+const operationsByPath$1 = {
+  "POST /chats": chatsCreate,
+  "GET /chats": chatsFind,
+  "POST /chats/init": chatsInitCreate,
+  "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,
+  "POST /chats/{chatId}/messages": chatsSendMessage,
+  "GET /chats/{chatId}/metadata": chatsGetMetadata,
+  "POST /chats/{chatId}/messages/{messageId}/resume": chatsResume,
+  "GET /deployments/{deploymentId}/logs": deploymentsFindLogs,
+  "GET /deployments/{deploymentId}/errors": deploymentsFindErrors,
+  "GET /integrations/vercel/projects": integrationsVercelProjectsFind,
+  "POST /integrations/vercel/projects": integrationsVercelProjectsCreate,
+  "GET /projects": projectsFind,
+  "POST /projects": projectsCreate,
+  "POST /projects/{projectId}/assign": projectsAssign,
+  "GET /rate-limits": rateLimitsFind,
+  "GET /user": userGet,
+  "GET /user/billing": userGetBilling,
+  "GET /user/plan": userGetPlan,
+  "GET /user/scopes": userGetScopes
+};
+const operationsByTag$1 = {
+  chats: {
+    chatsCreate,
+    chatsFind,
+    chatsInitCreate,
+    chatsDelete,
+    chatsGetById,
+    chatsUpdate,
+    chatsFavorite,
+    chatsFork,
+    chatsSendMessage,
+    chatsGetMetadata,
+    chatsResume
+  },
+  projects: {
+    projectsGetByChatId,
+    projectsFind,
+    projectsCreate,
+    projectsAssign
+  },
+  deployments: {
+    deploymentsFindLogs,
+    deploymentsFindErrors
+  },
+  integrations: {
+    integrationsVercelProjectsFind,
+    integrationsVercelProjectsCreate
+  },
+  ratelimits: {
+    rateLimitsFind
+  },
+  user: {
+    userGet,
+    userGetBilling,
+    userGetPlan,
+    userGetScopes
+  }
+};
+const tagDictionary$1 = {
+  chats: {
+    POST: ["chatsCreate", "chatsInitCreate", "chatsFork", "chatsSendMessage", "chatsResume"],
+    GET: ["chatsFind", "chatsGetById", "chatsGetMetadata"],
+    DELETE: ["chatsDelete"],
+    PATCH: ["chatsUpdate"],
+    PUT: ["chatsFavorite"]
+  },
+  projects: {
+    GET: ["projectsGetByChatId", "projectsFind"],
+    POST: ["projectsCreate", "projectsAssign"]
+  },
+  deployments: {
+    GET: ["deploymentsFindLogs", "deploymentsFindErrors"]
+  },
+  integrations: {
+    GET: ["integrationsVercelProjectsFind"],
+    POST: ["integrationsVercelProjectsCreate"]
+  },
+  ratelimits: {
+    GET: ["rateLimitsFind"]
+  },
+  user: {
+    GET: ["userGet", "userGetBilling", "userGetPlan", "userGetScopes"]
+  }
+};
+
+const Components = {
+  __proto__: null,
+  chatsCreate: chatsCreate,
+  chatsDelete: chatsDelete,
+  chatsFavorite: chatsFavorite,
+  chatsFind: chatsFind,
+  chatsFork: chatsFork,
+  chatsGetById: chatsGetById,
+  chatsGetMetadata: chatsGetMetadata,
+  chatsInitCreate: chatsInitCreate,
+  chatsResume: chatsResume,
+  chatsSendMessage: chatsSendMessage,
+  chatsUpdate: chatsUpdate,
+  deploymentsFindErrors: deploymentsFindErrors,
+  deploymentsFindLogs: deploymentsFindLogs,
+  integrationsVercelProjectsCreate: integrationsVercelProjectsCreate,
+  integrationsVercelProjectsFind: integrationsVercelProjectsFind,
+  operationsByPath: operationsByPath$1,
+  operationsByTag: operationsByTag$1,
+  projectsAssign: projectsAssign,
+  projectsCreate: projectsCreate,
+  projectsFind: projectsFind,
+  projectsGetByChatId: projectsGetByChatId,
+  rateLimitsFind: rateLimitsFind,
+  tagDictionary: tagDictionary$1,
+  userGet: userGet,
+  userGetBilling: userGetBilling,
+  userGetPlan: userGetPlan,
+  userGetScopes: userGetScopes
+};
+
+const chatDetailPrivacyEnum = {
+  private: "private",
+  public: "public",
+  team: "team",
+  "team-edit": "team-edit",
+  unlisted: "unlisted"
+};
+const messagesTypeEnum = {
+  "added-environment-variables": "added-environment-variables",
+  "added-integration": "added-integration",
+  "deleted-file": "deleted-file",
+  "edited-file": "edited-file",
+  "fix-with-v0": "fix-with-v0",
+  "forked-block": "forked-block",
+  "forked-chat": "forked-chat",
+  message: "message",
+  "moved-file": "moved-file",
+  "open-in-v0": "open-in-v0",
+  refinement: "refinement",
+  "renamed-file": "renamed-file",
+  "replace-src": "replace-src",
+  "reverted-block": "reverted-block",
+  "sync-git": "sync-git"
+};
+const messagesRoleEnum = {
+  assistant: "assistant",
+  user: "user"
+};
+const latestVersionStatusEnum = {
+  completed: "completed",
+  failed: "failed",
+  pending: "pending"
+};
+const modelConfigurationModelIdEnum = {
+  "v0-1.5-lg": "v0-1.5-lg",
+  "v0-1.5-md": "v0-1.5-md",
+  "v0-1.5-sm": "v0-1.5-sm"
+};
+const chatSummaryPrivacyEnum = {
+  private: "private",
+  public: "public",
+  team: "team",
+  "team-edit": "team-edit",
+  unlisted: "unlisted"
+};
+const latestVersionStatusEnum2 = {
+  completed: "completed",
+  failed: "failed",
+  pending: "pending"
+};
+const modelConfigurationModelIdEnum2 = {
+  "v0-1.5-lg": "v0-1.5-lg",
+  "v0-1.5-md": "v0-1.5-md",
+  "v0-1.5-sm": "v0-1.5-sm"
+};
+const messageSummaryTypeEnum = {
+  "added-environment-variables": "added-environment-variables",
+  "added-integration": "added-integration",
+  "deleted-file": "deleted-file",
+  "edited-file": "edited-file",
+  "fix-with-v0": "fix-with-v0",
+  "forked-block": "forked-block",
+  "forked-chat": "forked-chat",
+  message: "message",
+  "moved-file": "moved-file",
+  "open-in-v0": "open-in-v0",
+  refinement: "refinement",
+  "renamed-file": "renamed-file",
+  "replace-src": "replace-src",
+  "reverted-block": "reverted-block",
+  "sync-git": "sync-git"
+};
+const messageSummaryRoleEnum = {
+  assistant: "assistant",
+  user: "user"
+};
+const versionDetailStatusEnum = {
+  completed: "completed",
+  failed: "failed",
+  pending: "pending"
+};
+const versionSummaryStatusEnum = {
+  completed: "completed",
+  failed: "failed",
+  pending: "pending"
+};
+
+const types = {
+  __proto__: null,
+  chatDetailPrivacyEnum: chatDetailPrivacyEnum,
+  chatSummaryPrivacyEnum: chatSummaryPrivacyEnum,
+  latestVersionStatusEnum: latestVersionStatusEnum,
+  latestVersionStatusEnum2: latestVersionStatusEnum2,
+  messageSummaryRoleEnum: messageSummaryRoleEnum,
+  messageSummaryTypeEnum: messageSummaryTypeEnum,
+  messagesRoleEnum: messagesRoleEnum,
+  messagesTypeEnum: messagesTypeEnum,
+  modelConfigurationModelIdEnum: modelConfigurationModelIdEnum,
+  modelConfigurationModelIdEnum2: modelConfigurationModelIdEnum2,
+  versionDetailStatusEnum: versionDetailStatusEnum,
+  versionSummaryStatusEnum: versionSummaryStatusEnum
+};
+
+class V0Api {
+  token;
+  fetch;
+  constructor(options) {
+    this.token = options.token;
+    this.fetch = options.fetch || fetch;
+    if (!this.fetch) throw new Error("Fetch is required");
+  }
+  get api() {
+    const getConfig = async () => ({
+      token: this.token,
+      fetchImpl: this.fetch
+    });
+    return new Proxy(
+      {},
+      {
+        get: (_target, namespace) => {
+          if (operationsByTag$1[namespace] === void 0) {
+            return void 0;
+          }
+          return new Proxy(
+            {},
+            {
+              get: (_target2, operation) => {
+                if (operationsByTag$1[namespace][operation] === void 0) {
+                  return void 0;
+                }
+                const method = operationsByTag$1[namespace][operation];
+                return async (params) => {
+                  return await method({ ...params, config: await getConfig() });
+                };
+              }
+            }
+          );
+        }
+      }
+    );
+  }
+  async request(endpoint, params) {
+    const [method = "", url = ""] = endpoint.split(" ");
+    const extraParams = params || {};
+    const result = await schemas.client({
+      ...extraParams,
+      method,
+      url,
+      token: this.token,
+      fetchImpl: this.fetch
+    });
+    return result;
+  }
+}
+
+const { operationsByPath, operationsByTag, tagDictionary, ...Fetchers } = Components;
+const Helpers = { operationsByPath, operationsByTag, tagDictionary };
+
+exports.Schemas = schemas.schemas;
+exports.Fetchers = Fetchers;
+exports.Helpers = Helpers;
+exports.Types = types;
+exports.V0Api = V0Api;