v0-api 0.0.2

package/README.md

@@ -0,0 +1,3 @@
+# v0 API JavaScript SDK
+
+Unofficial Vercel v0 API JavaScript SDK built from the OpenAPI specification and with TypeScript types.

package/dist/client.d.mts

@@ -0,0 +1,57 @@
+import { operationsByPath, operationsByTag, tagDictionary } from "./generated/components.mjs";
+import { FetchImpl } from "./utils/fetch.mjs";
+import { FetcherConfig } from "./utils/fetcher.mjs";
+import { RequiredKeys } from "./utils/types.mjs";
+export interface VercelApiOptions {
+    token: string | null;
+    fetch?: FetchImpl;
+}
+export type ApiClient = {
+    [Tag in keyof typeof operationsByTag]: {
+        [Method in keyof (typeof operationsByTag)[Tag]]: (typeof operationsByTag)[Tag][Method] extends infer Operation extends (...args: any) => any ? Omit<Parameters<Operation>[0], keyof FetcherConfig> extends infer Params ? RequiredKeys<Params> extends never ? (params?: Params) => ReturnType<Operation> : (params: Params) => ReturnType<Operation> : never : never;
+    };
+};
+type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+export type ApiOperation = {
+    [Tag in keyof typeof operationsByTag]: keyof (typeof operationsByTag)[Tag] extends string ? `${Tag}.${keyof (typeof operationsByTag)[Tag]}` : never;
+}[keyof typeof operationsByTag];
+export type ApiOperationByMethod<Method extends HttpMethod> = {
+    [Tag in keyof typeof tagDictionary]: {
+        [TagMethod in keyof (typeof tagDictionary)[Tag]]: TagMethod extends Method ? (typeof tagDictionary)[Tag][TagMethod] extends readonly any[] ? `${Tag}.${(typeof tagDictionary)[Tag][TagMethod][number]}` : never : never;
+    }[keyof (typeof tagDictionary)[Tag]];
+}[keyof typeof tagDictionary];
+export type ApiOperationParams<T extends ApiOperation> = T extends `${infer Tag}.${infer Operation}` ? Tag extends keyof typeof operationsByTag ? Operation extends keyof (typeof operationsByTag)[Tag] ? (typeof operationsByTag)[Tag][Operation] extends infer Operation extends (...args: any) => any ? Omit<Parameters<Operation>[0], keyof FetcherConfig> : never : never : never : never;
+export type ApiOperationResult<T extends ApiOperation> = T extends `${infer Tag}.${infer Operation}` ? Tag extends keyof typeof operationsByTag ? Operation extends keyof (typeof operationsByTag)[Tag] ? (typeof operationsByTag)[Tag][Operation] extends (...args: any) => any ? Awaited<ReturnType<(typeof operationsByTag)[Tag][Operation]>> : never : never : never : never;
+type RequestEndpointParams<T extends keyof typeof operationsByPath> = Omit<Parameters<(typeof operationsByPath)[T]>[0], keyof FetcherConfig>;
+export declare class XataApi {
+    token: string | null;
+    fetch: FetchImpl;
+    constructor(options: VercelApiOptions);
+    get api(): ApiClient;
+    request<Endpoint extends keyof typeof operationsByPath>(endpoint: Endpoint, params: RequestEndpointParams<Endpoint>): Promise<ReturnType<{
+        'POST chats': typeof import("./generated/components").chatsCreate;
+        'GET chats': typeof import("./generated/components").chatsFind;
+        'DELETE chatsChatId': typeof import("./generated/components").chatsDelete;
+        'GET chatsChatId': typeof import("./generated/components").chatsGetById;
+        'PATCH chatsChatId': typeof import("./generated/components").chatsUpdate;
+        'PUT chatsChatIdFavorite': typeof import("./generated/components").chatsFavorite;
+        'POST chatsChatIdFork': typeof import("./generated/components").chatsFork;
+        'GET chatsChatIdProject': typeof import("./generated/components").projectsGetByChatId;
+        'POST chatsChatIdMessages': typeof import("./generated/components").chatsSendMessage;
+        'GET chatsChatIdMetadata': typeof import("./generated/components").chatsGetMetadata;
+        'POST chatsChatIdMessagesMessageIdResume': typeof import("./generated/components").chatsResume;
+        'GET deploymentsDeploymentIdLogs': typeof import("./generated/components").deploymentsFindLogs;
+        'GET deploymentsDeploymentIdErrors': typeof import("./generated/components").deploymentsFindErrors;
+        'GET integrationsVercelProjects': typeof import("./generated/components").integrationsVercelProjectsFind;
+        'POST integrationsVercelProjects': typeof import("./generated/components").integrationsVercelProjectsCreate;
+        'GET projects': typeof import("./generated/components").projectsFind;
+        'POST projects': typeof import("./generated/components").projectsCreate;
+        'POST projectsProjectIdAssign': typeof import("./generated/components").projectsAssign;
+        'GET rateLimits': typeof import("./generated/components").rateLimitsFind;
+        'GET user': typeof import("./generated/components").userGet;
+        'GET userBilling': typeof import("./generated/components").userGetBilling;
+        'GET userPlan': typeof import("./generated/components").userGetPlan;
+        'GET userScopes': typeof import("./generated/components").userGetScopes;
+    }[Endpoint]>>;
+}
+export {};

