@chatbotkit/sdk 1.17.2 → 1.17.4

package/dist/esm/conversation/v1.js

@@ -4,9 +4,9 @@ export function listConversations(client, request) {
     const response = client.clientFetch(url, { query: request });
     return response;
 }
-export async function fetchConversation(client, conversationId) {
+export function fetchConversation(client, conversationId) {
     const url = `/api/v1/conversation/${conversationId}/fetch`;
-    const response = await client.clientFetch(url, {
+    const response = client.clientFetch(url, {
         endpoint: '/api/v1/conversation/{conversationId}/fetch',
     });
     return response;

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

@@ -2,7 +2,7 @@ export class DatasetClient extends ChatBotKitClient {
     file: DatasetFileClient;
     record: DatasetRecordClient;
     list(request?: import("./v1.js").DatasetListRequest | undefined): ResponsePromise<import('./v1.js').DatasetListResponse, import('./v1.js').DatasetListStreamType>;
-    fetch(datasetId: string): Promise<import('./v1.js').DatasetFetchResponse>;
+    fetch(datasetId: string): ResponsePromise<import('./v1.js').DatasetFetchResponse, never>;
     create(request: import('./v1.js').DatasetCreateRequest): Promise<import('./v1.js').DatasetCreateResponse>;
     update(datasetId: string, request: import('./v1.js').DatasetUpdateRequest): Promise<import('./v1.js').DatasetUpdateResponse>;
     delete(datasetId: string): Promise<import('./v1.js').DatasetDeleteResponse>;

package/dist/esm/dataset/record/index.d.ts

@@ -1,6 +1,6 @@
 export class DatasetRecordClient extends ChatBotKitClient {
     list(datasetId: string, request?: import("./v1.js").DatasetRecordListRequest | undefined): ResponsePromise<import('./v1.js').DatasetRecordListResponse, import('./v1.js').DatasetRecordListStreamType>;
-    fetch(datasetId: string, recordId: string): Promise<import('./v1.js').DatasetRecordFetchResponse>;
+    fetch(datasetId: string, recordId: string): ResponsePromise<import('./v1.js').DatasetRecordFetchResponse, never>;
     create(datasetId: string, request: import('./v1.js').DatasetRecordCreateRequest): Promise<import('./v1.js').DatasetRecordCreateResponse>;
     update(datasetId: string, recordId: string, request: import('./v1.js').DatasetRecordUpdateRequest): Promise<import('./v1.js').DatasetRecordUpdateResponse>;
     delete(datasetId: string, recordId: string): Promise<import('./v1.js').DatasetRecordDeleteResponse>;

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

@@ -1,5 +1,5 @@
 export function listDatasetRecords(client: ChatBotKitClient, datasetId: string, request?: DatasetRecordListRequest | undefined): ResponsePromise<DatasetRecordListResponse, DatasetRecordListStreamType>;
-export function fetchDatasetRecord(client: ChatBotKitClient, datasetId: string, recordId: string): Promise<DatasetRecordFetchResponse>;
+export function fetchDatasetRecord(client: ChatBotKitClient, datasetId: string, recordId: string): ResponsePromise<DatasetRecordFetchResponse, never>;
 export function createDatasetRecord(client: ChatBotKitClient, datasetId: string, request: DatasetRecordCreateRequest): Promise<DatasetRecordCreateResponse>;
 export function updateDatasetRecord(client: ChatBotKitClient, datasetId: string, recordId: string, request: DatasetRecordUpdateRequest): Promise<DatasetRecordUpdateResponse>;
 export function deleteDatasetRecord(client: ChatBotKitClient, datasetId: string, recordId: string): Promise<DatasetRecordDeleteResponse>;

package/dist/esm/dataset/record/v1.js

@@ -3,9 +3,9 @@ export function listDatasetRecords(client, datasetId, request) {
     const response = client.clientFetch(url, { query: request });
     return response;
 }
-export async function fetchDatasetRecord(client, datasetId, recordId) {
+export function fetchDatasetRecord(client, datasetId, recordId) {
     const url = `/api/v1/dataset/${datasetId}/record/${recordId}/fetch`;
-    const response = await client.clientFetch(url);
+    const response = client.clientFetch(url);
     return response;
 }
 export async function createDatasetRecord(client, datasetId, request) {

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

@@ -1,5 +1,5 @@
 export function listDatasets(client: ChatBotKitClient, request?: DatasetListRequest | undefined): ResponsePromise<DatasetListResponse, DatasetListStreamType>;
-export function fetchDataset(client: ChatBotKitClient, datasetId: string): Promise<DatasetFetchResponse>;
+export function fetchDataset(client: ChatBotKitClient, datasetId: string): ResponsePromise<DatasetFetchResponse, never>;
 export function createDataset(client: ChatBotKitClient, request: DatasetCreateRequest): Promise<DatasetCreateResponse>;
 export function updateDataset(client: ChatBotKitClient, datasetId: string, request: DatasetUpdateRequest): Promise<DatasetUpdateResponse>;
 export function deleteDataset(client: ChatBotKitClient, datasetId: string): Promise<DatasetDeleteResponse>;

package/dist/esm/dataset/v1.js

@@ -3,9 +3,9 @@ export function listDatasets(client, request) {
     const response = client.clientFetch(url, { query: request });
     return response;
 }
-export async function fetchDataset(client, datasetId) {
+export function fetchDataset(client, datasetId) {
     const url = `/api/v1/dataset/${datasetId}/fetch`;
-    const response = await client.clientFetch(url);
+    const response = client.clientFetch(url);
     return response;
 }
 export async function createDataset(client, request) {

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

@@ -1,6 +1,6 @@
 export class FileClient extends ChatBotKitClient {
     list(request?: import("./v1.js").FileListRequest | undefined): ResponsePromise<import('./v1.js').FileListResponse, import('./v1.js').FileListStreamType>;
-    fetch(fileId: string): Promise<import('./v1.js').FileFetchResponse>;
+    fetch(fileId: string): ResponsePromise<import('./v1.js').FileFetchResponse, never>;
     create(request: import('./v1.js').FileCreateRequest): Promise<import('./v1.js').FileCreateResponse>;
     update(fileId: string, request: import('./v1.js').FileUpdateRequest): Promise<import('./v1.js').FileUpdateResponse>;
     delete(fileId: string): Promise<import('./v1.js').FileDeleteResponse>;

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

@@ -1,5 +1,5 @@
 export function listFiles(client: ChatBotKitClient, request?: FileListRequest | undefined): ResponsePromise<FileListResponse, FileListStreamType>;
-export function fetchFile(client: ChatBotKitClient, fileId: string): Promise<FileFetchResponse>;
+export function fetchFile(client: ChatBotKitClient, fileId: string): ResponsePromise<FileFetchResponse, never>;
 export function createFile(client: ChatBotKitClient, request: FileCreateRequest): Promise<FileCreateResponse>;
 export function updateFile(client: ChatBotKitClient, fileId: string, request: FileUpdateRequest): Promise<FileUpdateResponse>;
 export function deleteFile(client: ChatBotKitClient, fileId: string): Promise<FileDeleteResponse>;

package/dist/esm/file/v1.js

@@ -4,9 +4,9 @@ export function listFiles(client, request) {
     const response = client.clientFetch(url, { query: request });
     return response;
 }
-export async function fetchFile(client, fileId) {
+export function fetchFile(client, fileId) {
     const url = `/api/v1/file/${fileId}/fetch`;
-    const response = await client.clientFetch(url);
+    const response = client.clientFetch(url);
     return response;
 }
 export async function createFile(client, request) {

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

@@ -1,6 +1,6 @@
 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>;
+    fetch(discordId: string): ResponsePromise<import('./v1.js').DiscordIntegrationFetchResponse, never>;
     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>;

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

@@ -1,5 +1,5 @@
 export function listDiscordIntegrations(client: ChatBotKitClient, request?: DiscordIntegrationListRequest | undefined): ResponsePromise<DiscordIntegrationListResponse, DiscordIntegrationListStreamType>;
-export function fetchDiscordIntegration(client: ChatBotKitClient, discordId: string): Promise<DiscordIntegrationFetchResponse>;
+export function fetchDiscordIntegration(client: ChatBotKitClient, discordId: string): ResponsePromise<DiscordIntegrationFetchResponse, never>;
 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>;

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

@@ -4,9 +4,9 @@ export function listDiscordIntegrations(client, request) {
     const response = client.clientFetch(url, { query: request });
     return response;
 }
-export async function fetchDiscordIntegration(client, discordId) {
+export function fetchDiscordIntegration(client, discordId) {
     const url = `/api/v1/integration/discord/${discordId}/fetch`;
-    const response = await client.clientFetch(url);
+    const response = client.clientFetch(url);
     return response;
 }
 export async function createDiscordIntegration(client, request) {

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

@@ -1,6 +1,6 @@
 export class EmailIntegrationClient extends ChatBotKitClient {
     list(request?: import("./v1.js").EmailIntegrationListRequest | undefined): ResponsePromise<import('./v1.js').EmailIntegrationListResponse, import('./v1.js').EmailIntegrationListStreamType>;
-    fetch(emailId: string): Promise<import('./v1.js').EmailIntegrationFetchResponse>;
+    fetch(emailId: string): ResponsePromise<import('./v1.js').EmailIntegrationFetchResponse, never>;
     create(request: import('./v1.js').EmailIntegrationCreateRequest): Promise<import('./v1.js').EmailIntegrationCreateResponse>;
     update(emailId: string, request: import('./v1.js').EmailIntegrationUpdateRequest): Promise<import('./v1.js').EmailIntegrationUpdateResponse>;
     delete(emailId: string): Promise<import('./v1.js').EmailIntegrationDeleteResponse>;

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

@@ -1,5 +1,5 @@
 export function listEmailIntegrations(client: ChatBotKitClient, request?: EmailIntegrationListRequest | undefined): ResponsePromise<EmailIntegrationListResponse, EmailIntegrationListStreamType>;
-export function fetchEmailIntegration(client: ChatBotKitClient, emailId: string): Promise<EmailIntegrationFetchResponse>;
+export function fetchEmailIntegration(client: ChatBotKitClient, emailId: string): ResponsePromise<EmailIntegrationFetchResponse, never>;
 export function createEmailIntegration(client: ChatBotKitClient, request: EmailIntegrationCreateRequest): Promise<EmailIntegrationCreateResponse>;
 export function updateEmailIntegration(client: ChatBotKitClient, emailId: string, request: EmailIntegrationUpdateRequest): Promise<EmailIntegrationUpdateResponse>;
 export function deleteEmailIntegration(client: ChatBotKitClient, emailId: string): Promise<EmailIntegrationDeleteResponse>;

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

@@ -4,9 +4,9 @@ export function listEmailIntegrations(client, request) {
     const response = client.clientFetch(url, { query: request });
     return response;
 }
-export async function fetchEmailIntegration(client, emailId) {
+export function fetchEmailIntegration(client, emailId) {
     const url = `/api/v1/integration/email/${emailId}/fetch`;
-    const response = await client.clientFetch(url);
+    const response = client.clientFetch(url);
     return response;
 }
 export async function createEmailIntegration(client, request) {

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

@@ -1,6 +1,6 @@
 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>;
+    fetch(extractId: string): ResponsePromise<import('./v1.js').ExtractIntegrationFetchResponse, never>;
     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>;

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

@@ -1,5 +1,5 @@
 export function listExtractIntegrations(client: ChatBotKitClient, request?: ExtractIntegrationListRequest | undefined): ResponsePromise<ExtractIntegrationListResponse, ExtractIntegrationListStreamType>;
-export function fetchExtractIntegration(client: ChatBotKitClient, extractId: string): Promise<ExtractIntegrationFetchResponse>;
+export function fetchExtractIntegration(client: ChatBotKitClient, extractId: string): ResponsePromise<ExtractIntegrationFetchResponse, never>;
 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>;

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

@@ -3,9 +3,9 @@ export function listExtractIntegrations(client, request) {
     const response = client.clientFetch(url, { query: request });
     return response;
 }
-export async function fetchExtractIntegration(client, extractId) {
+export function fetchExtractIntegration(client, extractId) {
     const url = `/api/v1/integration/extract/${extractId}/fetch`;
-    const response = await client.clientFetch(url);
+    const response = client.clientFetch(url);
     return response;
 }
 export async function createExtractIntegration(client, request) {

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

@@ -1,6 +1,6 @@
 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>;
+    fetch(messengerId: string): ResponsePromise<import('./v1.js').MessengerIntegrationFetchResponse, never>;
     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>;

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

@@ -1,5 +1,5 @@
 export function listMessengerIntegrations(client: ChatBotKitClient, request?: MessengerIntegrationListRequest | undefined): ResponsePromise<MessengerIntegrationListResponse, MessengerIntegrationListStreamType>;
-export function fetchMessengerIntegration(client: ChatBotKitClient, messengerId: string): Promise<MessengerIntegrationFetchResponse>;
+export function fetchMessengerIntegration(client: ChatBotKitClient, messengerId: string): ResponsePromise<MessengerIntegrationFetchResponse, never>;
 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>;

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

@@ -4,9 +4,9 @@ export function listMessengerIntegrations(client, request) {
     const response = client.clientFetch(url, { query: request });
     return response;
 }
-export async function fetchMessengerIntegration(client, messengerId) {
+export function fetchMessengerIntegration(client, messengerId) {
     const url = `/api/v1/integration/messenger/${messengerId}/fetch`;
-    const response = await client.clientFetch(url);
+    const response = client.clientFetch(url);
     return response;
 }
 export async function createMessengerIntegration(client, request) {

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

@@ -1,6 +1,6 @@
 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>;
+    fetch(notionId: string): ResponsePromise<import('./v1.js').NotionIntegrationFetchResponse, never>;
     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>;

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

@@ -1,5 +1,5 @@
 export function listNotionIntegrations(client: ChatBotKitClient, request?: NotionIntegrationListRequest | undefined): ResponsePromise<NotionIntegrationListResponse, NotionIntegrationListStreamType>;
-export function fetchNotionIntegration(client: ChatBotKitClient, notionId: string): Promise<NotionIntegrationFetchResponse>;
+export function fetchNotionIntegration(client: ChatBotKitClient, notionId: string): ResponsePromise<NotionIntegrationFetchResponse, never>;
 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>;

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

@@ -3,9 +3,9 @@ export function listNotionIntegrations(client, request) {
     const response = client.clientFetch(url, { query: request });
     return response;
 }
-export async function fetchNotionIntegration(client, notionId) {
+export function fetchNotionIntegration(client, notionId) {
     const url = `/api/v1/integration/notion/${notionId}/fetch`;
-    const response = await client.clientFetch(url);
+    const response = client.clientFetch(url);
     return response;
 }
 export async function createNotionIntegration(client, request) {

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

@@ -1,6 +1,6 @@
 export class SitemapIntegrationClient extends ChatBotKitClient {
     list(request?: import("./v1.js").SitemapIntegrationListRequest | undefined): ResponsePromise<import('./v1.js').SitemapIntegrationListResponse, import('./v1.js').SitemapIntegrationListStreamType>;
-    fetch(sitemapId: string): Promise<import('./v1.js').SitemapIntegrationFetchResponse>;
+    fetch(sitemapId: string): ResponsePromise<import('./v1.js').SitemapIntegrationFetchResponse, never>;
     create(request: import('./v1.js').SitemapIntegrationCreateRequest): Promise<import('./v1.js').SitemapIntegrationCreateResponse>;
     update(sitemapId: string, request: import('./v1.js').SitemapIntegrationUpdateRequest): Promise<import('./v1.js').SitemapIntegrationUpdateResponse>;
     delete(sitemapId: string): Promise<import('./v1.js').SitemapIntegrationDeleteResponse>;

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

@@ -1,5 +1,5 @@
 export function listSitemapIntegrations(client: ChatBotKitClient, request?: SitemapIntegrationListRequest | undefined): ResponsePromise<SitemapIntegrationListResponse, SitemapIntegrationListStreamType>;
-export function fetchSitemapIntegration(client: ChatBotKitClient, sitemapId: string): Promise<SitemapIntegrationFetchResponse>;
+export function fetchSitemapIntegration(client: ChatBotKitClient, sitemapId: string): ResponsePromise<SitemapIntegrationFetchResponse, never>;
 export function createSitemapIntegration(client: ChatBotKitClient, request: SitemapIntegrationCreateRequest): Promise<SitemapIntegrationCreateResponse>;
 export function updateSitemapIntegration(client: ChatBotKitClient, sitemapId: string, request: SitemapIntegrationUpdateRequest): Promise<SitemapIntegrationUpdateResponse>;
 export function deleteSitemapIntegration(client: ChatBotKitClient, sitemapId: string): Promise<SitemapIntegrationDeleteResponse>;

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

@@ -3,9 +3,9 @@ export function listSitemapIntegrations(client, request) {
     const response = client.clientFetch(url, { query: request });
     return response;
 }
-export async function fetchSitemapIntegration(client, sitemapId) {
+export function fetchSitemapIntegration(client, sitemapId) {
     const url = `/api/v1/integration/sitemap/${sitemapId}/fetch`;
-    const response = await client.clientFetch(url);
+    const response = client.clientFetch(url);
     return response;
 }
 export async function createSitemapIntegration(client, request) {

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

@@ -1,6 +1,6 @@
 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>;
+    fetch(slackId: string): ResponsePromise<import('./v1.js').SlackIntegrationFetchResponse, never>;
     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>;

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

@@ -1,5 +1,5 @@
 export function listSlackIntegrations(client: ChatBotKitClient, request?: SlackIntegrationListRequest | undefined): ResponsePromise<SlackIntegrationListResponse, SlackIntegrationListStreamType>;
-export function fetchSlackIntegration(client: ChatBotKitClient, slackId: string): Promise<SlackIntegrationFetchResponse>;
+export function fetchSlackIntegration(client: ChatBotKitClient, slackId: string): ResponsePromise<SlackIntegrationFetchResponse, never>;
 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>;

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

@@ -4,9 +4,9 @@ export function listSlackIntegrations(client, request) {
     const response = client.clientFetch(url, { query: request });
     return response;
 }
-export async function fetchSlackIntegration(client, slackId) {
+export function fetchSlackIntegration(client, slackId) {
     const url = `/api/v1/integration/slack/${slackId}/fetch`;
-    const response = await client.clientFetch(url);
+    const response = client.clientFetch(url);
     return response;
 }
 export async function createSlackIntegration(client, request) {

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

@@ -1,6 +1,6 @@
 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>;
+    fetch(supportId: string): ResponsePromise<import('./v1.js').SupportIntegrationFetchResponse, never>;
     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>;

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

@@ -1,5 +1,5 @@
 export function listSupportIntegrations(client: ChatBotKitClient, request?: SupportIntegrationListRequest | undefined): ResponsePromise<SupportIntegrationListResponse, SupportIntegrationListStreamType>;
-export function fetchSupportIntegration(client: ChatBotKitClient, supportId: string): Promise<SupportIntegrationFetchResponse>;
+export function fetchSupportIntegration(client: ChatBotKitClient, supportId: string): ResponsePromise<SupportIntegrationFetchResponse, never>;
 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>;

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

@@ -3,9 +3,9 @@ export function listSupportIntegrations(client, request) {
     const response = client.clientFetch(url, { query: request });
     return response;
 }
-export async function fetchSupportIntegration(client, supportId) {
+export function fetchSupportIntegration(client, supportId) {
     const url = `/api/v1/integration/support/${supportId}/fetch`;
-    const response = await client.clientFetch(url);
+    const response = client.clientFetch(url);
     return response;
 }
 export async function createSupportIntegration(client, request) {

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

@@ -1,6 +1,6 @@
 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>;
+    fetch(telegramId: string): ResponsePromise<import('./v1.js').TelegramIntegrationFetchResponse, never>;
     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>;

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

@@ -1,5 +1,5 @@
 export function listTelegramIntegrations(client: ChatBotKitClient, request?: TelegramIntegrationListRequest | undefined): ResponsePromise<TelegramIntegrationListResponse, TelegramIntegrationListStreamType>;
-export function fetchTelegramIntegration(client: ChatBotKitClient, telegramId: string): Promise<TelegramIntegrationFetchResponse>;
+export function fetchTelegramIntegration(client: ChatBotKitClient, telegramId: string): ResponsePromise<TelegramIntegrationFetchResponse, never>;
 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>;

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

@@ -4,9 +4,9 @@ export function listTelegramIntegrations(client, request) {
     const response = client.clientFetch(url, { query: request });
     return response;
 }
-export async function fetchTelegramIntegration(client, telegramId) {
+export function fetchTelegramIntegration(client, telegramId) {
     const url = `/api/v1/integration/telegram/${telegramId}/fetch`;
-    const response = await client.clientFetch(url);
+    const response = client.clientFetch(url);
     return response;
 }
 export async function createTelegramIntegration(client, request) {

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

@@ -1,6 +1,6 @@
 export class TriggerIntegrationClient extends ChatBotKitClient {
     list(request?: import("./v1.js").TriggerIntegrationListRequest | undefined): ResponsePromise<import('./v1.js').TriggerIntegrationListResponse, import('./v1.js').TriggerIntegrationListStreamType>;
-    fetch(triggerId: string): Promise<import('./v1.js').TriggerIntegrationFetchResponse>;
+    fetch(triggerId: string): ResponsePromise<import('./v1.js').TriggerIntegrationFetchResponse, never>;
     create(request: import('./v1.js').TriggerIntegrationCreateRequest): Promise<import('./v1.js').TriggerIntegrationCreateResponse>;
     update(triggerId: string, request: import('./v1.js').TriggerIntegrationUpdateRequest): Promise<import('./v1.js').TriggerIntegrationUpdateResponse>;
     delete(triggerId: string): Promise<import('./v1.js').TriggerIntegrationDeleteResponse>;

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

@@ -1,5 +1,5 @@
 export function listTriggerIntegrations(client: ChatBotKitClient, request?: TriggerIntegrationListRequest | undefined): ResponsePromise<TriggerIntegrationListResponse, TriggerIntegrationListStreamType>;
-export function fetchTriggerIntegration(client: ChatBotKitClient, triggerId: string): Promise<TriggerIntegrationFetchResponse>;
+export function fetchTriggerIntegration(client: ChatBotKitClient, triggerId: string): ResponsePromise<TriggerIntegrationFetchResponse, never>;
 export function createTriggerIntegration(client: ChatBotKitClient, request: TriggerIntegrationCreateRequest): Promise<TriggerIntegrationCreateResponse>;
 export function updateTriggerIntegration(client: ChatBotKitClient, triggerId: string, request: TriggerIntegrationUpdateRequest): Promise<TriggerIntegrationUpdateResponse>;
 export function deleteTriggerIntegration(client: ChatBotKitClient, triggerId: string): Promise<TriggerIntegrationDeleteResponse>;

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

@@ -4,9 +4,9 @@ export function listTriggerIntegrations(client, request) {
     const response = client.clientFetch(url, { query: request });
     return response;
 }
-export async function fetchTriggerIntegration(client, triggerId) {
+export function fetchTriggerIntegration(client, triggerId) {
     const url = `/api/v1/integration/trigger/${triggerId}/fetch`;
-    const response = await client.clientFetch(url);
+    const response = client.clientFetch(url);
     return response;
 }
 export async function createTriggerIntegration(client, request) {

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

@@ -1,6 +1,6 @@
 export class WhatsAppIntegrationClient extends ChatBotKitClient {
     list(request?: import("./v1.js").WhatsAppIntegrationListRequest | undefined): ResponsePromise<import('./v1.js').WhatsAppIntegrationListResponse, import('./v1.js').WhatsAppIntegrationListStreamType>;
-    fetch(whatsappId: string): Promise<import('./v1.js').WhatsAppIntegrationFetchResponse>;
+    fetch(whatsappId: string): ResponsePromise<import('./v1.js').WhatsAppIntegrationFetchResponse, never>;
     create(request: import('./v1.js').WhatsAppIntegrationCreateRequest): Promise<import('./v1.js').WhatsAppIntegrationCreateResponse>;
     update(whatsappId: string, request: import('./v1.js').WhatsAppIntegrationUpdateRequest): Promise<import('./v1.js').WhatsAppIntegrationUpdateResponse>;
     delete(whatsappId: string): Promise<import('./v1.js').WhatsAppIntegrationDeleteResponse>;

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

@@ -1,5 +1,5 @@
 export function listWhatsAppIntegrations(client: ChatBotKitClient, request?: WhatsAppIntegrationListRequest | undefined): ResponsePromise<WhatsAppIntegrationListResponse, WhatsAppIntegrationListStreamType>;
-export function fetchWhatsAppIntegration(client: ChatBotKitClient, whatsappId: string): Promise<WhatsAppIntegrationFetchResponse>;
+export function fetchWhatsAppIntegration(client: ChatBotKitClient, whatsappId: string): ResponsePromise<WhatsAppIntegrationFetchResponse, never>;
 export function createWhatsAppIntegration(client: ChatBotKitClient, request: WhatsAppIntegrationCreateRequest): Promise<WhatsAppIntegrationCreateResponse>;
 export function updateWhatsAppIntegration(client: ChatBotKitClient, whatsappId: string, request: WhatsAppIntegrationUpdateRequest): Promise<WhatsAppIntegrationUpdateResponse>;
 export function deleteWhatsAppIntegration(client: ChatBotKitClient, whatsappId: string): Promise<WhatsAppIntegrationDeleteResponse>;

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

@@ -4,9 +4,9 @@ export function listWhatsAppIntegrations(client, request) {
     const response = client.clientFetch(url, { query: request });
     return response;
 }
-export async function fetchWhatsAppIntegration(client, whatsappId) {
+export function fetchWhatsAppIntegration(client, whatsappId) {
     const url = `/api/v1/integration/whatsapp/${whatsappId}/fetch`;
-    const response = await client.clientFetch(url);
+    const response = client.clientFetch(url);
     return response;
 }
 export async function createWhatsAppIntegration(client, request) {

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

@@ -1,6 +1,6 @@
 export class WidgetIntegrationClient extends ChatBotKitClient {
     list(request?: import("./v1.js").WidgetIntegrationListRequest | undefined): ResponsePromise<import('./v1.js').WidgetIntegrationListResponse, import('./v1.js').WidgetIntegrationListStreamType>;
-    fetch(widgetId: string): Promise<import('./v1.js').WidgetIntegrationFetchResponse>;
+    fetch(widgetId: string): ResponsePromise<import('./v1.js').WidgetIntegrationFetchResponse, never>;
     create(request: import('./v1.js').WidgetIntegrationCreateRequest): Promise<import('./v1.js').WidgetIntegrationCreateResponse>;
     update(widgetId: string, request: import('./v1.js').WidgetIntegrationUpdateRequest): Promise<import('./v1.js').WidgetIntegrationUpdateResponse>;
     delete(widgetId: string): Promise<import('./v1.js').WidgetIntegrationDeleteResponse>;

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

@@ -1,5 +1,5 @@
 export function listWidgetIntegrations(client: ChatBotKitClient, request?: WidgetIntegrationListRequest | undefined): ResponsePromise<WidgetIntegrationListResponse, WidgetIntegrationListStreamType>;
-export function fetchWidgetIntegration(client: ChatBotKitClient, widgetId: string): Promise<WidgetIntegrationFetchResponse>;
+export function fetchWidgetIntegration(client: ChatBotKitClient, widgetId: string): ResponsePromise<WidgetIntegrationFetchResponse, never>;
 export function createWidgetIntegration(client: ChatBotKitClient, request: WidgetIntegrationCreateRequest): Promise<WidgetIntegrationCreateResponse>;
 export function updateWidgetIntegration(client: ChatBotKitClient, widgetId: string, request: WidgetIntegrationUpdateRequest): Promise<WidgetIntegrationUpdateResponse>;
 export function deleteWidgetIntegration(client: ChatBotKitClient, widgetId: string): Promise<WidgetIntegrationDeleteResponse>;

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

@@ -3,9 +3,9 @@ export function listWidgetIntegrations(client, request) {
     const response = client.clientFetch(url, { query: request });
     return response;
 }
-export async function fetchWidgetIntegration(client, widgetId) {
+export function fetchWidgetIntegration(client, widgetId) {
     const url = `/api/v1/integration/widget/${widgetId}/fetch`;
-    const response = await client.clientFetch(url);
+    const response = client.clientFetch(url);
     return response;
 }
 export async function createWidgetIntegration(client, request) {

package/dist/esm/partner/user/index.d.ts

@@ -1,7 +1,7 @@
 export class PartnerUserClient extends ChatBotKitClient {
     token: PartnerUserTokenClient;
     list(request?: import("./v1.js").PartnerUserListRequest | undefined): ResponsePromise<import('./v1.js').PartnerUserListResponse, import('./v1.js').PartnerUserListStreamType>;
-    fetch(userId: string): Promise<import('./v1.js').PartnerUserFetchResponse>;
+    fetch(userId: string): ResponsePromise<import('./v1.js').PartnerUserFetchResponse, never>;
     create(request: import('./v1.js').PartnerUserCreateRequest): Promise<import('./v1.js').PartnerUserCreateResponse>;
     update(userId: string, request: import('./v1.js').PartnerUserUpdateRequest): Promise<import('./v1.js').PartnerUserUpdateResponse>;
     delete(userId: string): Promise<import('./v1.js').PartnerUserDeleteResponse>;

package/dist/esm/partner/user/v1.d.ts

@@ -1,5 +1,5 @@
 export function listPartnerUsers(client: ChatBotKitClient, request?: PartnerUserListRequest | undefined): ResponsePromise<PartnerUserListResponse, PartnerUserListStreamType>;
-export function fetchPartnerUser(client: ChatBotKitClient, userId: string): Promise<PartnerUserFetchResponse>;
+export function fetchPartnerUser(client: ChatBotKitClient, userId: string): ResponsePromise<PartnerUserFetchResponse, never>;
 export function createPartnerUser(client: ChatBotKitClient, request: PartnerUserCreateRequest): Promise<PartnerUserCreateResponse>;
 export function updatePartnerUser(client: ChatBotKitClient, userId: string, request: PartnerUserUpdateRequest): Promise<PartnerUserUpdateResponse>;
 export function deletePartnerUser(client: ChatBotKitClient, userId: string): Promise<PartnerUserDeleteResponse>;

package/dist/esm/partner/user/v1.js

@@ -3,9 +3,9 @@ export function listPartnerUsers(client, request) {
     const response = client.clientFetch(url, { query: request });
     return response;
 }
-export async function fetchPartnerUser(client, userId) {
+export function fetchPartnerUser(client, userId) {
     const url = `/api/v1/partner/user/${userId}/fetch`;
-    const response = await client.clientFetch(url);
+    const response = client.clientFetch(url);
     return response;
 }
 export async function createPartnerUser(client, request) {

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

@@ -1,6 +1,6 @@
 export class SecretClient extends ChatBotKitClient {
     list(request?: import("./v1.js").SecretListRequest | undefined): ResponsePromise<import('./v1.js').SecretListResponse, import('./v1.js').SecretListStreamType>;
-    fetch(secretId: string): Promise<import('./v1.js').SecretFetchResponse>;
+    fetch(secretId: string): ResponsePromise<import('./v1.js').SecretFetchResponse, never>;
     create(request: import('./v1.js').SecretCreateRequest): Promise<import('./v1.js').SecretCreateResponse>;
     update(secretId: string, request: import('./v1.js').SecretUpdateRequest): Promise<import('./v1.js').SecretUpdateResponse>;
     delete(secretId: string): Promise<import('./v1.js').SecretDeleteResponse>;

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

@@ -1,5 +1,5 @@
 export function listSecrets(client: ChatBotKitClient, request?: SecretListRequest | undefined): ResponsePromise<SecretListResponse, SecretListStreamType>;
-export function fetchSecret(client: ChatBotKitClient, secretId: string): Promise<SecretFetchResponse>;
+export function fetchSecret(client: ChatBotKitClient, secretId: string): ResponsePromise<SecretFetchResponse, never>;
 export function createSecret(client: ChatBotKitClient, request: SecretCreateRequest): Promise<SecretCreateResponse>;
 export function updateSecret(client: ChatBotKitClient, secretId: string, request: SecretUpdateRequest): Promise<SecretUpdateResponse>;
 export function deleteSecret(client: ChatBotKitClient, secretId: string): Promise<SecretDeleteResponse>;

package/dist/esm/secret/v1.js

@@ -3,9 +3,9 @@ export function listSecrets(client, request) {
     const response = client.clientFetch(url, { query: request });
     return response;
 }
-export async function fetchSecret(client, secretId) {
+export function fetchSecret(client, secretId) {
     const url = `/api/v1/secret/${secretId}/fetch`;
-    const response = await client.clientFetch(url);
+    const response = client.clientFetch(url);
     return response;
 }
 export async function createSecret(client, request) {

package/dist/esm/skillset/ability/index.d.ts

@@ -1,6 +1,6 @@
 export class SkillsetAbilityClient extends ChatBotKitClient {
     list(skillsetId: string, request?: import("./v1.js").SkillsetAbilityListRequest | undefined): ResponsePromise<import('./v1.js').SkillsetAbilityListResponse, import('./v1.js').SkillsetAbilityListStreamType>;
-    fetch(skillsetId: string, abilityId: string): Promise<import('./v1.js').SkillsetAbilityFetchResponse>;
+    fetch(skillsetId: string, abilityId: string): ResponsePromise<import('./v1.js').SkillsetAbilityFetchResponse, never>;
     create(skillsetId: string, request: import('./v1.js').SkillsetAbilityCreateRequest): Promise<import('./v1.js').SkillsetAbilityCreateResponse>;
     update(skillsetId: string, abilityId: string, request: import('./v1.js').SkillsetAbilityUpdateRequest): Promise<import('./v1.js').SkillsetAbilityUpdateResponse>;
     delete(skillsetId: string, abilityId: string): Promise<import('./v1.js').SkillsetAbilityDeleteResponse>;

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

@@ -1,5 +1,5 @@
 export function listSkillsetAbilities(client: ChatBotKitClient, skillsetId: string, request?: SkillsetAbilityListRequest | undefined): ResponsePromise<SkillsetAbilityListResponse, SkillsetAbilityListStreamType>;
-export function fetchSkillsetAbility(client: ChatBotKitClient, skillsetId: string, abilityId: string): Promise<SkillsetAbilityFetchResponse>;
+export function fetchSkillsetAbility(client: ChatBotKitClient, skillsetId: string, abilityId: string): ResponsePromise<SkillsetAbilityFetchResponse, never>;
 export function createSkillsetAbility(client: ChatBotKitClient, skillsetId: string, request: SkillsetAbilityCreateRequest): Promise<SkillsetAbilityCreateResponse>;
 export function updateSkillsetAbility(client: ChatBotKitClient, skillsetId: string, abilityId: string, request: SkillsetAbilityUpdateRequest): Promise<SkillsetAbilityUpdateResponse>;
 export function deleteSkillsetAbility(client: ChatBotKitClient, skillsetId: string, abilityId: string): Promise<SkillsetAbilityDeleteResponse>;

package/dist/esm/skillset/ability/v1.js

@@ -3,9 +3,9 @@ export function listSkillsetAbilities(client, skillsetId, request) {
     const response = client.clientFetch(url, { query: request });
     return response;
 }
-export async function fetchSkillsetAbility(client, skillsetId, abilityId) {
+export function fetchSkillsetAbility(client, skillsetId, abilityId) {
     const url = `/api/v1/skillset/${skillsetId}/ability/${abilityId}/fetch`;
-    const response = await client.clientFetch(url);
+    const response = client.clientFetch(url);
     return response;
 }
 export async function createSkillsetAbility(client, skillsetId, request) {