@chatbotkit/sdk 1.9.1 → 1.10.0

package/dist/esm/integration/notion/v1.d.ts

@@ -0,0 +1,53 @@
+export function listNotionIntegrations(client: ChatBotKitClient, request?: NotionIntegrationListRequest | undefined): ResponsePromise<NotionIntegrationListResponse, NotionIntegrationListStreamType>;
+export function fetchNotionIntegration(client: ChatBotKitClient, notionId: string): Promise<NotionIntegrationFetchResponse>;
+export function createNotionIntegration(client: ChatBotKitClient, request: NotionIntegrationCreateRequest): Promise<NotionIntegrationCreateResponse>;
+export function updateNotionIntegration(client: ChatBotKitClient, notionId: string, request: NotionIntegrationUpdateRequest): Promise<NotionIntegrationUpdateResponse>;
+export function deleteNotionIntegration(client: ChatBotKitClient, notionId: string): Promise<NotionIntegrationDeleteResponse>;
+export function syncNotionIntegration(client: ChatBotKitClient, notionId: string): Promise<NotionIntegrationSyncResponse>;
+export type ChatBotKitClient = import('../../client.js').ChatBotKitClient;
+export type ResponsePromise<T, U> = import('../../client.js').ResponsePromise<T, U>;
+export type NotionIntegrationOptions = {
+    name?: string;
+    description?: string;
+    datasetId?: string;
+    token?: string;
+    syncSchedule?: string;
+    expiresIn?: number;
+    meta?: Record<string, any>;
+};
+export type NotionInegrationInstance = NotionIntegrationOptions & {
+    id: string;
+    createdAt: number;
+    updatedAt: number;
+};
+export type NotionIntegrationListRequest = {
+    cursor?: string;
+    order?: 'desc' | 'asc';
+    take?: number;
+    meta?: Record<string, string>;
+};
+export type NotionIntegrationListResponse = {
+    items: NotionInegrationInstance[];
+};
+export type NotionIntegrationListStreamItem = {
+    type: 'item';
+    data: NotionInegrationInstance;
+};
+export type NotionIntegrationListStreamType = NotionIntegrationListStreamItem;
+export type NotionIntegrationFetchResponse = NotionInegrationInstance & {};
+export type NotionIntegrationCreateRequest = NotionIntegrationOptions & {
+    datasetId: string;
+};
+export type NotionIntegrationCreateResponse = {
+    id: string;
+};
+export type NotionIntegrationUpdateRequest = NotionIntegrationOptions & {};
+export type NotionIntegrationUpdateResponse = {
+    id: string;
+};
+export type NotionIntegrationDeleteResponse = {
+    id: string;
+};
+export type NotionIntegrationSyncResponse = {
+    id: string;
+};

package/dist/esm/integration/notion/v1.js

@@ -0,0 +1,42 @@
+export function listNotionIntegrations(client, request) {
+    let url = `/api/v1/integration/notion/list`;
+    const response = client.clientFetch(url, { query: request });
+    return response;
+}
+export async function fetchNotionIntegration(client, notionId) {
+    const url = `/api/v1/integration/notion/${notionId}/fetch`;
+    const response = await client.clientFetch(url);
+    return response;
+}
+export async function createNotionIntegration(client, request) {
+    const url = `/api/v1/integration/notion/create`;
+    const response = await client.clientFetch(url, {
+        record: {
+            ...request,
+        },
+    });
+    return response;
+}
+export async function updateNotionIntegration(client, notionId, request) {
+    const url = `/api/v1/integration/notion/${notionId}/update`;
+    const response = await client.clientFetch(url, {
+        record: {
+            ...request,
+        },
+    });
+    return response;
+}
+export async function deleteNotionIntegration(client, notionId) {
+    const url = `/api/v1/integration/notion/${notionId}/delete`;
+    const response = await client.clientFetch(url, {
+        record: {},
+    });
+    return response;
+}
+export async function syncNotionIntegration(client, notionId) {
+    const url = `/api/v1/integration/notion/${notionId}/sync`;
+    const response = await client.clientFetch(url, {
+        record: {},
+    });
+    return response;
+}

