@chatbotkit/sdk 1.29.1 → 1.30.1

package/dist/cjs/types/api/v1.d.ts

@@ -4772,6 +4772,147 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/space/{spaceId}/storage/copy/{path}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Copy a file in space storage
+         * @description Copy a file from one location to another within space storage. The
+         *     source file path is specified in the URL after /copy/. The
+         *     destinationPath in the request body specifies where to copy the file.
+         *
+         */
+        post: operations["copySpaceStoragePath"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/space/{spaceId}/storage/delete/{path}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Delete a file or directory from space storage
+         * @description Delete a file or directory from space storage. The path is specified
+         *     in the URL after /delete/. If recursive is true and the path is a
+         *     directory, all files within it will be deleted.
+         *
+         */
+        post: operations["deleteSpaceStoragePath"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/space/{spaceId}/storage/download/{path}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Download a file from space storage
+         * @description Download a file from space storage. The file path is specified in the
+         *     URL after /download/. Can return either the direct file content
+         *     (default) or a presigned download URL (when Accept: application/json).
+         *
+         */
+        get: operations["downloadSpaceStoragePath"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/space/{spaceId}/storage/list/{path}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List files and directories in space storage
+         * @description List files and directories in the space's storage. Supports both flat
+         *     and recursive listing. The path is specified in the URL after /list/.
+         *     Omit the path to list the root directory.
+         *
+         */
+        get: operations["listSpaceStoragePath"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/space/{spaceId}/storage/move/{path}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Move (rename) a file in space storage
+         * @description Move a file from one location to another within space storage, or
+         *     rename a file by moving it to a new path. The source file path is
+         *     specified in the URL after /move/. The destinationPath in the request
+         *     body is the target location for the file.
+         *
+         */
+        post: operations["moveSpaceStoragePath"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/space/{spaceId}/storage/upload/{path}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Upload a file to space storage
+         * @description Upload a file to space storage. The file path is specified in the URL
+         *     after /upload/. The file can be specified either as a HTTP URL, a data
+         *     URL, a multipart/form-data, or as a raw file stream. The maximum file
+         *     size for uploads is determined dynamically based on user limits and
+         *     configuration, and may vary.
+         *
+         */
+        post: operations["uploadSpaceStoragePath"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/space/{spaceId}/update": {
         parameters: {
             query?: never;
@@ -5004,6 +5145,23 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/usage/list": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** List usage records */
+        get: operations["listUsageRecords"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/usage/series/fetch": {
         parameters: {
             query?: never;
@@ -23796,6 +23954,281 @@ export interface operations {
             };
         };
     };
+    copySpaceStoragePath: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                spaceId: string;
+                path: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    /** @description The destination file path */
+                    destinationPath: string;
+                };
+            };
+        };
+        responses: {
+            /** @description The file was copied successfully */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** @description The destination file path */
+                        path: string;
+                    };
+                };
+            };
+            /** @description An error response */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    deleteSpaceStoragePath: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                spaceId: string;
+                path: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: {
+            content: {
+                "application/json": {
+                    /**
+                     * @description Whether to delete directory contents recursively
+                     * @default false
+                     */
+                    recursive?: boolean;
+                };
+            };
+        };
+        responses: {
+            /** @description The file or directory was deleted successfully */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** @description The deleted file or directory path */
+                        path: string;
+                    };
+                };
+            };
+            /** @description An error response */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    downloadSpaceStoragePath: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                spaceId: string;
+                path: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The file was downloaded successfully */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** @description The ID of the file */
+                        id: string;
+                        /** @description The presigned URL to download the file */
+                        url: string;
+                    };
+                    "application/octet-stream": string;
+                };
+            };
+            /** @description An error response */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    listSpaceStoragePath: {
+        parameters: {
+            query?: {
+                recursive?: boolean;
+            };
+            header?: never;
+            path: {
+                spaceId: string;
+                path: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The list of files was retrieved successfully */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        items: {
+                            /** @description The ID of the file or directory */
+                            id?: string;
+                            /** @description The relative path of the file or directory */
+                            path?: string;
+                            /** @description The size of the file in bytes (0 for directories) */
+                            size?: number;
+                            /** @description The timestamp (ms) when the file was last modified */
+                            updatedAt?: number;
+                            /** @description Whether this is a directory */
+                            isDirectory?: boolean;
+                        }[];
+                        /** @description Token to use for next page of results */
+                        nextToken?: string;
+                    };
+                };
+            };
+            /** @description An error response */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    moveSpaceStoragePath: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                spaceId: string;
+                path: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    /** @description The destination file path */
+                    destinationPath: string;
+                };
+            };
+        };
+        responses: {
+            /** @description The file was moved successfully */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** @description The destination file path */
+                        path: string;
+                    };
+                };
+            };
+            /** @description An error response */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    uploadSpaceStoragePath: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                spaceId: string;
+                path: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    /** @description The file to upload either as http: or data: URL */
+                    file?: string;
+                } | {
+                    /** @description The file definition to upload */
+                    file?: {
+                        /** @description The file type */
+                        type: string;
+                        /** @description The file size */
+                        size: number;
+                        /** @description Optional metadata */
+                        meta?: Record<string, never>;
+                    };
+                };
+                "multipart/form-data": {
+                    /**
+                     * Format: binary
+                     * @description The file to upload
+                     */
+                    file: string;
+                };
+                "*/*": string;
+            };
+        };
+        responses: {
+            /** @description The file was uploaded successfully */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** @description The ID of the uploaded file */
+                        id: string;
+                        /** @description The path where the file is stored */
+                        path: string;
+                        /** @description The request required to upload the file */
+                        uploadRequest?: {
+                            /** @description The HTTP method to use */
+                            method: string;
+                            /** @description The HTTP url to use */
+                            url: string;
+                            /** @description The HTTP headers to use */
+                            headers: Record<string, never>;
+                        };
+                    };
+                };
+            };
+            /** @description An error response */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
     updateSpace: {
         parameters: {
             query?: never;
@@ -24651,6 +25084,81 @@ export interface operations {
             };
         };
     };