package/dist/client.d.ts

@@ -0,0 +1,57 @@
+import { operationsByPath, operationsByTag, tagDictionary } from "./generated/components.js";
+import { FetchImpl } from "./utils/fetch.js";
+import { FetcherConfig } from "./utils/fetcher.js";
+import { RequiredKeys } from "./utils/types.js";
+export interface VercelApiOptions {
+    token: string | null;
+    fetch?: FetchImpl;
+}
+export type ApiClient = {
+    [Tag in keyof typeof operationsByTag]: {
+        [Method in keyof (typeof operationsByTag)[Tag]]: (typeof operationsByTag)[Tag][Method] extends infer Operation extends (...args: any) => any ? Omit<Parameters<Operation>[0], keyof FetcherConfig> extends infer Params ? RequiredKeys<Params> extends never ? (params?: Params) => ReturnType<Operation> : (params: Params) => ReturnType<Operation> : never : never;
+    };
+};
+type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+export type ApiOperation = {
+    [Tag in keyof typeof operationsByTag]: keyof (typeof operationsByTag)[Tag] extends string ? `${Tag}.${keyof (typeof operationsByTag)[Tag]}` : never;
+}[keyof typeof operationsByTag];
+export type ApiOperationByMethod<Method extends HttpMethod> = {
+    [Tag in keyof typeof tagDictionary]: {
+        [TagMethod in keyof (typeof tagDictionary)[Tag]]: TagMethod extends Method ? (typeof tagDictionary)[Tag][TagMethod] extends readonly any[] ? `${Tag}.${(typeof tagDictionary)[Tag][TagMethod][number]}` : never : never;
+    }[keyof (typeof tagDictionary)[Tag]];
+}[keyof typeof tagDictionary];
+export type ApiOperationParams<T extends ApiOperation> = T extends `${infer Tag}.${infer Operation}` ? Tag extends keyof typeof operationsByTag ? Operation extends keyof (typeof operationsByTag)[Tag] ? (typeof operationsByTag)[Tag][Operation] extends infer Operation extends (...args: any) => any ? Omit<Parameters<Operation>[0], keyof FetcherConfig> : never : never : never : never;
+export type ApiOperationResult<T extends ApiOperation> = T extends `${infer Tag}.${infer Operation}` ? Tag extends keyof typeof operationsByTag ? Operation extends keyof (typeof operationsByTag)[Tag] ? (typeof operationsByTag)[Tag][Operation] extends (...args: any) => any ? Awaited<ReturnType<(typeof operationsByTag)[Tag][Operation]>> : never : never : never : never;
+type RequestEndpointParams<T extends keyof typeof operationsByPath> = Omit<Parameters<(typeof operationsByPath)[T]>[0], keyof FetcherConfig>;
+export declare class XataApi {
+    token: string | null;
+    fetch: FetchImpl;
+    constructor(options: VercelApiOptions);
+    get api(): ApiClient;
+    request<Endpoint extends keyof typeof operationsByPath>(endpoint: Endpoint, params: RequestEndpointParams<Endpoint>): Promise<ReturnType<{
+        'POST chats': typeof import("./generated/components").chatsCreate;
+        'GET chats': typeof import("./generated/components").chatsFind;
+        'DELETE chatsChatId': typeof import("./generated/components").chatsDelete;
+        'GET chatsChatId': typeof import("./generated/components").chatsGetById;
+        'PATCH chatsChatId': typeof import("./generated/components").chatsUpdate;
+        'PUT chatsChatIdFavorite': typeof import("./generated/components").chatsFavorite;
+        'POST chatsChatIdFork': typeof import("./generated/components").chatsFork;
+        'GET chatsChatIdProject': typeof import("./generated/components").projectsGetByChatId;
+        'POST chatsChatIdMessages': typeof import("./generated/components").chatsSendMessage;
+        'GET chatsChatIdMetadata': typeof import("./generated/components").chatsGetMetadata;
+        'POST chatsChatIdMessagesMessageIdResume': typeof import("./generated/components").chatsResume;
+        'GET deploymentsDeploymentIdLogs': typeof import("./generated/components").deploymentsFindLogs;
+        'GET deploymentsDeploymentIdErrors': typeof import("./generated/components").deploymentsFindErrors;
+        'GET integrationsVercelProjects': typeof import("./generated/components").integrationsVercelProjectsFind;
+        'POST integrationsVercelProjects': typeof import("./generated/components").integrationsVercelProjectsCreate;
+        'GET projects': typeof import("./generated/components").projectsFind;
+        'POST projects': typeof import("./generated/components").projectsCreate;
+        'POST projectsProjectIdAssign': typeof import("./generated/components").projectsAssign;
+        'GET rateLimits': typeof import("./generated/components").rateLimitsFind;
+        'GET user': typeof import("./generated/components").userGet;
+        'GET userBilling': typeof import("./generated/components").userGetBilling;
+        'GET userPlan': typeof import("./generated/components").userGetPlan;
+        'GET userScopes': typeof import("./generated/components").userGetScopes;
+    }[Endpoint]>>;
+}
+export {};