package/dist/esm/integration/slack/index.d.ts

@@ -0,0 +1,11 @@
+export class SlackIntegrationClient extends ChatBotKitClient {
+    list(request?: import("./v1.js").SlackIntegrationListRequest | undefined): ResponsePromise<import('./v1.js').SlackIntegrationListResponse, import('./v1.js').SlackIntegrationListStreamType>;
+    fetch(slackId: string): Promise<import('./v1.js').SlackIntegrationFetchResponse>;
+    create(request: import('./v1.js').SlackIntegrationCreateRequest): Promise<import('./v1.js').SlackIntegrationCreateResponse>;
+    update(slackId: string, request: import('./v1.js').SlackIntegrationUpdateRequest): Promise<import('./v1.js').SlackIntegrationUpdateResponse>;
+    delete(slackId: string): Promise<import('./v1.js').SlackIntegrationDeleteResponse>;
+    setup(slackId: string): Promise<import('./v1.js').SlackIntegrationSetupResponse>;
+}
+export default SlackIntegrationClient;
+export type ResponsePromise<T, U> = import('../../client.js').ResponsePromise<T, U>;
+import { ChatBotKitClient } from '../../client.js';

package/dist/esm/integration/slack/index.js

@@ -0,0 +1,26 @@
+import { ChatBotKitClient } from '../../client.js';
+import { createSlackIntegration, deleteSlackIntegration, fetchSlackIntegration, listSlackIntegrations, setupSlackIntegration, updateSlackIntegration, } from './v1.js';
+export class SlackIntegrationClient extends ChatBotKitClient {
+    constructor(options) {
+        super(options);
+    }
+    list(request) {
+        return listSlackIntegrations(this, request);
+    }
+    fetch(slackId) {
+        return fetchSlackIntegration(this, slackId);
+    }
+    create(request) {
+        return createSlackIntegration(this, request);
+    }
+    update(slackId, request) {
+        return updateSlackIntegration(this, slackId, request);
+    }
+    delete(slackId) {
+        return deleteSlackIntegration(this, slackId);
+    }
+    setup(slackId) {
+        return setupSlackIntegration(this, slackId);
+    }
+}
+export default SlackIntegrationClient;

package/dist/esm/integration/slack/v1.d.ts

@@ -0,0 +1,67 @@
+export function listSlackIntegrations(client: ChatBotKitClient, request?: SlackIntegrationListRequest | undefined): ResponsePromise<SlackIntegrationListResponse, SlackIntegrationListStreamType>;
+export function fetchSlackIntegration(client: ChatBotKitClient, slackId: string): Promise<SlackIntegrationFetchResponse>;
+export function createSlackIntegration(client: ChatBotKitClient, request: SlackIntegrationCreateRequest): Promise<SlackIntegrationCreateResponse>;
+export function updateSlackIntegration(client: ChatBotKitClient, slackId: string, request: SlackIntegrationUpdateRequest): Promise<SlackIntegrationUpdateResponse>;
+export function deleteSlackIntegration(client: ChatBotKitClient, slackId: string): Promise<SlackIntegrationDeleteResponse>;
+export function setupSlackIntegration(client: ChatBotKitClient, slackId: string): Promise<SlackIntegrationSetupResponse>;
+export type ChatBotKitClient = import('../../client.js').ChatBotKitClient;
+export type ResponsePromise<T, U> = import('../../client.js').ResponsePromise<T, U>;
+export type BotRef = {
+    botId?: string;
+};
+export type BotConfig = {
+    backstory?: string;
+    model?: string;
+    datasetId?: string;
+    skillsetId?: string;
+    privacy?: boolean;
+    moderation?: boolean;
+};
+export type BotRefOrConfig = BotRef | BotConfig;
+export type SlackIntegrationOptions = BotRefOrConfig & {
+    name?: string;
+    description?: string;
+    signingSecret?: string;
+    botToken?: string;
+    visibleMessages?: number;
+    sessionDuration?: number;
+    meta?: Record<string, any>;
+};
+export type SlackIntegrationInstance = SlackIntegrationOptions & {
+    id: string;
+    createdAt: number;
+    updatedAt: number;
+};
+export type SlackIntegrationListRequest = {
+    cursor?: string;
+    order?: 'desc' | 'asc';
+    take?: number;
+    meta?: Record<string, string>;
+};
+export type SlackIntegrationListResponse = {
+    items: SlackIntegrationInstance[];
+};
+export type SlackIntegrationListStreamItem = {
+    type: 'item';
+    data: SlackIntegrationInstance;
+};
+export type SlackIntegrationListStreamType = SlackIntegrationListStreamItem;
+export type SlackIntegrationFetchResponse = SlackIntegrationInstance & {};
+export type SlackIntegrationCreateRequest = SlackIntegrationOptions & {
+    model?: import('../../model/v1.js').Model;
+};
+export type SlackIntegrationCreateResponse = {
+    id: string;
+};
+export type SlackIntegrationUpdateRequest = SlackIntegrationOptions & {
+    model?: import('../../model/v1.js').Model;
+};
+export type SlackIntegrationUpdateResponse = {
+    id: string;
+};
+export type SlackIntegrationDeleteResponse = {
+    id: string;
+};
+export type SlackIntegrationSetupResponse = {
+    id: string;
+};

