@chatbotkit/sdk 1.9.1 → 1.10.0

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

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

package/dist/cjs/usage/series/v1.cjs

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchUsageSeries = void 0;
+async function fetchUsageSeries(client) {
+    const url = `/api/v1/usage/fetch`;
+    const response = await client.clientFetch(url);
+    return response;
+}
+exports.fetchUsageSeries = fetchUsageSeries;

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

@@ -0,0 +1,18 @@
+export function fetchUsageSeries(client: ChatBotKitClient): Promise<UsageSeriesFetchResponse>;
+export type ChatBotKitClient = import('../../client.cjs').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/cjs/usage/v1.d.ts

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

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

@@ -14,6 +14,7 @@ export type BotOptions = {
     model?: string;
     datasetId?: string;
     skillsetId?: string;
+    visibility?: 'public' | 'private' | 'restrictedAccessChat' | 'unrestrictedAccessChat';
     meta?: Record<string, any>;
 };
 export type BotInstance = BotOptions & {

package/dist/esm/conversation/message/v1.d.ts

@@ -7,7 +7,7 @@ export function upvoteConversationMessage(client: ChatBotKitClient, conversation
 export function downvoteConversationMessage(client: ChatBotKitClient, conversationId: string, messageId: string, request: ConversationMessageDownvoteRequest): Promise<ConversationMessageDownvoteResponse>;
 export type ChatBotKitClient = import('../../client.js').ChatBotKitClient;
 export type ResponsePromise<T, U> = import('../../client.js').ResponsePromise<T, U>;
-export type ConversationMessageType = 'user' | 'bot' | 'context' | 'instruction' | 'backstory';
+export type ConversationMessageType = 'user' | 'bot' | 'context' | 'instruction' | 'backstory' | 'activity';
 export type ConversationMessageOptions = {
     type: ConversationMessageType;
     text: string;

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

@@ -11,15 +11,17 @@ export type DatasetOptions = {
     description?: string;
     store?: string;
     recordMaxTokens?: number;
+    searchMinScore?: number;
     searchMaxRecords?: number;
     searchMaxTokens?: number;
     matchInstruction?: string;
     mismatchInstruction?: string;
+    separators?: string;
+    visibility?: 'public' | 'private';
     meta?: Record<string, any>;
 };
 export type DatasetInstance = DatasetOptions & {
     id: string;
-    store: string;
     createdAt: number;
     updatedAt: number;
 };

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

@@ -0,0 +1,11 @@
+export class DiscordIntegrationClient extends ChatBotKitClient {
+    list(request?: import("./v1.js").DiscordIntegrationListRequest | undefined): ResponsePromise<import('./v1.js').DiscordIntegrationListResponse, import('./v1.js').DiscordIntegrationListStreamType>;
+    fetch(discordId: string): Promise<import('./v1.js').DiscordIntegrationFetchResponse>;
+    create(request: import('./v1.js').DiscordIntegrationCreateRequest): Promise<import('./v1.js').DiscordIntegrationCreateResponse>;
+    update(discordId: string, request: import('./v1.js').DiscordIntegrationUpdateRequest): Promise<import('./v1.js').DiscordIntegrationUpdateResponse>;
+    delete(discordId: string): Promise<import('./v1.js').DiscordIntegrationDeleteResponse>;
+    setup(discordId: string): Promise<import('./v1.js').DiscordIntegrationSetupResponse>;
+}
+export default DiscordIntegrationClient;
+export type ResponsePromise<T, U> = import('../../client.js').ResponsePromise<T, U>;
+import { ChatBotKitClient } from '../../client.js';

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

@@ -0,0 +1,26 @@
+import { ChatBotKitClient } from '../../client.js';
+import { createDiscordIntegration, deleteDiscordIntegration, fetchDiscordIntegration, listDiscordIntegrations, setupDiscordIntegration, updateDiscordIntegration, } from './v1.js';
+export class DiscordIntegrationClient extends ChatBotKitClient {
+    constructor(options) {
+        super(options);
+    }
+    list(request) {
+        return listDiscordIntegrations(this, request);
+    }
+    fetch(discordId) {
+        return fetchDiscordIntegration(this, discordId);
+    }
+    create(request) {
+        return createDiscordIntegration(this, request);
+    }
+    update(discordId, request) {
+        return updateDiscordIntegration(this, discordId, request);
+    }
+    delete(discordId) {
+        return deleteDiscordIntegration(this, discordId);
+    }
+    setup(discordId) {
+        return setupDiscordIntegration(this, discordId);
+    }
+}
+export default DiscordIntegrationClient;

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

@@ -0,0 +1,68 @@
+export function listDiscordIntegrations(client: ChatBotKitClient, request?: DiscordIntegrationListRequest | undefined): ResponsePromise<DiscordIntegrationListResponse, DiscordIntegrationListStreamType>;
+export function fetchDiscordIntegration(client: ChatBotKitClient, discordId: string): Promise<DiscordIntegrationFetchResponse>;
+export function createDiscordIntegration(client: ChatBotKitClient, request: DiscordIntegrationCreateRequest): Promise<DiscordIntegrationCreateResponse>;
+export function updateDiscordIntegration(client: ChatBotKitClient, discordId: string, request: DiscordIntegrationUpdateRequest): Promise<DiscordIntegrationUpdateResponse>;
+export function deleteDiscordIntegration(client: ChatBotKitClient, discordId: string): Promise<DiscordIntegrationDeleteResponse>;
+export function setupDiscordIntegration(client: ChatBotKitClient, discordId: string): Promise<DiscordIntegrationSetupResponse>;
+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 DiscordIntegrationOptions = BotRefOrConfig & {
+    name?: string;
+    description?: string;
+    appId?: string;
+    botToken?: string;
+    publicKey?: string;
+    handle?: string;
+    sessionDuration?: number;
+    meta?: Record<string, any>;
+};
+export type DiscordIntegrationInstance = DiscordIntegrationOptions & {
+    id: string;
+    createdAt: number;
+    updatedAt: number;
+};
+export type DiscordIntegrationListRequest = {
+    cursor?: string;
+    order?: 'desc' | 'asc';
+    take?: number;
+    meta?: Record<string, string>;
+};
+export type DiscordIntegrationListResponse = {
+    items: DiscordIntegrationInstance[];
+};
+export type DiscordIntegrationListStreamItem = {
+    type: 'item';
+    data: DiscordIntegrationInstance;
+};
+export type DiscordIntegrationListStreamType = DiscordIntegrationListStreamItem;
+export type DiscordIntegrationFetchResponse = DiscordIntegrationInstance & {};
+export type DiscordIntegrationCreateRequest = DiscordIntegrationOptions & {
+    model?: import('../../model/v1.js').Model;
+};
+export type DiscordIntegrationCreateResponse = {
+    id: string;
+};
+export type DiscordIntegrationUpdateRequest = DiscordIntegrationOptions & {
+    model?: import('../../model/v1.js').Model;
+};
+export type DiscordIntegrationUpdateResponse = {
+    id: string;
+};
+export type DiscordIntegrationDeleteResponse = {
+    id: string;
+};
+export type DiscordIntegrationSetupResponse = {
+    id: string;
+};

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

@@ -0,0 +1,45 @@
+import { buildModelString } from '../../model/v1.js';
+export function listDiscordIntegrations(client, request) {
+    let url = `/api/v1/integration/discord/list`;
+    const response = client.clientFetch(url, { query: request });
+    return response;
+}
+export async function fetchDiscordIntegration(client, discordId) {
+    const url = `/api/v1/integration/discord/${discordId}/fetch`;
+    const response = await client.clientFetch(url);
+    return response;
+}
+export async function createDiscordIntegration(client, request) {
+    const url = `/api/v1/integration/discord/create`;
+    const response = await client.clientFetch(url, {
+        record: {
+            ...request,
+            model: request.model ? buildModelString(request.model) : undefined,
+        },
+    });
+    return response;
+}
+export async function updateDiscordIntegration(client, discordId, request) {
+    const url = `/api/v1/integration/discord/${discordId}/update`;
+    const response = await client.clientFetch(url, {
+        record: {
+            ...request,
+            model: request.model ? buildModelString(request.model) : undefined,
+        },
+    });
+    return response;
+}
+export async function deleteDiscordIntegration(client, discordId) {
+    const url = `/api/v1/integration/discord/${discordId}/delete`;
+    const response = await client.clientFetch(url, {
+        record: {},
+    });
+    return response;
+}
+export async function setupDiscordIntegration(client, discordId) {
+    const url = `/api/v1/integration/discord/${discordId}/setup`;
+    const response = await client.clientFetch(url, {
+        record: {},
+    });
+    return response;
+}

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

@@ -0,0 +1,10 @@
+export class ExtractIntegrationClient extends ChatBotKitClient {
+    list(request?: import("./v1.js").ExtractIntegrationListRequest | undefined): ResponsePromise<import('./v1.js').ExtractIntegrationListResponse, import('./v1.js').ExtractIntegrationListStreamType>;
+    fetch(extractId: string): Promise<import('./v1.js').ExtractIntegrationFetchResponse>;
+    create(request: import('./v1.js').ExtractIntegrationCreateRequest): Promise<import('./v1.js').ExtractIntegrationCreateResponse>;
+    update(extractId: string, request: import('./v1.js').ExtractIntegrationUpdateRequest): Promise<import('./v1.js').ExtractIntegrationUpdateResponse>;
+    delete(extractId: string): Promise<import('./v1.js').ExtractIntegrationDeleteResponse>;
+}
+export default ExtractIntegrationClient;
+export type ResponsePromise<T, U> = import('../../client.js').ResponsePromise<T, U>;
+import { ChatBotKitClient } from '../../client.js';

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

@@ -0,0 +1,23 @@
+import { ChatBotKitClient } from '../../client.js';
+import { createExtractIntegration, deleteExtractIntegration, fetchExtractIntegration, listExtractIntegrations, updateExtractIntegration, } from './v1.js';
+export class ExtractIntegrationClient extends ChatBotKitClient {
+    constructor(options) {
+        super(options);
+    }
+    list(request) {
+        return listExtractIntegrations(this, request);
+    }
+    fetch(extractId) {
+        return fetchExtractIntegration(this, extractId);
+    }
+    create(request) {
+        return createExtractIntegration(this, request);
+    }
+    update(extractId, request) {
+        return updateExtractIntegration(this, extractId, request);
+    }
+    delete(extractId) {
+        return deleteExtractIntegration(this, extractId);
+    }
+}
+export default ExtractIntegrationClient;

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

@@ -0,0 +1,49 @@
+export function listExtractIntegrations(client: ChatBotKitClient, request?: ExtractIntegrationListRequest | undefined): ResponsePromise<ExtractIntegrationListResponse, ExtractIntegrationListStreamType>;
+export function fetchExtractIntegration(client: ChatBotKitClient, extractId: string): Promise<ExtractIntegrationFetchResponse>;
+export function createExtractIntegration(client: ChatBotKitClient, request: ExtractIntegrationCreateRequest): Promise<ExtractIntegrationCreateResponse>;
+export function updateExtractIntegration(client: ChatBotKitClient, extractId: string, request: ExtractIntegrationUpdateRequest): Promise<ExtractIntegrationUpdateResponse>;
+export function deleteExtractIntegration(client: ChatBotKitClient, extractId: string): Promise<ExtractIntegrationDeleteResponse>;
+export type ChatBotKitClient = import('../../client.js').ChatBotKitClient;
+export type ResponsePromise<T, U> = import('../../client.js').ResponsePromise<T, U>;
+export type ExtractIntegrationOptions = {
+    name?: string;
+    description?: string;
+    botId?: string;
+    schema?: Record<string, any>;
+    syncSchedule?: string;
+    expiresIn?: number;
+    meta?: Record<string, any>;
+};
+export type ExtractInegrationInstance = ExtractIntegrationOptions & {
+    id: string;
+    createdAt: number;
+    updatedAt: number;
+};
+export type ExtractIntegrationListRequest = {
+    cursor?: string;
+    order?: 'desc' | 'asc';
+    take?: number;
+    meta?: Record<string, string>;
+};
+export type ExtractIntegrationListResponse = {
+    items: ExtractInegrationInstance[];
+};
+export type ExtractIntegrationListStreamItem = {
+    type: 'item';
+    data: ExtractInegrationInstance;
+};
+export type ExtractIntegrationListStreamType = ExtractIntegrationListStreamItem;
+export type ExtractIntegrationFetchResponse = ExtractInegrationInstance & {};
+export type ExtractIntegrationCreateRequest = ExtractIntegrationOptions & {
+    botId: string;
+};
+export type ExtractIntegrationCreateResponse = {
+    id: string;
+};
+export type ExtractIntegrationUpdateRequest = ExtractIntegrationOptions & {};
+export type ExtractIntegrationUpdateResponse = {
+    id: string;
+};
+export type ExtractIntegrationDeleteResponse = {
+    id: string;
+};

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

@@ -0,0 +1,35 @@
+export function listExtractIntegrations(client, request) {
+    let url = `/api/v1/integration/extract/list`;
+    const response = client.clientFetch(url, { query: request });
+    return response;
+}
+export async function fetchExtractIntegration(client, extractId) {
+    const url = `/api/v1/integration/extract/${extractId}/fetch`;
+    const response = await client.clientFetch(url);
+    return response;
+}
+export async function createExtractIntegration(client, request) {
+    const url = `/api/v1/integration/extract/create`;
+    const response = await client.clientFetch(url, {
+        record: {
+            ...request,
+        },
+    });
+    return response;
+}
+export async function updateExtractIntegration(client, extractId, request) {
+    const url = `/api/v1/integration/extract/${extractId}/update`;
+    const response = await client.clientFetch(url, {
+        record: {
+            ...request,
+        },
+    });
+    return response;
+}
+export async function deleteExtractIntegration(client, extractId) {
+    const url = `/api/v1/integration/extract/${extractId}/delete`;
+    const response = await client.clientFetch(url, {
+        record: {},
+    });
+    return response;
+}

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

@@ -1,10 +1,24 @@
 export class IntegrationClient extends ChatBotKitClient {
     widget: WidgetIntegrationClient;
-    sitemap: SitemapIntegrationClient;
+    slack: SlackIntegrationClient;
+    discord: DiscordIntegrationClient;
     whatsapp: WhatsAppIntegrationClient;
+    messenger: MessengerIntegrationClient;
+    telegram: TelegramIntegrationClient;
+    sitemap: SitemapIntegrationClient;
+    notion: NotionIntegrationClient;
+    support: SupportIntegrationClient;
+    extract: ExtractIntegrationClient;
 }
 export default IntegrationClient;
 import { ChatBotKitClient } from '../client.js';
 import { WidgetIntegrationClient } from './widget/index.js';
-import { SitemapIntegrationClient } from './sitemap/index.js';
+import { SlackIntegrationClient } from './slack/index.js';
+import { DiscordIntegrationClient } from './discord/index.js';
 import { WhatsAppIntegrationClient } from './whatsapp/index.js';
+import { MessengerIntegrationClient } from './messenger/index.js';
+import { TelegramIntegrationClient } from './telegram/index.js';
+import { SitemapIntegrationClient } from './sitemap/index.js';
+import { NotionIntegrationClient } from './notion/index.js';
+import { SupportIntegrationClient } from './support/index.js';
+import { ExtractIntegrationClient } from './extract/index.js';

package/dist/esm/integration/index.js

@@ -1,13 +1,27 @@
 import { ChatBotKitClient } from '../client.js';
+import { DiscordIntegrationClient } from './discord/index.js';
+import { ExtractIntegrationClient } from './extract/index.js';
+import { MessengerIntegrationClient } from './messenger/index.js';
+import { NotionIntegrationClient } from './notion/index.js';
 import { SitemapIntegrationClient } from './sitemap/index.js';
+import { SlackIntegrationClient } from './slack/index.js';
+import { SupportIntegrationClient } from './support/index.js';
+import { TelegramIntegrationClient } from './telegram/index.js';
 import { WhatsAppIntegrationClient } from './whatsapp/index.js';
 import { WidgetIntegrationClient } from './widget/index.js';
 export class IntegrationClient extends ChatBotKitClient {
     constructor(options) {
         super(options);
         this.widget = new WidgetIntegrationClient(options);
-        this.sitemap = new SitemapIntegrationClient(options);
+        this.slack = new SlackIntegrationClient(options);
+        this.discord = new DiscordIntegrationClient(options);
         this.whatsapp = new WhatsAppIntegrationClient(options);
+        this.messenger = new MessengerIntegrationClient(options);
+        this.telegram = new TelegramIntegrationClient(options);
+        this.sitemap = new SitemapIntegrationClient(options);
+        this.notion = new NotionIntegrationClient(options);
+        this.support = new SupportIntegrationClient(options);
+        this.extract = new ExtractIntegrationClient(options);
     }
 }
 export default IntegrationClient;

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

@@ -0,0 +1,11 @@
+export class MessengerIntegrationClient extends ChatBotKitClient {
+    list(request?: import("./v1.js").MessengerIntegrationListRequest | undefined): ResponsePromise<import('./v1.js').MessengerIntegrationListResponse, import('./v1.js').MessengerIntegrationListStreamType>;
+    fetch(messengerId: string): Promise<import('./v1.js').MessengerIntegrationFetchResponse>;
+    create(request: import('./v1.js').MessengerIntegrationCreateRequest): Promise<import('./v1.js').MessengerIntegrationCreateResponse>;
+    update(messengerId: string, request: import('./v1.js').MessengerIntegrationUpdateRequest): Promise<import('./v1.js').MessengerIntegrationUpdateResponse>;
+    delete(messengerId: string): Promise<import('./v1.js').MessengerIntegrationDeleteResponse>;
+    setup(messengerId: string): Promise<import('./v1.js').MessengerIntegrationSetupResponse>;
+}
+export default MessengerIntegrationClient;
+export type ResponsePromise<T, U> = import('../../client.js').ResponsePromise<T, U>;
+import { ChatBotKitClient } from '../../client.js';

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

@@ -0,0 +1,26 @@
+import { ChatBotKitClient } from '../../client.js';
+import { createMessengerIntegration, deleteMessengerIntegration, fetchMessengerIntegration, listMessengerIntegrations, setupMessengerIntegration, updateMessengerIntegration, } from './v1.js';
+export class MessengerIntegrationClient extends ChatBotKitClient {
+    constructor(options) {
+        super(options);
+    }
+    list(request) {
+        return listMessengerIntegrations(this, request);
+    }
+    fetch(messengerId) {
+        return fetchMessengerIntegration(this, messengerId);
+    }
+    create(request) {
+        return createMessengerIntegration(this, request);
+    }
+    update(messengerId, request) {
+        return updateMessengerIntegration(this, messengerId, request);
+    }
+    delete(messengerId) {
+        return deleteMessengerIntegration(this, messengerId);
+    }
+    setup(messengerId) {
+        return setupMessengerIntegration(this, messengerId);
+    }
+}
+export default MessengerIntegrationClient;

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

@@ -0,0 +1,66 @@
+export function listMessengerIntegrations(client: ChatBotKitClient, request?: MessengerIntegrationListRequest | undefined): ResponsePromise<MessengerIntegrationListResponse, MessengerIntegrationListStreamType>;
+export function fetchMessengerIntegration(client: ChatBotKitClient, messengerId: string): Promise<MessengerIntegrationFetchResponse>;
+export function createMessengerIntegration(client: ChatBotKitClient, request: MessengerIntegrationCreateRequest): Promise<MessengerIntegrationCreateResponse>;
+export function updateMessengerIntegration(client: ChatBotKitClient, messengerId: string, request: MessengerIntegrationUpdateRequest): Promise<MessengerIntegrationUpdateResponse>;
+export function deleteMessengerIntegration(client: ChatBotKitClient, messengerId: string): Promise<MessengerIntegrationDeleteResponse>;
+export function setupMessengerIntegration(client: ChatBotKitClient, messengerId: string): Promise<MessengerIntegrationSetupResponse>;
+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 MessengerIntegrationOptions = BotRefOrConfig & {
+    name?: string;
+    description?: string;
+    accessToken?: string;
+    sessionDuration?: number;
+    meta?: Record<string, any>;
+};
+export type MessengerIntegrationInstance = MessengerIntegrationOptions & {
+    id: string;
+    createdAt: number;
+    updatedAt: number;
+    verifyToken: string;
+};
+export type MessengerIntegrationListRequest = {
+    cursor?: string;
+    order?: 'desc' | 'asc';
+    take?: number;
+    meta?: Record<string, string>;
+};
+export type MessengerIntegrationListResponse = {
+    items: MessengerIntegrationInstance[];
+};
+export type MessengerIntegrationListStreamItem = {
+    type: 'item';
+    data: MessengerIntegrationInstance;
+};
+export type MessengerIntegrationListStreamType = MessengerIntegrationListStreamItem;
+export type MessengerIntegrationFetchResponse = MessengerIntegrationInstance & {};
+export type MessengerIntegrationCreateRequest = MessengerIntegrationOptions & {
+    model?: import('../../model/v1.js').Model;
+};
+export type MessengerIntegrationCreateResponse = {
+    id: string;
+};
+export type MessengerIntegrationUpdateRequest = MessengerIntegrationOptions & {
+    model?: import('../../model/v1.js').Model;
+};
+export type MessengerIntegrationUpdateResponse = {
+    id: string;
+};
+export type MessengerIntegrationDeleteResponse = {
+    id: string;
+};
+export type MessengerIntegrationSetupResponse = {
+    id: string;
+};

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

@@ -0,0 +1,45 @@
+import { buildModelString } from '../../model/v1.js';
+export function listMessengerIntegrations(client, request) {
+    let url = `/api/v1/integration/messenger/list`;
+    const response = client.clientFetch(url, { query: request });
+    return response;
+}
+export async function fetchMessengerIntegration(client, messengerId) {
+    const url = `/api/v1/integration/messenger/${messengerId}/fetch`;
+    const response = await client.clientFetch(url);
+    return response;
+}
+export async function createMessengerIntegration(client, request) {
+    const url = `/api/v1/integration/messenger/create`;
+    const response = await client.clientFetch(url, {
+        record: {
+            ...request,
+            model: request.model ? buildModelString(request.model) : undefined,
+        },
+    });
+    return response;
+}
+export async function updateMessengerIntegration(client, messengerId, request) {
+    const url = `/api/v1/integration/messenger/${messengerId}/update`;
+    const response = await client.clientFetch(url, {
+        record: {
+            ...request,
+            model: request.model ? buildModelString(request.model) : undefined,
+        },
+    });
+    return response;
+}
+export async function deleteMessengerIntegration(client, messengerId) {
+    const url = `/api/v1/integration/messenger/${messengerId}/delete`;
+    const response = await client.clientFetch(url, {
+        record: {},
+    });
+    return response;
+}
+export async function setupMessengerIntegration(client, messengerId) {
+    const url = `/api/v1/integration/messenger/${messengerId}/setup`;
+    const response = await client.clientFetch(url, {
+        record: {},
+    });
+    return response;
+}

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

@@ -0,0 +1,11 @@
+export class NotionIntegrationClient extends ChatBotKitClient {
+    list(request?: import("./v1.js").NotionIntegrationListRequest | undefined): ResponsePromise<import('./v1.js').NotionIntegrationListResponse, import('./v1.js').NotionIntegrationListStreamType>;
+    fetch(notionId: string): Promise<import('./v1.js').NotionIntegrationFetchResponse>;
+    create(request: import('./v1.js').NotionIntegrationCreateRequest): Promise<import('./v1.js').NotionIntegrationCreateResponse>;
+    update(notionId: string, request: import('./v1.js').NotionIntegrationUpdateRequest): Promise<import('./v1.js').NotionIntegrationUpdateResponse>;
+    delete(notionId: string): Promise<import('./v1.js').NotionIntegrationDeleteResponse>;
+    sync(notionId: string): Promise<import('./v1.js').NotionIntegrationSyncResponse>;
+}
+export default NotionIntegrationClient;
+export type ResponsePromise<T, U> = import('../../client.js').ResponsePromise<T, U>;
+import { ChatBotKitClient } from '../../client.js';

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

@@ -0,0 +1,26 @@
+import { ChatBotKitClient } from '../../client.js';
+import { createNotionIntegration, deleteNotionIntegration, fetchNotionIntegration, listNotionIntegrations, syncNotionIntegration, updateNotionIntegration, } from './v1.js';
+export class NotionIntegrationClient extends ChatBotKitClient {
+    constructor(options) {
+        super(options);
+    }
+    list(request) {
+        return listNotionIntegrations(this, request);
+    }
+    fetch(notionId) {
+        return fetchNotionIntegration(this, notionId);
+    }
+    create(request) {
+        return createNotionIntegration(this, request);
+    }
+    update(notionId, request) {
+        return updateNotionIntegration(this, notionId, request);
+    }
+    delete(notionId) {
+        return deleteNotionIntegration(this, notionId);
+    }
+    sync(notionId) {
+        return syncNotionIntegration(this, notionId);
+    }
+}
+export default NotionIntegrationClient;