@chatbotkit/sdk 1.18.3 → 1.20.0

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

@@ -1,66 +1,42 @@
-export function listBots(client: ChatBotKitClient, request?: BotListRequest | undefined): ResponsePromise<BotListResponse, BotListStreamType>;
+export function listBots(client: ChatBotKitClient, request?: BotListRequest): ResponsePromise<BotListResponse, BotListStreamType>;
 export function fetchBot(client: ChatBotKitClient, botId: string): ResponsePromise<BotFetchResponse, never>;
 export function createBot(client: ChatBotKitClient, request: BotCreateRequest): Promise<BotCreateResponse>;
 export function updateBot(client: ChatBotKitClient, botId: string, request: BotUpdateRequest): Promise<BotUpdateResponse>;
 export function deleteBot(client: ChatBotKitClient, botId: string): Promise<BotDeleteResponse>;
 export function upvoteBot(client: ChatBotKitClient, botId: string, request: BotUpvoteRequest): Promise<BotUpvoteResponse>;
 export function downvoteBot(client: ChatBotKitClient, botId: string, request: BotDownvoteRequest): Promise<BotDownvoteResponse>;
-export type ChatBotKitClient = import('../client.js').ChatBotKitClient;
-export type ResponsePromise<T, U> = import('../client.js').ResponsePromise<T, U>;
-export type BotOptions = {
-    name?: string;
-    description?: string;
-    backstory?: string;
-    model?: string;
-    datasetId?: string;
-    skillsetId?: string;
-    visibility?: 'private' | 'protected' | 'public';
-    meta?: Record<string, any>;
-};
-export type BotInstance = BotOptions & {
-    id: string;
-    createdAt: number;
-    updatedAt: number;
-};
+export type ChatBotKitClient = import("../client.js").ChatBotKitClient;
+export type ResponsePromise<T, U> = import("../client.js").ResponsePromise<T, U>;
 export type BotListRequest = {
     cursor?: string;
-    order?: 'desc' | 'asc';
+    order?: "desc" | "asc";
     take?: number;
     meta?: Record<string, string>;
 };
-export type BotListResponse = {
-    items: BotInstance[];
-};
-export type BotListStreamItemType = {
-    type: 'item';
-    data: BotInstance;
-};
-export type BotListStreamType = BotListStreamItemType;
-export type BotFetchResponse = BotInstance & {};
-export type BotCreateRequest = BotOptions & {
-    model?: import('../model/v1.js').Model;
-};
-export type BotCreateResponse = {
-    id: string;
-};
-export type BotUpdateRequest = BotOptions & {
-    model?: import('../model/v1.js').Model;
-};
-export type BotUpdateResponse = {
-    id: string;
-};
-export type BotDeleteResponse = {
-    id: string;
-};
-export type BotUpvoteRequest = {
-    value?: number;
-};
-export type BotUpvoteResponse = {
-    id: string;
-};
-export type BotDownvoteRequest = {
-    value?: number;
-};
-export type BotDownvoteResponse = {
-    id: string;
-};
+export type BotListResponse = import("../types/api/v1.js").operations["listBots"]["responses"]["200"]["content"]["application/json"];
+export type BotListStreamType = import("../types/api/v1.js").operations["listBots"]["responses"]["200"]["content"]["application/jsonl"];
+export type BotFetchResponse = import("../types/api/v1.js").operations["fetchBot"]["responses"]["200"]["content"]["application/json"];
+export type BotCreateRequestBody = import("../types/api/v1.js").operations["createBot"]["requestBody"]["content"]["application/json"];
+export type BotCreateRequest = Omit<BotCreateRequestBody, "model"> & {
+    model?: import("../model/v1.js").Model;
+};
+export type BotCreateResponseBody = import("../types/api/v1.js").operations["createBot"]["responses"]["200"]["content"]["application/json"];
+export type BotCreateResponse = BotCreateResponseBody;
+export type BotUpdateRequestBody = import("../types/api/v1.js").operations["updateBot"]["requestBody"]["content"]["application/json"];
+export type BotUpdateRequest = Omit<BotUpdateRequestBody, "model"> & {
+    model?: import("../model/v1.js").Model;
+};
+export type BotUpdateResponseBody = import("../types/api/v1.js").operations["updateBot"]["responses"]["200"]["content"]["application/json"];
+export type BotUpdateResponse = BotUpdateResponseBody;
+export type BotDeleteRequestBody = import("../types/api/v1.js").operations["deleteBot"]["requestBody"]["content"]["application/json"];
+export type BotDeleteRequest = BotDeleteRequestBody;
+export type BotDeleteResponseBody = import("../types/api/v1.js").operations["deleteBot"]["responses"]["200"]["content"]["application/json"];
+export type BotDeleteResponse = BotDeleteResponseBody;
+export type BotUpvoteRequestBody = import("../types/api/v1.js").operations["upvoteBot"]["requestBody"]["content"]["application/json"];
+export type BotUpvoteRequest = BotUpvoteRequestBody;
+export type BotUpvoteResponseBody = import("../types/api/v1.js").operations["upvoteBot"]["responses"]["200"]["content"]["application/json"];
+export type BotUpvoteResponse = BotUpvoteResponseBody;
+export type BotDownvoteRequestBody = import("../types/api/v1.js").operations["downvoteBot"]["requestBody"]["content"]["application/json"];
+export type BotDownvoteRequest = BotDownvoteRequestBody;
+export type BotDownvoteResponseBody = import("../types/api/v1.js").operations["downvoteBot"]["responses"]["200"]["content"]["application/json"];
+export type BotDownvoteResponse = BotDownvoteResponseBody;