package/dist/esm/integration/slack/v1.js

@@ -0,0 +1,45 @@
+import { buildModelString } from '../../model/v1.js';
+export function listSlackIntegrations(client, request) {
+    let url = `/api/v1/integration/slack/list`;
+    const response = client.clientFetch(url, { query: request });
+    return response;
+}
+export async function fetchSlackIntegration(client, slackId) {
+    const url = `/api/v1/integration/slack/${slackId}/fetch`;
+    const response = await client.clientFetch(url);
+    return response;
+}
+export async function createSlackIntegration(client, request) {
+    const url = `/api/v1/integration/slack/create`;
+    const response = await client.clientFetch(url, {
+        record: {
+            ...request,
+            model: request.model ? buildModelString(request.model) : undefined,
+        },
+    });
+    return response;
+}
+export async function updateSlackIntegration(client, slackId, request) {
+    const url = `/api/v1/integration/slack/${slackId}/update`;
+    const response = await client.clientFetch(url, {
+        record: {
+            ...request,
+            model: request.model ? buildModelString(request.model) : undefined,
+        },
+    });
+    return response;
+}
+export async function deleteSlackIntegration(client, slackId) {
+    const url = `/api/v1/integration/slack/${slackId}/delete`;
+    const response = await client.clientFetch(url, {
+        record: {},
+    });
+    return response;
+}
+export async function setupSlackIntegration(client, slackId) {
+    const url = `/api/v1/integration/slack/${slackId}/setup`;
+    const response = await client.clientFetch(url, {
+        record: {},
+    });
+    return response;
+}

package/dist/esm/integration/support/index.d.ts

@@ -0,0 +1,10 @@
+export class SupportIntegrationClient extends ChatBotKitClient {
+    list(request?: import("./v1.js").SupportIntegrationListRequest | undefined): ResponsePromise<import('./v1.js').SupportIntegrationListResponse, import('./v1.js').SupportIntegrationListStreamType>;
+    fetch(supportId: string): Promise<import('./v1.js').SupportIntegrationFetchResponse>;
+    create(request: import('./v1.js').SupportIntegrationCreateRequest): Promise<import('./v1.js').SupportIntegrationCreateResponse>;
+    update(supportId: string, request: import('./v1.js').SupportIntegrationUpdateRequest): Promise<import('./v1.js').SupportIntegrationUpdateResponse>;
+    delete(supportId: string): Promise<import('./v1.js').SupportIntegrationDeleteResponse>;
+}
+export default SupportIntegrationClient;
+export type ResponsePromise<T, U> = import('../../client.js').ResponsePromise<T, U>;
+import { ChatBotKitClient } from '../../client.js';

package/dist/esm/integration/support/index.js