+    listUsageRecords: {
+        parameters: {
+            query?: {
+                cursor?: string;
+                order?: "asc" | "desc";
+                take?: number;
+                meta?: {
+                    [key: string]: string;
+                };
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The list of usage records was retrieved successfully */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        items: {
+                            /** @description The associated name */
+                            name?: string;
+                            /** @description The associated description */
+                            description?: string;
+                            /** @description Meta data information */
+                            meta?: {
+                                [key: string]: unknown;
+                            };
+                            /** @description The instance ID */
+                            id: string;
+                            /** @description The timestamp (ms) when the instance was created */
+                            createdAt: number;
+                            /** @description The timestamp (ms) when the instance was updated */
+                            updatedAt: number;
+                            /** @description The usage type */
+                            type: string;
+                            /** @description The usage count */
+                            count: number;
+                            /** @description Related conversation ID if applicable */
+                            conversationId?: string;
+                            /** @description Related message ID if applicable */
+                            messageId?: string;
+                            /** @description Related task ID if applicable */
+                            taskId?: string;
+                            /** @description Related contact ID if applicable */
+                            contactId?: string;
+                            /** @description Related blueprint ID if applicable */
+                            blueprintId?: string;
+                            /** @description Related bot ID if applicable */
+                            botId?: string;
+                            /** @description Related dataset ID if applicable */
+                            datasetId?: string;
+                            /** @description Related skillset ID if applicable */
+                            skillsetId?: string;
+                            /** @description Related ability ID if applicable */
+                            abilityId?: string;
+                        }[];
+                        /** @description Cursor for fetching the next page */
+                        cursor: string;
+                    };
+                };
+            };
+            /** @description An error response */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
     fetchUsageSeries: {
         parameters: {
             query?: never;

package/dist/esm/client.js

@@ -1,5 +1,15 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
 var _ChatBotKitClient_secret, _ChatBotKitClient_baseUrl, _ChatBotKitClient_endpoints, _ChatBotKitClient_runAsUserId, _ChatBotKitClient_runAsChildUserEmail, _ChatBotKitClient_timezone, _ChatBotKitClient_headers, _ChatBotKitClient_timeout, _ChatBotKitClient_retries, _ChatBotKitClient_retryDelay, _ChatBotKitClient_retryTimeout, _ChatBotKitClient_fetchFn, _ChatBotKitClient_cacheMap;
-import { __classPrivateFieldGet, __classPrivateFieldSet } from "tslib";
 import { Blob, FetchError, FormData, fetch, jsonl, withRetry, withTimeout, } from '@chatbotkit/fetch';
 const fetchPlusPlus = withRetry(withTimeout(fetch, { timeout: Infinity }), {
     retries: 3,

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

@@ -1,4 +1,5 @@
 export class SpaceClient extends ChatBotKitClient {
+    storage: SpaceStorageClient;
     list(request?: import("./v1.js").SpaceListRequest): ResponsePromise<import("./v1.js").SpaceListResponse, import("./v1.js").SpaceListStreamType>;
     fetch(spaceId: string): ResponsePromise<import("./v1.js").SpaceFetchResponse, never>;
     create(request: import("./v1.js").SpaceCreateRequest): Promise<import("./v1.js").SpaceCreateResponse>;
@@ -8,3 +9,4 @@ export class SpaceClient extends ChatBotKitClient {
 export default SpaceClient;
 export type ResponsePromise<T, U> = import("../client.js").ResponsePromise<T, U>;
 import { ChatBotKitClient } from '../client.js';
+import { SpaceStorageClient } from './storage/index.js';

package/dist/esm/space/index.js

@@ -1,8 +1,10 @@
 import { ChatBotKitClient } from '../client.js';
+import { SpaceStorageClient } from './storage/index.js';
 import { createSpace, deleteSpace, fetchSpace, listSpaces, updateSpace, } from './v1.js';
 export class SpaceClient extends ChatBotKitClient {
     constructor(options) {
         super(options);
+        this.storage = new SpaceStorageClient(options);
     }
     list(request) {
         return listSpaces(this, request);

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

@@ -0,0 +1,11 @@
+export class SpaceStorageClient extends ChatBotKitClient {
+    list(spaceId: string, path?: string, request?: import("./v1.js").SpaceStorageListRequest): ResponsePromise<import("./v1.js").SpaceStorageListResponse, never>;
+    download(spaceId: string, path: string, request?: import("./v1.js").SpaceStorageDownloadRequest): ResponsePromise<import("./v1.js").SpaceStorageDownloadResponse, never>;
+    upload(spaceId: string, path: string, request: import("./v1.js").SpaceStorageUploadRequest): Promise<import("./v1.js").SpaceStorageUploadResponse>;
+    delete(spaceId: string, path: string, request?: import("./v1.js").SpaceStorageDeleteRequest): Promise<import("./v1.js").SpaceStorageDeleteResponse>;
+    copy(spaceId: string, path: string, request: import("./v1.js").SpaceStorageCopyRequest): Promise<import("./v1.js").SpaceStorageCopyResponse>;
+    move(spaceId: string, path: string, request: import("./v1.js").SpaceStorageMoveRequest): Promise<import("./v1.js").SpaceStorageMoveResponse>;
+}
+export default SpaceStorageClient;
+export type ResponsePromise<T, U> = import("../../client.js").ResponsePromise<T, U>;
+import { ChatBotKitClient } from '../../client.js';

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

@@ -0,0 +1,26 @@
+import { ChatBotKitClient } from '../../client.js';
+import { copySpaceStorage, deleteSpaceStorage, downloadSpaceStorage, listSpaceStorage, moveSpaceStorage, uploadSpaceStorage, } from './v1.js';
+export class SpaceStorageClient extends ChatBotKitClient {
+    constructor(options) {
+        super(options);
+    }
+    list(spaceId, path, request) {
+        return listSpaceStorage(this, spaceId, path, request);
+    }
+    download(spaceId, path, request) {
+        return downloadSpaceStorage(this, spaceId, path, request);
+    }
+    upload(spaceId, path, request) {
+        return uploadSpaceStorage(this, spaceId, path, request);
+    }
+    delete(spaceId, path, request) {
+        return deleteSpaceStorage(this, spaceId, path, request);
+    }
+    copy(spaceId, path, request) {
+        return copySpaceStorage(this, spaceId, path, request);
+    }
+    move(spaceId, path, request) {
+        return moveSpaceStorage(this, spaceId, path, request);
+    }
+}
+export default SpaceStorageClient;

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

@@ -0,0 +1,20 @@
+export function listSpaceStorage(client: ChatBotKitClient, spaceId: string, path?: string, request?: SpaceStorageListRequest): ResponsePromise<SpaceStorageListResponse, never>;
+export function downloadSpaceStorage(client: ChatBotKitClient, spaceId: string, path: string, request?: SpaceStorageDownloadRequest): ResponsePromise<SpaceStorageDownloadResponse, never>;
+export function uploadSpaceStorage(client: ChatBotKitClient, spaceId: string, path: string, request: SpaceStorageUploadRequest): Promise<SpaceStorageUploadResponse>;
+export function deleteSpaceStorage(client: ChatBotKitClient, spaceId: string, path: string, request?: SpaceStorageDeleteRequest): Promise<SpaceStorageDeleteResponse>;
+export function copySpaceStorage(client: ChatBotKitClient, spaceId: string, path: string, request: SpaceStorageCopyRequest): Promise<SpaceStorageCopyResponse>;
+export function moveSpaceStorage(client: ChatBotKitClient, spaceId: string, path: string, request: SpaceStorageMoveRequest): Promise<SpaceStorageMoveResponse>;
+export type ChatBotKitClient = import("../../client.js").ChatBotKitClient;
+export type ResponsePromise<T, U> = import("../../client.js").ResponsePromise<T, U>;
+export type SpaceStorageListRequest = NonNullable<import("../../types/api/v1.js").operations["listSpaceStoragePath"]["parameters"]["query"]>;
+export type SpaceStorageListResponse = import("../../types/api/v1.js").operations["listSpaceStoragePath"]["responses"]["200"]["content"]["application/json"];
+export type SpaceStorageDownloadRequest = NonNullable<import("../../types/api/v1.js").operations["downloadSpaceStoragePath"]["parameters"]["query"]>;
+export type SpaceStorageDownloadResponse = import("../../types/api/v1.js").operations["downloadSpaceStoragePath"]["responses"]["200"]["content"]["application/json"];
+export type SpaceStorageUploadRequest = import("../../types/api/v1.js").operations["uploadSpaceStoragePath"]["requestBody"]["content"]["application/json"];
+export type SpaceStorageUploadResponse = import("../../types/api/v1.js").operations["uploadSpaceStoragePath"]["responses"]["200"]["content"]["application/json"];
+export type SpaceStorageDeleteRequest = NonNullable<import("../../types/api/v1.js").operations["deleteSpaceStoragePath"]["requestBody"]>["content"]["application/json"];
+export type SpaceStorageDeleteResponse = import("../../types/api/v1.js").operations["deleteSpaceStoragePath"]["responses"]["200"]["content"]["application/json"];
+export type SpaceStorageCopyRequest = import("../../types/api/v1.js").operations["copySpaceStoragePath"]["requestBody"]["content"]["application/json"];
+export type SpaceStorageCopyResponse = import("../../types/api/v1.js").operations["copySpaceStoragePath"]["responses"]["200"]["content"]["application/json"];
+export type SpaceStorageMoveRequest = import("../../types/api/v1.js").operations["moveSpaceStoragePath"]["requestBody"]["content"]["application/json"];
+export type SpaceStorageMoveResponse = import("../../types/api/v1.js").operations["moveSpaceStoragePath"]["responses"]["200"]["content"]["application/json"];

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

@@ -0,0 +1,44 @@
+function encodeStoragePath(path) {
+    return path.split('/').map(encodeURIComponent).join('/');
+}
+export function listSpaceStorage(client, spaceId, path, request) {
+    const url = `/api/v1/space/${spaceId}/storage/list${path ? `/${encodeStoragePath(path)}` : ''}`;
+    const response = client.clientFetch(url, { query: request });
+    return response;
+}
+export function downloadSpaceStorage(client, spaceId, path, request) {
+    const url = `/api/v1/space/${spaceId}/storage/download/${encodeStoragePath(path)}`;
+    const response = client.clientFetch(url, {
+        headers: { Accept: 'application/json' },
+        query: request,
+    });
+    return response;
+}
+export async function uploadSpaceStorage(client, spaceId, path, request) {
+    const url = `/api/v1/space/${spaceId}/storage/upload/${encodeStoragePath(path)}`;
+    const response = await client.clientFetch(url, {
+        record: { ...request },
+    });
+    return response;
+}
+export async function deleteSpaceStorage(client, spaceId, path, request) {
+    const url = `/api/v1/space/${spaceId}/storage/delete/${encodeStoragePath(path)}`;
+    const response = await client.clientFetch(url, {
+        record: request ? { ...request } : {},
+    });
+    return response;
+}
+export async function copySpaceStorage(client, spaceId, path, request) {
+    const url = `/api/v1/space/${spaceId}/storage/copy/${encodeStoragePath(path)}`;
+    const response = await client.clientFetch(url, {
+        record: { ...request },
+    });
+    return response;
+}
+export async function moveSpaceStorage(client, spaceId, path, request) {
+    const url = `/api/v1/space/${spaceId}/storage/move/${encodeStoragePath(path)}`;
+    const response = await client.clientFetch(url, {
+        record: { ...request },
+    });
+    return response;
+}