package/dist/esm/bot/v1.js

@@ -40,7 +40,6 @@ export async function upvoteBot(client, botId, request) {
     const url = `/api/v1/bot/${botId}/upvote`;
     const response = await client.clientFetch(url, {
         record: {
-            value: 100,
             ...request,
         },
     });
@@ -50,7 +49,6 @@ export async function downvoteBot(client, botId, request) {
     const url = `/api/v1/bot/${botId}/downvote`;
     const response = await client.clientFetch(url, {
         record: {
-            value: -100,
             ...request,
         },
     });

package/dist/esm/buffer.js

@@ -1,8 +1,9 @@
 export function getBuffer(buffer) {
     if (typeof buffer === 'string') {
-        return new TextEncoder().encode(buffer);
+        return new TextEncoder().encode(buffer).buffer;
     }
-    else {
-        return new Uint8Array(buffer);
+    if (buffer instanceof ArrayBuffer) {
+        return buffer;
     }
+    return buffer.buffer;
 }

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

@@ -0,0 +1,7 @@
+export class ChannelClient extends ChatBotKitClient {
+    publish(channelId: string, request: import("./v1.js").ChannelPublishRequest): Promise<import("./v1.js").ChannelPublishResponse>;
+    subscribe(channelId: string, request?: import("./v1.js").ChannelSubscribeRequest): ResponsePromise<never, import("./v1.js").ChannelSubscribeStreamType>;
+}
+export default ChannelClient;
+export type ResponsePromise<T, U> = import("../client.js").ResponsePromise<T, U>;
+import { ChatBotKitClient } from '../client.js';

package/dist/esm/channel/index.js

@@ -0,0 +1,14 @@
+import { ChatBotKitClient } from '../client.js';
+import { publishChannelMessage, subscribeChannelMessages } from './v1.js';
+export class ChannelClient extends ChatBotKitClient {
+    constructor(options) {
+        super(options);
+    }
+    publish(channelId, request) {
+        return publishChannelMessage(this, channelId, request);
+    }
+    subscribe(channelId, request) {
+        return subscribeChannelMessages(this, channelId, request);
+    }
+}
+export default ChannelClient;

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

@@ -0,0 +1,12 @@
+export function publishChannelMessage(client: ChatBotKitClient, channelId: string, request: ChannelPublishRequest): Promise<ChannelPublishResponse>;
+export function subscribeChannelMessages(client: ChatBotKitClient, channelId: string, request?: ChannelSubscribeRequest): ResponsePromise<never, ChannelSubscribeStreamType>;
+export type ChatBotKitClient = import("../client.js").ChatBotKitClient;
+export type ResponsePromise<T, U> = import("../client.js").ResponsePromise<T, U>;
+export type ChannelPublishRequestBody = import("../types/api/v1.js").operations["publishChannelMessage"]["requestBody"]["content"]["application/json"];
+export type ChannelPublishRequest = ChannelPublishRequestBody;
+export type ChannelPublishResponseBody = import("../types/api/v1.js").operations["publishChannelMessage"]["responses"]["200"]["content"]["application/json"];
+export type ChannelPublishResponse = ChannelPublishResponseBody;
+export type ChannelSubscribeRequestBody = import("../types/api/v1.js").operations["subscribeChannelMessages"]["requestBody"]["content"]["application/json"];
+export type ChannelSubscribeRequest = ChannelSubscribeRequestBody;
+export type ChannelSubscribeResponseBody = import("../types/api/v1.js").operations["subscribeChannelMessages"]["responses"]["200"]["content"]["application/jsonl"];
+export type ChannelSubscribeStreamType = ChannelSubscribeResponseBody;

package/dist/esm/channel/v1.js

@@ -0,0 +1,18 @@
+export async function publishChannelMessage(client, channelId, request) {
+    const url = `/api/v1/channel/${channelId}/publish`;
+    const response = await client.clientFetch(url, {
+        record: {
+            ...request,
+        },
+        endpoint: '/api/v1/channel/{channelId}/publish',
+    });
+    return response;
+}
+export function subscribeChannelMessages(client, channelId, request) {
+    const url = `/api/v1/channel/${channelId}/subscribe`;
+    const response = client.clientFetch(url, {
+        record: request || {},
+        endpoint: '/api/v1/channel/{channelId}/subscribe',
+    });
+    return response;
+}

package/dist/esm/client.d.ts

@@ -8,39 +8,39 @@ export class ResponsePromise<T, U> {
         retryDelay?: number;
         retryTimeout?: boolean;
         fetchFn?: FetchFunction;
-    }, cacheMap?: Map<string, Promise<T>> | undefined);
+    }, cacheMap?: Map<string, Promise<T>>);
     url: string | URL;
     request: {
         method: string;
         headers: Record<string, any>;
         data?: any;
-        timeout?: number | undefined;
-        retries?: number | undefined;
-        retryDelay?: number | undefined;
-        retryTimeout?: boolean | undefined;
-        fetchFn?: FetchFunction | undefined;
+        timeout?: number;
+        retries?: number;
+        retryDelay?: number;
+        retryTimeout?: boolean;
+        fetchFn?: FetchFunction;
     };
     decoder: TextDecoder;
     fetchPromise: Promise<Response> | null;
     streamPromise: Promise<Response> | null;
     cacheMap: Map<string, Promise<T>>;
     getRequest(params?: {
-        method?: string | undefined;
-        headers?: Record<string, any> | undefined;
+        method?: string;
+        headers?: Record<string, any>;
         data?: any;
-        timeout?: number | undefined;
-        retries?: number | undefined;
-        retryDelay?: number | undefined;
-        retryTimeout?: boolean | undefined;
-        fetchFn?: FetchFunction | undefined;
-    } | undefined): Promise<Response>;
+        timeout?: number;
+        retries?: number;
+        retryDelay?: number;
+        retryTimeout?: boolean;
+        fetchFn?: FetchFunction;
+    }): Promise<Response>;
     getFetchPromise(): Promise<Response>;
     getStreamPromise(): Promise<Response>;