@@ -0,0 +1,23 @@
+import { ChatBotKitClient } from '../../client.js';
+import { createSupportIntegration, deleteSupportIntegration, fetchSupportIntegration, listSupportIntegrations, updateSupportIntegration, } from './v1.js';
+export class SupportIntegrationClient extends ChatBotKitClient {
+    constructor(options) {
+        super(options);
+    }
+    list(request) {
+        return listSupportIntegrations(this, request);
+    }
+    fetch(supportId) {
+        return fetchSupportIntegration(this, supportId);
+    }
+    create(request) {
+        return createSupportIntegration(this, request);
+    }
+    update(supportId, request) {
+        return updateSupportIntegration(this, supportId, request);
+    }
+    delete(supportId) {
+        return deleteSupportIntegration(this, supportId);
+    }
+}
+export default SupportIntegrationClient;

package/dist/esm/integration/support/v1.d.ts

@@ -0,0 +1,49 @@
+export function listSupportIntegrations(client: ChatBotKitClient, request?: SupportIntegrationListRequest | undefined): ResponsePromise<SupportIntegrationListResponse, SupportIntegrationListStreamType>;
+export function fetchSupportIntegration(client: ChatBotKitClient, supportId: string): Promise<SupportIntegrationFetchResponse>;
+export function createSupportIntegration(client: ChatBotKitClient, request: SupportIntegrationCreateRequest): Promise<SupportIntegrationCreateResponse>;
+export function updateSupportIntegration(client: ChatBotKitClient, supportId: string, request: SupportIntegrationUpdateRequest): Promise<SupportIntegrationUpdateResponse>;
+export function deleteSupportIntegration(client: ChatBotKitClient, supportId: string): Promise<SupportIntegrationDeleteResponse>;
+export type ChatBotKitClient = import('../../client.js').ChatBotKitClient;
+export type ResponsePromise<T, U> = import('../../client.js').ResponsePromise<T, U>;
+export type SupportIntegrationOptions = {
+    name?: string;
+    description?: string;
+    botId?: string;
+    email?: string;
+    syncSchedule?: string;
+    expiresIn?: number;
+    meta?: Record<string, any>;
+};
+export type SupportInegrationInstance = SupportIntegrationOptions & {
+    id: string;
+    createdAt: number;
+    updatedAt: number;
+};
+export type SupportIntegrationListRequest = {
+    cursor?: string;
+    order?: 'desc' | 'asc';
+    take?: number;
+    meta?: Record<string, string>;
+};
+export type SupportIntegrationListResponse = {
+    items: SupportInegrationInstance[];
+};
+export type SupportIntegrationListStreamItem = {
+    type: 'item';
+    data: SupportInegrationInstance;
+};
+export type SupportIntegrationListStreamType = SupportIntegrationListStreamItem;
+export type SupportIntegrationFetchResponse = SupportInegrationInstance & {};
+export type SupportIntegrationCreateRequest = SupportIntegrationOptions & {
+    botId: string;
+};
+export type SupportIntegrationCreateResponse = {
+    id: string;
+};
+export type SupportIntegrationUpdateRequest = SupportIntegrationOptions & {};
+export type SupportIntegrationUpdateResponse = {
+    id: string;
+};
+export type SupportIntegrationDeleteResponse = {
+    id: string;
+};

package/dist/esm/integration/support/v1.js

@@ -0,0 +1,35 @@
+export function listSupportIntegrations(client, request) {
+    let url = `/api/v1/integration/support/list`;
+    const response = client.clientFetch(url, { query: request });
+    return response;
+}
+export async function fetchSupportIntegration(client, supportId) {
+    const url = `/api/v1/integration/support/${supportId}/fetch`;
+    const response = await client.clientFetch(url);
+    return response;
+}
+export async function createSupportIntegration(client, request) {
+    const url = `/api/v1/integration/support/create`;
+    const response = await client.clientFetch(url, {
+        record: {
+            ...request,
+        },
+    });
+    return response;
+}
+export async function updateSupportIntegration(client, supportId, request) {
+    const url = `/api/v1/integration/support/${supportId}/update`;
+    const response = await client.clientFetch(url, {
+        record: {
+            ...request,
+        },
+    });
+    return response;
+}
+export async function deleteSupportIntegration(client, supportId) {
+    const url = `/api/v1/integration/support/${supportId}/delete`;
+    const response = await client.clientFetch(url, {
+        record: {},
+    });
+    return response;
+}

