@chatbotkit/sdk 1.9.1 → 1.11.0

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;

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;