-    then(onSuccess: (...args: any[]) => any, onFail: (...args: any[]) => any): Promise<T>;
-    catch(fn: (...args: any[]) => any): Promise<any>;
-    finally(fn: (...args: any[]) => any): Promise<Response>;
+    then<TResult1, TResult2>(onSuccess?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onFail?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<TResult1 | TResult2>;
+    catch<TResult>(fn?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): Promise<T | TResult>;
+    finally(fn?: (() => void) | undefined | null): Promise<T>;
     stream(): AsyncGenerator<U>;
-    cache(key?: string | undefined): Promise<T>;
+    cache(key?: string): Promise<T>;
     get [Symbol.toStringTag](): string;
 }
 export class ChatBotKitClient {
@@ -59,26 +59,26 @@ export class ChatBotKitClient {
     fetchFn: FetchFunction;
     cacheMap: Map<any, any>;
     clientFetch<T, U>(path: string, options?: {
-        method?: string | undefined;
-        headers?: Record<string, any> | undefined;
-        query?: Record<string, any> | undefined;
-        record?: Record<string, any> | undefined;
-        buffer?: ArrayBuffer | undefined;
+        method?: string;
+        headers?: Record<string, any>;
+        query?: Record<string, any>;
+        record?: Record<string, any>;
+        buffer?: ArrayBuffer;
         file?: {
-            name?: string | undefined;
-            type?: string | undefined;
+            name?: string;
+            type?: string;
             data: string | ArrayBuffer;
-        } | undefined;
-        external?: boolean | undefined;
-        endpoint?: string | undefined;
-        timeout?: number | undefined;
-        retries?: number | undefined;
-        retryDelay?: number | undefined;
-        retryTimeout?: boolean | undefined;
-        fetchFn?: FetchFunction | undefined;
-    } | undefined): ResponsePromise<T, U>;
+        };
+        external?: boolean;
+        endpoint?: string;
+        timeout?: number;
+        retries?: number;
+        retryDelay?: number;
+        retryTimeout?: boolean;
+        fetchFn?: FetchFunction;
+    }): ResponsePromise<T, U>;
 }