package/dist/esm/integration/telegram/index.d.ts

@@ -0,0 +1,11 @@
+export class TelegramIntegrationClient extends ChatBotKitClient {
+    list(request?: import("./v1.js").TelegramIntegrationListRequest | undefined): ResponsePromise<import('./v1.js').TelegramIntegrationListResponse, import('./v1.js').TelegramIntegrationListStreamType>;
+    fetch(telegramId: string): Promise<import('./v1.js').TelegramIntegrationFetchResponse>;
+    create(request: import('./v1.js').TelegramIntegrationCreateRequest): Promise<import('./v1.js').TelegramIntegrationCreateResponse>;
+    update(telegramId: string, request: import('./v1.js').TelegramIntegrationUpdateRequest): Promise<import('./v1.js').TelegramIntegrationUpdateResponse>;
+    delete(telegramId: string): Promise<import('./v1.js').TelegramIntegrationDeleteResponse>;
+    setup(telegramId: string): Promise<import('./v1.js').TelegramIntegrationSetupResponse>;
+}
+export default TelegramIntegrationClient;
+export type ResponsePromise<T, U> = import('../../client.js').ResponsePromise<T, U>;
+import { ChatBotKitClient } from '../../client.js';

package/dist/esm/integration/telegram/index.js

@@ -0,0 +1,26 @@
+import { ChatBotKitClient } from '../../client.js';
+import { createTelegramIntegration, deleteTelegramIntegration, fetchTelegramIntegration, listTelegramIntegrations, setupTelegramIntegration, updateTelegramIntegration, } from './v1.js';
+export class TelegramIntegrationClient extends ChatBotKitClient {
+    constructor(options) {
+        super(options);
+    }
+    list(request) {
+        return listTelegramIntegrations(this, request);
+    }
+    fetch(telegramId) {
+        return fetchTelegramIntegration(this, telegramId);
+    }
+    create(request) {
+        return createTelegramIntegration(this, request);
+    }
+    update(telegramId, request) {
+        return updateTelegramIntegration(this, telegramId, request);
+    }
+    delete(telegramId) {
+        return deleteTelegramIntegration(this, telegramId);
+    }
+    setup(telegramId) {
+        return setupTelegramIntegration(this, telegramId);
+    }
+}
+export default TelegramIntegrationClient;

package/dist/esm/integration/telegram/v1.d.ts