package/dist/client.js

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XataApi = void 0;
+const components_1 = require("./generated/components.js");
+const fetcher_1 = __importDefault(require("./utils/fetcher.js"));
+class XataApi {
+    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 (components_1.operationsByTag[namespace] === undefined) {
+                    return undefined;
+                }
+                return new Proxy({}, {
+                    get: (_target, operation) => {
+                        if (components_1.operationsByTag[namespace][operation] === undefined) {
+                            return undefined;
+                        }
+                        const method = components_1.operationsByTag[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 (0, fetcher_1.default)({
+            ...extraParams,
+            method,
+            url,
+            token: this.token,
+            fetchImpl: this.fetch
+        });
+        return result;
+    }
+}
+exports.XataApi = XataApi;

package/dist/client.mjs

@@ -0,0 +1,46 @@
+import { operationsByTag } from "./generated/components.mjs";
+import fetchFn from "./utils/fetcher.mjs";
+export class XataApi {
+    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[namespace] === undefined) {
+                    return undefined;
+                }
+                return new Proxy({}, {
+                    get: (_target, operation) => {
+                        if (operationsByTag[namespace][operation] === undefined) {
+                            return undefined;
+                        }
+                        const method = operationsByTag[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 fetchFn({
+            ...extraParams,
+            method,
+            url,
+            token: this.token,
+            fetchImpl: this.fetch
+        });
+        return result;
+    }
+}

package/dist/generated/components.d.mts

@@ -0,0 +1,341 @@
+/**
+ * Generated by Kubb (https://kubb.dev/).
+ * Do not edit manually.
+ */
+import client from "../utils/fetcher.mjs";
+import type { FetcherConfig } from "../utils/fetcher.mjs";
+import type { ChatsFindQueryParams, ChatsDeletePathParams, ChatsGetByIdPathParams, ChatsUpdatePathParams, ChatsFavoritePathParams, ChatsForkPathParams, ProjectsGetByChatIdPathParams, ChatsSendMessagePathParams, ChatsGetMetadataPathParams, ChatsResumePathParams, DeploymentsFindLogsPathParams, DeploymentsFindLogsQueryParams, DeploymentsFindErrorsPathParams, ProjectsAssignPathParams, RateLimitsFindQueryParams, UserGetBillingQueryParams } from "./types.mjs";
+/**
+ * @description Create a new chat
+ * @summary Create Chat
+ * {@link chats}
+ */
+export declare function chatsCreate({ config }: {
+    config?: Partial<FetcherConfig> & {
+        client?: typeof client;
+    };
+}): Promise<unknown>;
+/**
+ * @description Find all chats
+ * @summary Find Chats
+ * {@link chats}
+ */
+export declare function chatsFind({ queryParams, config, }: {
+    queryParams?: ChatsFindQueryParams;
+    config?: Partial<FetcherConfig> & {
+        client?: typeof client;
+    };
+}): Promise<unknown>;
+/**
+ * @description Delete a chat
+ * @summary Delete Chat
+ * {@link chatsChatId}
+ */
+export declare function chatsDelete({ pathParams: { chatId }, config, }: {
+    pathParams: ChatsDeletePathParams;
+    config?: Partial<FetcherConfig> & {
+        client?: typeof client;
+    };
+}): Promise<unknown>;
+/**
+ * @description Get a chat
+ * @summary Get Chat
+ * {@link chatsChatId}
+ */
+export declare function chatsGetById({ pathParams: { chatId }, config, }: {
+    pathParams: ChatsGetByIdPathParams;
+    config?: Partial<FetcherConfig> & {
+        client?: typeof client;
+    };
+}): Promise<unknown>;
+/**
+ * @description Update a chat
+ * @summary Update Chat
+ * {@link chatsChatId}
+ */
+export declare function chatsUpdate({ pathParams: { chatId }, config, }: {
+    pathParams: ChatsUpdatePathParams;
+    config?: Partial<FetcherConfig> & {
+        client?: typeof client;
+    };
+}): Promise<unknown>;
+/**
+ * @description Favorite a chat
+ * @summary Favorite Chat
+ * {@link chatsChatIdFavorite}
+ */
+export declare function chatsFavorite({ pathParams: { chatId }, config, }: {
+    pathParams: ChatsFavoritePathParams;
+    config?: Partial<FetcherConfig> & {
+        client?: typeof client;
+    };
+}): Promise<unknown>;
+/**
+ * @description Fork a version in a chat
+ * @summary Fork Chat
+ * {@link chatsChatIdFork}
+ */
+export declare function chatsFork({ pathParams: { chatId }, config, }: {
+    pathParams: ChatsForkPathParams;
+    config?: Partial<FetcherConfig> & {
+        client?: typeof client;
+    };
+}): Promise<unknown>;
+/**
+ * @description Get the project for a chat
+ * @summary Get Project by Chat ID
+ * {@link chatsChatIdProject}
+ */
+export declare function projectsGetByChatId({ pathParams: { chatId }, config, }: {
+    pathParams: ProjectsGetByChatIdPathParams;
+    config?: Partial<FetcherConfig> & {
+        client?: typeof client;
+    };
+}): Promise<unknown>;
+/**
+ * @description Create a new message in a chat
+ * @summary Create Message
+ * {@link chatsChatIdMessages}
+ */
+export declare function chatsSendMessage({ pathParams: { chatId }, config, }: {
+    pathParams: ChatsSendMessagePathParams;
+    config?: Partial<FetcherConfig> & {
+        client?: typeof client;
+    };
+}): Promise<unknown>;
+/**
+ * @description Get the metadata for a chat
+ * @summary Get Chat Metadata
+ * {@link chatsChatIdMetadata}
+ */
+export declare function chatsGetMetadata({ pathParams: { chatId }, config, }: {
+    pathParams: ChatsGetMetadataPathParams;
+    config?: Partial<FetcherConfig> & {
+        client?: typeof client;
+    };
+}): Promise<unknown>;
+/**
+ * @description Resume a chat message
+ * @summary Resume Chat Message
+ * {@link chatsChatIdMessagesMessageIdResume}
+ */
+export declare function chatsResume({ pathParams: { chatId, messageId }, config, }: {
+    pathParams: ChatsResumePathParams;
+    config?: Partial<FetcherConfig> & {
+        client?: typeof client;
+    };
+}): Promise<unknown>;
+/**
+ * @description Find logs for a deployment
+ * @summary Find Deployment Logs
+ * {@link deploymentsDeploymentIdLogs}
+ */
+export declare function deploymentsFindLogs({ pathParams: { deploymentId }, queryParams, config, }: {
+    pathParams: DeploymentsFindLogsPathParams;
+    queryParams?: DeploymentsFindLogsQueryParams;
+    config?: Partial<FetcherConfig> & {
+        client?: typeof client;
+    };
+}): Promise<unknown>;
+/**
+ * @description Find errors for a deployment
+ * @summary Find Deployment Errors
+ * {@link deploymentsDeploymentIdErrors}
+ */
+export declare function deploymentsFindErrors({ pathParams: { deploymentId }, config, }: {
+    pathParams: DeploymentsFindErrorsPathParams;
+    config?: Partial<FetcherConfig> & {
+        client?: typeof client;
+    };
+}): Promise<unknown>;
+/**
+ * @description Find all Vercel projects
+ * @summary Find Vercel Projects
+ * {@link integrationsVercelProjects}
+ */
+export declare function integrationsVercelProjectsFind({ config }: {
+    config?: Partial<FetcherConfig> & {
+        client?: typeof client;
+    };
+}): Promise<unknown>;
+/**
+ * @description Create a new Vercel project
+ * @summary Create Vercel Project
+ * {@link integrationsVercelProjects}
+ */
+export declare function integrationsVercelProjectsCreate({ config }: {
+    config?: Partial<FetcherConfig> & {
+        client?: typeof client;
+    };
+}): Promise<unknown>;
+/**
+ * @description Find all projects
+ * @summary Find Projects
+ * {@link projects}
+ */
+export declare function projectsFind({ config }: {
+    config?: Partial<FetcherConfig> & {
+        client?: typeof client;
+    };
+}): Promise<unknown>;
+/**
+ * @description Create a new project
+ * @summary Create Project
+ * {@link projects}
+ */
+export declare function projectsCreate({ config }: {
+    config?: Partial<FetcherConfig> & {
+        client?: typeof client;
+    };
+}): Promise<unknown>;
+/**
+ * @description Assign a project to a chat
+ * @summary Assign Project to Chat
+ * {@link projectsProjectIdAssign}
+ */
+export declare function projectsAssign({ pathParams: { projectId }, config, }: {
+    pathParams: ProjectsAssignPathParams;
+    config?: Partial<FetcherConfig> & {
+        client?: typeof client;
+    };
+}): Promise<unknown>;
+/**
+ * @description Find the rate limit for a scope
+ * @summary Find Rate Limit
+ * {@link rateLimits}
+ */
+export declare function rateLimitsFind({ queryParams, config, }: {
+    queryParams?: RateLimitsFindQueryParams;
+    config?: Partial<FetcherConfig> & {
+        client?: typeof client;
+    };
+}): Promise<unknown>;
+/**
+ * @description Get the user
+ * @summary Get User
+ * {@link user}
+ */
+export declare function userGet({ config }: {
+    config?: Partial<FetcherConfig> & {
+        client?: typeof client;
+    };
+}): Promise<unknown>;
+/**
+ * @description Get the billing for the user
+ * @summary Get Billing
+ * {@link userBilling}
+ */
+export declare function userGetBilling({ queryParams, config, }: {
+    queryParams?: UserGetBillingQueryParams;
+    config?: Partial<FetcherConfig> & {
+        client?: typeof client;
+    };
+}): Promise<unknown>;
+/**
+ * @description Get the plan for the user
+ * @summary Get Plan
+ * {@link userPlan}
+ */
+export declare function userGetPlan({ config }: {
+    config?: Partial<FetcherConfig> & {
+        client?: typeof client;
+    };
+}): Promise<unknown>;
+/**
+ * @description Get all scopes for the user
+ * @summary Get User Scopes
+ * {@link userScopes}
+ */
+export declare function userGetScopes({ config }: {
+    config?: Partial<FetcherConfig> & {
+        client?: typeof client;
+    };
+}): Promise<unknown>;
+export declare const operationsByPath: {
+    'POST chats': typeof chatsCreate;
+    'GET chats': typeof chatsFind;
+    'DELETE chatsChatId': typeof chatsDelete;
+    'GET chatsChatId': typeof chatsGetById;
+    'PATCH chatsChatId': typeof chatsUpdate;
+    'PUT chatsChatIdFavorite': typeof chatsFavorite;
+    'POST chatsChatIdFork': typeof chatsFork;
+    'GET chatsChatIdProject': typeof projectsGetByChatId;
+    'POST chatsChatIdMessages': typeof chatsSendMessage;
+    'GET chatsChatIdMetadata': typeof chatsGetMetadata;
+    'POST chatsChatIdMessagesMessageIdResume': typeof chatsResume;
+    'GET deploymentsDeploymentIdLogs': typeof deploymentsFindLogs;
+    'GET deploymentsDeploymentIdErrors': typeof deploymentsFindErrors;
+    'GET integrationsVercelProjects': typeof integrationsVercelProjectsFind;
+    'POST integrationsVercelProjects': typeof integrationsVercelProjectsCreate;
+    'GET projects': typeof projectsFind;
+    'POST projects': typeof projectsCreate;
+    'POST projectsProjectIdAssign': typeof projectsAssign;
+    'GET rateLimits': typeof rateLimitsFind;
+    'GET user': typeof userGet;
+    'GET userBilling': typeof userGetBilling;
+    'GET userPlan': typeof userGetPlan;
+    'GET userScopes': typeof userGetScopes;
+};
+export declare const operationsByTag: {
+    chats: {
+        chatsCreate: typeof chatsCreate;
+        chatsFind: typeof chatsFind;
+        chatsDelete: typeof chatsDelete;
+        chatsGetById: typeof chatsGetById;
+        chatsUpdate: typeof chatsUpdate;
+        chatsFavorite: typeof chatsFavorite;
+        chatsFork: typeof chatsFork;
+        chatsSendMessage: typeof chatsSendMessage;
+        chatsGetMetadata: typeof chatsGetMetadata;
+        chatsResume: typeof chatsResume;
+    };
+    projects: {
+        projectsGetByChatId: typeof projectsGetByChatId;
+        projectsFind: typeof projectsFind;
+        projectsCreate: typeof projectsCreate;
+        projectsAssign: typeof projectsAssign;
+    };
+    deployments: {
+        deploymentsFindLogs: typeof deploymentsFindLogs;
+        deploymentsFindErrors: typeof deploymentsFindErrors;
+    };
+    integrations: {
+        integrationsVercelProjectsFind: typeof integrationsVercelProjectsFind;
+        integrationsVercelProjectsCreate: typeof integrationsVercelProjectsCreate;
+    };
+    ratelimits: {
+        rateLimitsFind: typeof rateLimitsFind;
+    };
+    user: {
+        userGet: typeof userGet;
+        userGetBilling: typeof userGetBilling;
+        userGetPlan: typeof userGetPlan;
+        userGetScopes: typeof userGetScopes;
+    };
+};
+export declare const tagDictionary: {
+    readonly chats: {
+        readonly POST: readonly ["chatsCreate", "chatsFork", "chatsSendMessage", "chatsResume"];
+        readonly GET: readonly ["chatsFind", "chatsGetById", "chatsGetMetadata"];
+        readonly DELETE: readonly ["chatsDelete"];
+        readonly PATCH: readonly ["chatsUpdate"];
+        readonly PUT: readonly ["chatsFavorite"];
+    };
+    readonly projects: {
+        readonly GET: readonly ["projectsGetByChatId", "projectsFind"];
+        readonly POST: readonly ["projectsCreate", "projectsAssign"];
+    };
+    readonly deployments: {
+        readonly GET: readonly ["deploymentsFindLogs", "deploymentsFindErrors"];
+    };
+    readonly integrations: {
+        readonly GET: readonly ["integrationsVercelProjectsFind"];
+        readonly POST: readonly ["integrationsVercelProjectsCreate"];
+    };
+    readonly ratelimits: {
+        readonly GET: readonly ["rateLimitsFind"];
+    };
+    readonly user: {
+        readonly GET: readonly ["userGet", "userGetBilling", "userGetPlan", "userGetScopes"];
+    };
+};