-export type FetchFunction = import('@chatbotkit/fetch').FetchFn<import('@chatbotkit/fetch').withRetryOptions & import('@chatbotkit/fetch').withTimeoutOptions>;
+export type FetchFunction = import("@chatbotkit/fetch").FetchFn<import("@chatbotkit/fetch").withRetryOptions & import("@chatbotkit/fetch").withTimeoutOptions>;
 export type ChatBotKitClientOptions = {
     secret: string;
     host?: string | undefined;

package/dist/esm/client.js

@@ -92,6 +92,7 @@ export class ResponsePromise {
             }
             else {
                 return {
+                    headers: response.headers,
                     data: await response.arrayBuffer(),
                 };
             }
@@ -99,10 +100,20 @@ export class ResponsePromise {
             .then(onSuccess, onFail);
     }
     catch(fn) {
-        return this.getFetchPromise().catch(fn);
+        return this.then(undefined, fn);
     }
     finally(fn) {
-        return this.getFetchPromise().finally(fn);
+        return this.then((value) => {
+            if (fn) {
+                fn();
+            }
+            return value;
+        }, (reason) => {
+            if (fn) {
+                fn();
+            }
+            throw reason;
+        });
     }
     async *stream() {
         const response = await this.getStreamPromise();

package/dist/esm/contact/conversation/index.d.ts

@@ -1,6 +1,6 @@
 export class ConversationClient extends ChatBotKitClient {
-    list(contactId: string, request?: import("./v1.js").ConversationListRequest | undefined): ResponsePromise<import('./v1.js').ConversationListResponse, import('./v1.js').ConversationListStreamType>;
+    list(contactId: string, request?: import("./v1.js").ConversationListRequest): ResponsePromise<import("./v1.js").ConversationListResponse, import("./v1.js").ConversationListStreamType>;
 }
 export default ConversationClient;
-export type ResponsePromise<T, U> = import('../../client.js').ResponsePromise<T, U>;
+export type ResponsePromise<T, U> = import("../../client.js").ResponsePromise<T, U>;
 import { ChatBotKitClient } from '../../client.js';

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

@@ -1,34 +1,11 @@
-export function listConversations(client: ChatBotKitClient, contactId: string, request?: ConversationListRequest | undefined): ResponsePromise<ConversationListResponse, ConversationListStreamType>;
-export type ChatBotKitClient = import('../../client.js').ChatBotKitClient;
-export type ResponsePromise<T, U> = import('../../client.js').ResponsePromise<T, U>;
-export type ConversationOptions = {
-    name?: string;
-    description?: string;
-    contactId?: string;
-    taskId?: string;
-    botId?: string;
-    backstory?: string;
-    model?: string;
-    datasetId?: string;
-    skillsetId?: string;
-    meta?: Record<string, any>;
-};
-export type ConversationInstance = ConversationOptions & {
-    id: string;
-    createdAt: number;
-    updatedAt: number;
-};
+export function listConversations(client: ChatBotKitClient, contactId: string, request?: ConversationListRequest): ResponsePromise<ConversationListResponse, ConversationListStreamType>;
+export type ChatBotKitClient = import("../../client.js").ChatBotKitClient;
+export type ResponsePromise<T, U> = import("../../client.js").ResponsePromise<T, U>;
 export type ConversationListRequest = {
     cursor?: string;
-    order?: 'desc' | 'asc';
+    order?: "desc" | "asc";
     take?: number;
     meta?: Record<string, string>;
 };
-export type ConversationListResponse = {
-    items: ConversationInstance[];
-};
-export type ConversationListStreamItemType = {
-    type: 'item';
-    data: ConversationInstance;
-};
-export type ConversationListStreamType = ConversationListStreamItemType;
+export type ConversationListResponse = import("../../types/api/v1.js").operations["listContactConversations"]["responses"]["200"]["content"]["application/json"];
+export type ConversationListStreamType = import("../../types/api/v1.js").operations["listContactConversations"]["responses"]["200"]["content"]["application/jsonl"];

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

@@ -1,17 +1,19 @@
 export class ContactClient extends ChatBotKitClient {
     task: TaskClient;
+    space: SpaceClient;
     conversation: ConversationClient;
     secrets: SecretClient;
-    list(request?: import("./v1.js").ContactListRequest | undefined): ResponsePromise<import('./v1.js').ContactListResponse, import('./v1.js').ContactListStreamType>;
-    fetch(contactId: string): ResponsePromise<import('./v1.js').ContactFetchResponse, never>;
-    create(request: import('./v1.js').ContactCreateRequest): Promise<import('./v1.js').ContactCreateResponse>;
-    update(contactId: string, request: import('./v1.js').ContactUpdateRequest): Promise<import('./v1.js').ContactUpdateResponse>;
-    delete(contactId: string): Promise<import('./v1.js').ContactDeleteResponse>;
-    ensure(request: import('./v1.js').ContactEnsureRequest): Promise<import('./v1.js').ContactEnsureResponse>;
+    list(request?: import("./v1.js").ContactListRequest): ResponsePromise<import("./v1.js").ContactListResponse, import("./v1.js").ContactListStreamType>;
+    fetch(contactId: string): ResponsePromise<import("./v1.js").ContactFetchResponse, never>;
+    create(request: import("./v1.js").ContactCreateRequest): Promise<import("./v1.js").ContactCreateResponse>;
+    update(contactId: string, request: import("./v1.js").ContactUpdateRequest): Promise<import("./v1.js").ContactUpdateResponse>;
+    delete(contactId: string): Promise<import("./v1.js").ContactDeleteResponse>;
+    ensure(request: import("./v1.js").ContactEnsureRequest): Promise<import("./v1.js").ContactEnsureResponse>;
 }
 export default ContactClient;
-export type ResponsePromise<T, U> = import('../client.js').ResponsePromise<T, U>;
+export type ResponsePromise<T, U> = import("../client.js").ResponsePromise<T, U>;
 import { ChatBotKitClient } from '../client.js';
 import { TaskClient } from './task/index.js';
+import { SpaceClient } from './space/index.js';
 import { ConversationClient } from './conversation/index.js';
 import { SecretClient } from './secret/index.js';

package/dist/esm/contact/index.js

@@ -1,12 +1,14 @@
 import { ChatBotKitClient } from '../client.js';
 import { ConversationClient } from './conversation/index.js';
 import { SecretClient } from './secret/index.js';
+import { SpaceClient } from './space/index.js';
 import { TaskClient } from './task/index.js';
 import { createContact, deleteContact, ensureContact, fetchContact, listContacts, updateContact, } from './v1.js';
 export class ContactClient extends ChatBotKitClient {
     constructor(options) {
         super(options);
         this.task = new TaskClient(options);
+        this.space = new SpaceClient(options);
         this.conversation = new ConversationClient(options);
         this.secrets = new SecretClient(options);
     }

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

@@ -1,9 +1,9 @@
 export class SecretClient extends ChatBotKitClient {
-    list(contactId: string, request?: import("./v1.js").SecretListRequest | undefined): ResponsePromise<import('./v1.js').SecretListResponse, import('./v1.js').SecretListStreamType>;
-    revoke(contactId: string, secretId: string): ResponsePromise<import('./v1.js').SecretRevokeResponse, never>;
-    verify(contactId: string, secretId: string): ResponsePromise<import('./v1.js').SecretVerifyResponse, never>;
-    authenticate(contactId: string, secretId: string): ResponsePromise<import('./v1.js').SecretAuthenticateResponse, never>;
+    list(contactId: string, request?: import("./v1.js").SecretListRequest): ResponsePromise<import("./v1.js").SecretListResponse, import("./v1.js").SecretListStreamType>;
+    revoke(contactId: string, secretId: string): Promise<import("./v1.js").SecretRevokeResponse>;
+    verify(contactId: string, secretId: string): Promise<import("./v1.js").SecretVerifyResponse>;
+    authenticate(contactId: string, secretId: string): Promise<import("./v1.js").SecretAuthenticateResponse>;
 }
 export default SecretClient;
-export type ResponsePromise<T, U> = import('../../client.js').ResponsePromise<T, U>;
+export type ResponsePromise<T, U> = import("../../client.js").ResponsePromise<T, U>;
 import { ChatBotKitClient } from '../../client.js';

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

@@ -1,46 +1,26 @@
-export function listSecrets(client: ChatBotKitClient, contactId: string, request?: SecretListRequest | undefined): ResponsePromise<SecretListResponse, SecretListStreamType>;
-export function revokeSecret(client: ChatBotKitClient, contactId: string, secretId: string): ResponsePromise<SecretRevokeResponse, never>;
-export function verifySecret(client: ChatBotKitClient, contactId: string, secretId: string): ResponsePromise<SecretVerifyResponse, never>;
-export function authenticateSecret(client: ChatBotKitClient, contactId: string, secretId: string): ResponsePromise<SecretAuthenticateResponse, never>;
-export type ChatBotKitClient = import('../../client.js').ChatBotKitClient;
-export type ResponsePromise<T, U> = import('../../client.js').ResponsePromise<T, U>;
-export type SecretOptions = {
-    name?: string;
-    description?: string;
-    type?: string;
-    meta?: Record<string, any>;
-};
-export type SecretInstance = SecretOptions & {
-    id: string;
-    createdAt: number;
-    updatedAt: number;
-};
+export function listSecrets(client: ChatBotKitClient, contactId: string, request?: SecretListRequest): ResponsePromise<SecretListResponse, SecretListStreamType>;
+export function revokeSecret(client: ChatBotKitClient, contactId: string, secretId: string): Promise<SecretRevokeResponse>;
+export function verifySecret(client: ChatBotKitClient, contactId: string, secretId: string): Promise<SecretVerifyResponse>;
+export function authenticateSecret(client: ChatBotKitClient, contactId: string, secretId: string): Promise<SecretAuthenticateResponse>;
+export type ChatBotKitClient = import("../../client.js").ChatBotKitClient;
+export type ResponsePromise<T, U> = import("../../client.js").ResponsePromise<T, U>;
 export type SecretListRequest = {
     cursor?: string;
-    order?: 'desc' | 'asc';
+    order?: "desc" | "asc";
     take?: number;
     meta?: Record<string, string>;
 };
-export type SecretListResponse = {
-    items: SecretInstance[];
-};
-export type SecretListStreamItemType = {
-    type: 'item';
-    data: SecretInstance;
-};
-export type SecretListStreamType = SecretListStreamItemType;
-export type SecretRevokeResponse = {
-    id: string;
-};
-export type SecretVerifyResponse = {
-    id: string;
-    status: 'unauthenticated' | 'authenticated';
-    action?: {
-        type: 'authenticate';
-        url: string;
-    };
-};
-export type SecretAuthenticateResponse = {
-    id: string;
-    url: string;
-};
+export type SecretListResponse = import("../../types/api/v1.js").operations["listContactSecrets"]["responses"]["200"]["content"]["application/json"];
+export type SecretListStreamType = import("../../types/api/v1.js").operations["listContactSecrets"]["responses"]["200"]["content"]["application/jsonl"];
+export type SecretRevokeRequestBody = import("../../types/api/v1.js").operations["revokeContactSecret"]["requestBody"]["content"]["application/json"];
+export type SecretRevokeRequest = SecretRevokeRequestBody;
+export type SecretRevokeResponseBody = import("../../types/api/v1.js").operations["revokeContactSecret"]["responses"]["200"]["content"]["application/json"];
+export type SecretRevokeResponse = SecretRevokeResponseBody;
+export type SecretVerifyRequestBody = import("../../types/api/v1.js").operations["verifyContactSecret"]["requestBody"]["content"]["application/json"];
+export type SecretVerifyRequest = SecretVerifyRequestBody;
+export type SecretVerifyResponseBody = import("../../types/api/v1.js").operations["verifyContactSecret"]["responses"]["200"]["content"]["application/json"];
+export type SecretVerifyResponse = SecretVerifyResponseBody;
+export type SecretAuthenticateRequestBody = import("../../types/api/v1.js").operations["authenticateContactSecret"]["requestBody"]["content"]["application/json"];
+export type SecretAuthenticateRequest = SecretAuthenticateRequestBody;
+export type SecretAuthenticateResponseBody = import("../../types/api/v1.js").operations["authenticateContactSecret"]["responses"]["200"]["content"]["application/json"];
+export type SecretAuthenticateResponse = SecretAuthenticateResponseBody;

package/dist/esm/contact/secret/v1.js

@@ -3,23 +3,23 @@ export function listSecrets(client, contactId, request) {
     const response = client.clientFetch(url, { query: request });
     return response;
 }
-export function revokeSecret(client, contactId, secretId) {
+export async function revokeSecret(client, contactId, secretId) {
     const url = `/api/v1/contact/${contactId}/secret/${secretId}/revoke`;
-    const response = client.clientFetch(url, {
+    const response = await client.clientFetch(url, {
         record: {},
     });
     return response;
 }
-export function verifySecret(client, contactId, secretId) {
+export async function verifySecret(client, contactId, secretId) {
     const url = `/api/v1/contact/${contactId}/secret/${secretId}/verify`;
-    const response = client.clientFetch(url, {
+    const response = await client.clientFetch(url, {
         record: {},
     });
     return response;
 }
-export function authenticateSecret(client, contactId, secretId) {
+export async function authenticateSecret(client, contactId, secretId) {
     const url = `/api/v1/contact/${contactId}/secret/${secretId}/authenticate`;
-    const response = client.clientFetch(url, {
+    const response = await client.clientFetch(url, {
         record: {},
     });
     return response;

package/dist/esm/contact/space/index.d.ts

@@ -0,0 +1,6 @@
+export class SpaceClient extends ChatBotKitClient {
+    list(contactId: string, request?: import("./v1.js").SpaceListRequest): ResponsePromise<import("./v1.js").SpaceListResponse, import("./v1.js").SpaceListStreamType>;
+}
+export default SpaceClient;
+export type ResponsePromise<T, U> = import("../../client.js").ResponsePromise<T, U>;
+import { ChatBotKitClient } from '../../client.js';

package/dist/esm/contact/space/index.js

@@ -0,0 +1,11 @@
+import { ChatBotKitClient } from '../../client.js';
+import { listSpaces } from './v1.js';
+export class SpaceClient extends ChatBotKitClient {
+    constructor(options) {
+        super(options);
+    }
+    list(contactId, request) {
+        return listSpaces(this, contactId, request);
+    }
+}
+export default SpaceClient;

package/dist/esm/contact/space/v1.d.ts

@@ -0,0 +1,11 @@
+export function listSpaces(client: ChatBotKitClient, contactId: string, request?: SpaceListRequest): ResponsePromise<SpaceListResponse, SpaceListStreamType>;
+export type ChatBotKitClient = import("../../client.js").ChatBotKitClient;
+export type ResponsePromise<T, U> = import("../../client.js").ResponsePromise<T, U>;
+export type SpaceListRequest = {
+    cursor?: string;
+    order?: "desc" | "asc";
+    take?: number;
+    meta?: Record<string, string>;
+};
+export type SpaceListResponse = import("../../types/api/v1.js").operations["listContactSpaces"]["responses"]["200"]["content"]["application/json"];
+export type SpaceListStreamType = import("../../types/api/v1.js").operations["listContactSpaces"]["responses"]["200"]["content"]["application/jsonl"];

package/dist/esm/contact/space/v1.js

@@ -0,0 +1,5 @@
+export function listSpaces(client, contactId, request) {
+    let url = `/api/v1/contact/${contactId}/space/list`;
+    const response = client.clientFetch(url, { query: request });
+    return response;
+}

package/dist/esm/contact/task/index.d.ts

@@ -1,6 +1,6 @@
 export class TaskClient extends ChatBotKitClient {
-    list(contactId: string, request?: import("./v1.js").TaskListRequest | undefined): ResponsePromise<import('./v1.js').TaskListResponse, import('./v1.js').TaskListStreamType>;
+    list(contactId: string, request?: import("./v1.js").TaskListRequest): ResponsePromise<import("./v1.js").TaskListResponse, import("./v1.js").TaskListStreamType>;
 }
 export default TaskClient;
-export type ResponsePromise<T, U> = import('../../client.js').ResponsePromise<T, U>;
+export type ResponsePromise<T, U> = import("../../client.js").ResponsePromise<T, U>;
 import { ChatBotKitClient } from '../../client.js';

package/dist/esm/contact/task/v1.d.ts

@@ -1,30 +1,11 @@
-export function listTasks(client: ChatBotKitClient, contactId: string, request?: TaskListRequest | undefined): ResponsePromise<TaskListResponse, TaskListStreamType>;
-export type ChatBotKitClient = import('../../client.js').ChatBotKitClient;
-export type ResponsePromise<T, U> = import('../../client.js').ResponsePromise<T, U>;
-export type TaskOptions = {
-    name?: string;
-    description?: string;
-    contactId?: string;
-    botId?: string;
-    schedule?: string;
-    meta?: Record<string, any>;
-};
-export type TaskInstance = TaskOptions & {
-    id: string;
-    createdAt: number;
-    updatedAt: number;
-};
+export function listTasks(client: ChatBotKitClient, contactId: string, request?: TaskListRequest): ResponsePromise<TaskListResponse, TaskListStreamType>;
+export type ChatBotKitClient = import("../../client.js").ChatBotKitClient;
+export type ResponsePromise<T, U> = import("../../client.js").ResponsePromise<T, U>;
 export type TaskListRequest = {
     cursor?: string;
-    order?: 'desc' | 'asc';
+    order?: "desc" | "asc";
     take?: number;
     meta?: Record<string, string>;
 };
-export type TaskListResponse = {
-    items: TaskInstance[];
-};
-export type TaskListStreamItemType = {
-    type: 'item';
-    data: TaskInstance;
-};
-export type TaskListStreamType = TaskListStreamItemType;
+export type TaskListResponse = import("../../types/api/v1.js").operations["listContactTasks"]["responses"]["200"]["content"]["application/json"];
+export type TaskListStreamType = import("../../types/api/v1.js").operations["listContactTasks"]["responses"]["200"]["content"]["application/jsonl"];