@@ -0,0 +1,65 @@
+export function listTelegramIntegrations(client: ChatBotKitClient, request?: TelegramIntegrationListRequest | undefined): ResponsePromise<TelegramIntegrationListResponse, TelegramIntegrationListStreamType>;
+export function fetchTelegramIntegration(client: ChatBotKitClient, telegramId: string): Promise<TelegramIntegrationFetchResponse>;
+export function createTelegramIntegration(client: ChatBotKitClient, request: TelegramIntegrationCreateRequest): Promise<TelegramIntegrationCreateResponse>;
+export function updateTelegramIntegration(client: ChatBotKitClient, telegramId: string, request: TelegramIntegrationUpdateRequest): Promise<TelegramIntegrationUpdateResponse>;
+export function deleteTelegramIntegration(client: ChatBotKitClient, telegramId: string): Promise<TelegramIntegrationDeleteResponse>;
+export function setupTelegramIntegration(client: ChatBotKitClient, telegramId: string): Promise<TelegramIntegrationSetupResponse>;
+export type ChatBotKitClient = import('../../client.js').ChatBotKitClient;
+export type ResponsePromise<T, U> = import('../../client.js').ResponsePromise<T, U>;
+export type BotRef = {
+    botId?: string;
+};
+export type BotConfig = {
+    backstory?: string;
+    model?: string;
+    datasetId?: string;
+    skillsetId?: string;
+    privacy?: boolean;
+    moderation?: boolean;
+};
+export type BotRefOrConfig = BotRef | BotConfig;
+export type TelegramIntegrationOptions = BotRefOrConfig & {
+    name?: string;
+    description?: string;
+    botToken?: string;
+    sessionDuration?: number;
+    meta?: Record<string, any>;
+};
+export type TelegramIntegrationInstance = TelegramIntegrationOptions & {
+    id: string;
+    createdAt: number;
+    updatedAt: number;
+};
+export type TelegramIntegrationListRequest = {
+    cursor?: string;
+    order?: 'desc' | 'asc';
+    take?: number;
+    meta?: Record<string, string>;
+};
+export type TelegramIntegrationListResponse = {
+    items: TelegramIntegrationInstance[];
+};
+export type TelegramIntegrationListStreamItem = {
+    type: 'item';
+    data: TelegramIntegrationInstance;
+};
+export type TelegramIntegrationListStreamType = TelegramIntegrationListStreamItem;
+export type TelegramIntegrationFetchResponse = TelegramIntegrationInstance & {};
+export type TelegramIntegrationCreateRequest = TelegramIntegrationOptions & {
+    model?: import('../../model/v1.js').Model;
+};
+export type TelegramIntegrationCreateResponse = {
+    id: string;
+};
+export type TelegramIntegrationUpdateRequest = TelegramIntegrationOptions & {
+    model?: import('../../model/v1.js').Model;
+};
+export type TelegramIntegrationUpdateResponse = {
+    id: string;
+};
+export type TelegramIntegrationDeleteResponse = {
+    id: string;
+};
+export type TelegramIntegrationSetupResponse = {
+    id: string;
+};

package/dist/esm/integration/telegram/v1.js

@@ -0,0 +1,45 @@
+import { buildModelString } from '../../model/v1.js';
+export function listTelegramIntegrations(client, request) {
+    let url = `/api/v1/integration/telegram/list`;
+    const response = client.clientFetch(url, { query: request });
+    return response;
+}
+export async function fetchTelegramIntegration(client, telegramId) {
+    const url = `/api/v1/integration/telegram/${telegramId}/fetch`;
+    const response = await client.clientFetch(url);
+    return response;
+}
+export async function createTelegramIntegration(client, request) {
+    const url = `/api/v1/integration/telegram/create`;
+    const response = await client.clientFetch(url, {
+        record: {
+            ...request,
+            model: request.model ? buildModelString(request.model) : undefined,
+        },
+    });
+    return response;
+}
+export async function updateTelegramIntegration(client, telegramId, request) {
+    const url = `/api/v1/integration/telegram/${telegramId}/update`;
+    const response = await client.clientFetch(url, {
+        record: {
+            ...request,
+            model: request.model ? buildModelString(request.model) : undefined,
+        },
+    });
+    return response;
+}
+export async function deleteTelegramIntegration(client, telegramId) {
+    const url = `/api/v1/integration/telegram/${telegramId}/delete`;
+    const response = await client.clientFetch(url, {
+        record: {},
+    });
+    return response;
+}
+export async function setupTelegramIntegration(client, telegramId) {
+    const url = `/api/v1/integration/telegram/${telegramId}/setup`;
+    const response = await client.clientFetch(url, {
+        record: {},
+    });
+    return response;
+}

package/dist/esm/integration/whatsapp/v1.d.ts

@@ -30,6 +30,7 @@ export type WhatsAppIntegrationInstance = WhatsAppIntegrationOptions & {
     id: string;
     createdAt: number;
     updatedAt: number;
+    verifyToken: string;
 };
 export type WhatsAppIntegrationListRequest = {
     cursor?: string;

package/dist/esm/integration/widget/v1.d.ts

@@ -8,6 +8,27 @@ export type ResponsePromise<T, U> = import('../../client.js').ResponsePromise<T,
 export type WidgetIntegrationOptions = {
     name?: string;
     description?: string;
+    theme?: string;
+    layout?: string;
+    title?: string;
+    intro?: string;
+    initial?: string;
+    placeholder?: string;
+    language?: string;
+    origin?: string;
+    stream?: boolean;
+    verbose?: boolean;
+    tools?: boolean;
+    unfurl?: boolean;
+    autoScroll?: boolean;
+    startFirst?: boolean;
+    contactCollection?: boolean;
+    exportConversation?: boolean;
+    restartConversation?: boolean;
+    maxsimize?: boolean;
+    messagePeek?: boolean;
+    poweredBy?: boolean;
+    sessionDuration?: number;
     meta?: Record<string, any>;
 };
 export type WidgetInegrationInstance = WidgetIntegrationOptions & {

package/dist/esm/skillset/v1.d.ts

@@ -8,6 +8,7 @@ export type ResponsePromise<T, U> = import('../client.js').ResponsePromise<T, U>
 export type SkillsetOptions = {
     name?: string;
     description?: string;
+    visibility?: 'public' | 'private';
     meta?: Record<string, any>;
 };
 export type SkillsetInstance = SkillsetOptions & {

package/dist/esm/usage/index.d.ts

@@ -1,5 +1,7 @@
 export class UsageClient extends ChatBotKitClient {
+    series: UsageSeriesClient;
     fetch(): Promise<import('./v1.js').UsageFetchResponse>;
 }
 export default UsageClient;
 import { ChatBotKitClient } from '../client.js';
+import { UsageSeriesClient } from './series/index.js';

package/dist/esm/usage/index.js

@@ -1,8 +1,10 @@
 import { ChatBotKitClient } from '../client.js';
+import { UsageSeriesClient } from './series/index.js';
 import { fetchUsage } from './v1.js';
 export class UsageClient extends ChatBotKitClient {
     constructor(options) {
         super(options);
+        this.series = new UsageSeriesClient(options);
     }
     fetch() {
         return fetchUsage(this);

package/dist/esm/usage/series/index.d.ts

@@ -0,0 +1,5 @@
+export class UsageSeriesClient extends ChatBotKitClient {
+    fetch(): Promise<import('./v1.js').UsageSeriesFetchResponse>;
+}
+export default UsageSeriesClient;
+import { ChatBotKitClient } from '../../client.js';

package/dist/esm/usage/series/index.js

@@ -0,0 +1,11 @@
+import { ChatBotKitClient } from '../../client.js';
+import { fetchUsageSeries } from './v1.js';
+export class UsageSeriesClient extends ChatBotKitClient {
+    constructor(options) {
+        super(options);
+    }
+    fetch() {
+        return fetchUsageSeries(this);
+    }
+}
+export default UsageSeriesClient;

package/dist/esm/usage/series/v1.d.ts

@@ -0,0 +1,18 @@
+export function fetchUsageSeries(client: ChatBotKitClient): Promise<UsageSeriesFetchResponse>;
+export type ChatBotKitClient = import('../../client.js').ChatBotKitClient;
+export type UsageSeriesOptions = {
+    tokens: {
+        date: number;
+        total: number;
+    }[];
+    conversations: {
+        date: number;
+        total: number;
+    }[];
+    messages: {
+        date: number;
+        total: number;
+    }[];
+};
+export type UsageSeriesInstance = UsageSeriesOptions & {};
+export type UsageSeriesFetchResponse = UsageSeriesInstance & {};

package/dist/esm/usage/series/v1.js

@@ -0,0 +1,5 @@
+export async function fetchUsageSeries(client) {
+    const url = `/api/v1/usage/fetch`;
+    const response = await client.clientFetch(url);
+    return response;
+}

package/dist/esm/usage/v1.d.ts

@@ -3,6 +3,7 @@ export type ChatBotKitClient = import('../client.js').ChatBotKitClient;
 export type UsageOptions = {
     tokens: number;
     conversations: number;
+    messages: number;
 };
 export type UsageInstance = UsageOptions & {};
 export type UsageFetchResponse = UsageInstance & {};