@botpress/client 0.22.0 → 0.23.1

package/dist/errors.d.ts

@@ -6,6 +6,7 @@ export declare class UploadFileError extends Error {
         id: string;
         botId: string;
         key: string;
+        url: string;
         size: number | null;
         contentType: string;
         tags: {
@@ -23,6 +24,7 @@ export declare class UploadFileError extends Error {
         id: string;
         botId: string;
         key: string;
+        url: string;
         size: number | null;
         contentType: string;
         tags: {

package/dist/gen/index.d.ts

@@ -94,6 +94,12 @@ import * as getIntegration from './operations/getIntegration';
 import * as getIntegrationLogs from './operations/getIntegrationLogs';
 import * as getIntegrationByName from './operations/getIntegrationByName';
 import * as deleteIntegration from './operations/deleteIntegration';
+import * as createInterface from './operations/createInterface';
+import * as getInterface from './operations/getInterface';
+import * as getInterfaceByName from './operations/getInterfaceByName';
+import * as updateInterface from './operations/updateInterface';
+import * as deleteInterface from './operations/deleteInterface';
+import * as listInterfaces from './operations/listInterfaces';
 import * as getUsage from './operations/getUsage';
 import * as getMultipleUsages from './operations/getMultipleUsages';
 import * as listUsageHistory from './operations/listUsageHistory';
@@ -215,6 +221,12 @@ export * as getIntegration from './operations/getIntegration';
 export * as getIntegrationLogs from './operations/getIntegrationLogs';
 export * as getIntegrationByName from './operations/getIntegrationByName';
 export * as deleteIntegration from './operations/deleteIntegration';
+export * as createInterface from './operations/createInterface';
+export * as getInterface from './operations/getInterface';
+export * as getInterfaceByName from './operations/getInterfaceByName';
+export * as updateInterface from './operations/updateInterface';
+export * as deleteInterface from './operations/deleteInterface';
+export * as listInterfaces from './operations/listInterfaces';
 export * as getUsage from './operations/getUsage';
 export * as getMultipleUsages from './operations/getMultipleUsages';
 export * as listUsageHistory from './operations/listUsageHistory';
@@ -342,6 +354,12 @@ export declare class Client {
     readonly getIntegrationLogs: (input: getIntegrationLogs.GetIntegrationLogsInput) => Promise<getIntegrationLogs.GetIntegrationLogsResponse>;
     readonly getIntegrationByName: (input: getIntegrationByName.GetIntegrationByNameInput) => Promise<getIntegrationByName.GetIntegrationByNameResponse>;
     readonly deleteIntegration: (input: deleteIntegration.DeleteIntegrationInput) => Promise<deleteIntegration.DeleteIntegrationResponse>;
+    readonly createInterface: (input: createInterface.CreateInterfaceInput) => Promise<createInterface.CreateInterfaceResponse>;
+    readonly getInterface: (input: getInterface.GetInterfaceInput) => Promise<getInterface.GetInterfaceResponse>;
+    readonly getInterfaceByName: (input: getInterfaceByName.GetInterfaceByNameInput) => Promise<getInterfaceByName.GetInterfaceByNameResponse>;
+    readonly updateInterface: (input: updateInterface.UpdateInterfaceInput) => Promise<updateInterface.UpdateInterfaceResponse>;
+    readonly deleteInterface: (input: deleteInterface.DeleteInterfaceInput) => Promise<deleteInterface.DeleteInterfaceResponse>;
+    readonly listInterfaces: (input: listInterfaces.ListInterfacesInput) => Promise<listInterfaces.ListInterfacesResponse>;
     readonly getUsage: (input: getUsage.GetUsageInput) => Promise<getUsage.GetUsageResponse>;
     readonly getMultipleUsages: (input: getMultipleUsages.GetMultipleUsagesInput) => Promise<getMultipleUsages.GetMultipleUsagesResponse>;
     readonly listUsageHistory: (input: listUsageHistory.ListUsageHistoryInput) => Promise<listUsageHistory.ListUsageHistoryResponse>;

package/dist/gen/models.d.ts

@@ -579,6 +579,89 @@ export interface Integration {
      */
     secrets: string[];
 }
+export interface Interface {
+    /**
+     * ID of the [Interface](#schema_interface)
+     */
+    id: string;
+    /**
+     * Creation date of the [Interface](#schema_interface) in ISO 8601 format
+     */
+    createdAt: string;
+    /**
+     * Updating date of the [Interface](#schema_interface) in ISO 8601 format
+     */
+    updatedAt: string;
+    /**
+     * Name of the [Interface](#schema_interface)
+     */
+    name: string;
+    /**
+     * Version of the [Interface](#schema_interface)
+     */
+    version: string;
+    events: {
+        /**
+         * Event Definition
+         */
+        [k: string]: {
+            /**
+             * Title of the event
+             */
+            title?: string;
+            /**
+             * Description of the event
+             */
+            description?: string;
+            schema: {
+                [k: string]: any;
+            };
+        };
+    };
+    actions: {
+        /**
+         * Action definition
+         */
+        [k: string]: {
+            /**
+             * Title of the action
+             */
+            title?: string;
+            /**
+             * Description of the action
+             */
+            description?: string;
+            input: {
+                schema: {
+                    [k: string]: any;
+                };
+            };
+            output: {
+                schema: {
+                    [k: string]: any;
+                };
+            };
+        };
+    };
+    entities: {
+        /**
+         * Entity definition
+         */
+        [k: string]: {
+            /**
+             * Title of the entity
+             */
+            title?: string;
+            /**
+             * Description of the entity
+             */
+            description?: string;
+            schema: {
+                [k: string]: any;
+            };
+        };
+    };
+}
 export interface Workspace {
     id: string;
     name: string;
@@ -1129,11 +1212,11 @@ export interface File {
      */
     key: string;
     /**
-     * If the file is not uploaded yet, this will be set to a `null` value.
+     * URL to retrieve the file content. This URL will be ready to use once the file is uploaded.
      *
      * If the file has a `public_content` policy, this will contain the permanent public URL to retrieve the file, otherwise this will contain a temporary pre-signed URL to download the file which should be used shortly after retrieving and should not be stored long-term as the URL will expire after a short timeframe.
      */
-    url: string | null;
+    url: string;
     /**
      * File size in bytes. Non-null if file upload status is "COMPLETE".
      */

package/dist/gen/operations/createInterface.d.ts

@@ -0,0 +1,172 @@
+export interface CreateInterfaceRequestHeaders {
+}
+export interface CreateInterfaceRequestQuery {
+}
+export interface CreateInterfaceRequestParams {
+}
+export interface CreateInterfaceRequestBody {
+    /**
+     * Name of the [Interface](#schema_interface)
+     */
+    name: string;
+    /**
+     * Version of the [Interface](#schema_interface)
+     */
+    version: string;
+    events: {
+        /**
+         * Event Definition
+         */
+        [k: string]: {
+            /**
+             * Title of the event
+             */
+            title?: string;
+            /**
+             * Description of the event
+             */
+            description?: string;
+            schema: {
+                [k: string]: any;
+            };
+        };
+    };
+    actions: {
+        /**
+         * Action definition
+         */
+        [k: string]: {
+            /**
+             * Title of the action
+             */
+            title?: string;
+            /**
+             * Description of the action
+             */
+            description?: string;
+            input: {
+                schema: {
+                    [k: string]: any;
+                };
+            };
+            output: {
+                schema: {
+                    [k: string]: any;
+                };
+            };
+        };
+    };
+    entities: {
+        /**
+         * Entity definition
+         */
+        [k: string]: {
+            /**
+             * Title of the entity
+             */
+            title?: string;
+            /**
+             * Description of the entity
+             */
+            description?: string;
+            schema: {
+                [k: string]: any;
+            };
+        };
+    };
+}
+export type CreateInterfaceInput = CreateInterfaceRequestBody & CreateInterfaceRequestHeaders & CreateInterfaceRequestQuery & CreateInterfaceRequestParams;
+export type CreateInterfaceRequest = {
+    headers: CreateInterfaceRequestHeaders;
+    query: CreateInterfaceRequestQuery;
+    params: CreateInterfaceRequestParams;
+    body: CreateInterfaceRequestBody;
+};
+export declare const parseReq: (input: CreateInterfaceInput) => CreateInterfaceRequest & {
+    path: string;
+};
+export interface CreateInterfaceResponse {
+    interface: {
+        /**
+         * ID of the [Interface](#schema_interface)
+         */
+        id: string;
+        /**
+         * Creation date of the [Interface](#schema_interface) in ISO 8601 format
+         */
+        createdAt: string;
+        /**
+         * Updating date of the [Interface](#schema_interface) in ISO 8601 format
+         */
+        updatedAt: string;
+        /**
+         * Name of the [Interface](#schema_interface)
+         */
+        name: string;
+        /**
+         * Version of the [Interface](#schema_interface)
+         */
+        version: string;
+        events: {
+            /**
+             * Event Definition
+             */
+            [k: string]: {
+                /**
+                 * Title of the event
+                 */
+                title?: string;
+                /**
+                 * Description of the event
+                 */
+                description?: string;
+                schema: {
+                    [k: string]: any;
+                };
+            };
+        };
+        actions: {
+            /**
+             * Action definition
+             */
+            [k: string]: {
+                /**
+                 * Title of the action
+                 */
+                title?: string;
+                /**
+                 * Description of the action
+                 */
+                description?: string;
+                input: {
+                    schema: {
+                        [k: string]: any;
+                    };
+                };
+                output: {
+                    schema: {
+                        [k: string]: any;
+                    };
+                };
+            };
+        };
+        entities: {
+            /**
+             * Entity definition
+             */
+            [k: string]: {
+                /**
+                 * Title of the entity
+                 */
+                title?: string;
+                /**
+                 * Description of the entity
+                 */
+                description?: string;
+                schema: {
+                    [k: string]: any;
+                };
+            };
+        };
+    };
+}

package/dist/gen/operations/deleteInterface.d.ts

@@ -0,0 +1,21 @@
+export interface DeleteInterfaceRequestHeaders {
+}
+export interface DeleteInterfaceRequestQuery {
+}
+export interface DeleteInterfaceRequestParams {
+    id: string;
+}
+export interface DeleteInterfaceRequestBody {
+}
+export type DeleteInterfaceInput = DeleteInterfaceRequestBody & DeleteInterfaceRequestHeaders & DeleteInterfaceRequestQuery & DeleteInterfaceRequestParams;
+export type DeleteInterfaceRequest = {
+    headers: DeleteInterfaceRequestHeaders;
+    query: DeleteInterfaceRequestQuery;
+    params: DeleteInterfaceRequestParams;
+    body: DeleteInterfaceRequestBody;
+};
+export declare const parseReq: (input: DeleteInterfaceInput) => DeleteInterfaceRequest & {
+    path: string;
+};
+export interface DeleteInterfaceResponse {
+}

package/dist/gen/operations/getFile.d.ts

@@ -32,11 +32,11 @@ export interface GetFileResponse {
          */
         key: string;
         /**
-         * If the file is not uploaded yet, this will be set to a `null` value.
+         * URL to retrieve the file content. This URL will be ready to use once the file is uploaded.
          *
          * If the file has a `public_content` policy, this will contain the permanent public URL to retrieve the file, otherwise this will contain a temporary pre-signed URL to download the file which should be used shortly after retrieving and should not be stored long-term as the URL will expire after a short timeframe.
          */
-        url: string | null;
+        url: string;
         /**
          * File size in bytes. Non-null if file upload status is "COMPLETE".
          */

package/dist/gen/operations/getInterface.d.ts

@@ -0,0 +1,104 @@
+export interface GetInterfaceRequestHeaders {
+}
+export interface GetInterfaceRequestQuery {
+}
+export interface GetInterfaceRequestParams {
+    id: string;
+}
+export interface GetInterfaceRequestBody {
+}
+export type GetInterfaceInput = GetInterfaceRequestBody & GetInterfaceRequestHeaders & GetInterfaceRequestQuery & GetInterfaceRequestParams;
+export type GetInterfaceRequest = {
+    headers: GetInterfaceRequestHeaders;
+    query: GetInterfaceRequestQuery;
+    params: GetInterfaceRequestParams;
+    body: GetInterfaceRequestBody;
+};
+export declare const parseReq: (input: GetInterfaceInput) => GetInterfaceRequest & {
+    path: string;
+};
+export interface GetInterfaceResponse {
+    interface: {
+        /**
+         * ID of the [Interface](#schema_interface)
+         */
+        id: string;
+        /**
+         * Creation date of the [Interface](#schema_interface) in ISO 8601 format
+         */
+        createdAt: string;
+        /**
+         * Updating date of the [Interface](#schema_interface) in ISO 8601 format
+         */
+        updatedAt: string;
+        /**
+         * Name of the [Interface](#schema_interface)
+         */
+        name: string;
+        /**
+         * Version of the [Interface](#schema_interface)
+         */
+        version: string;
+        events: {
+            /**
+             * Event Definition
+             */
+            [k: string]: {
+                /**
+                 * Title of the event
+                 */
+                title?: string;
+                /**
+                 * Description of the event
+                 */
+                description?: string;
+                schema: {
+                    [k: string]: any;
+                };
+            };
+        };
+        actions: {
+            /**
+             * Action definition
+             */
+            [k: string]: {
+                /**
+                 * Title of the action
+                 */
+                title?: string;
+                /**
+                 * Description of the action
+                 */
+                description?: string;
+                input: {
+                    schema: {
+                        [k: string]: any;
+                    };
+                };
+                output: {
+                    schema: {
+                        [k: string]: any;
+                    };
+                };
+            };
+        };
+        entities: {
+            /**
+             * Entity definition
+             */
+            [k: string]: {
+                /**
+                 * Title of the entity
+                 */
+                title?: string;
+                /**
+                 * Description of the entity
+                 */
+                description?: string;
+                schema: {
+                    [k: string]: any;
+                };
+            };
+        };
+    };
+}

package/dist/gen/operations/getInterfaceByName.d.ts

@@ -0,0 +1,105 @@
+export interface GetInterfaceByNameRequestHeaders {
+}
+export interface GetInterfaceByNameRequestQuery {
+}
+export interface GetInterfaceByNameRequestParams {
+    name: string;
+    version: string;
+}
+export interface GetInterfaceByNameRequestBody {
+}
+export type GetInterfaceByNameInput = GetInterfaceByNameRequestBody & GetInterfaceByNameRequestHeaders & GetInterfaceByNameRequestQuery & GetInterfaceByNameRequestParams;
+export type GetInterfaceByNameRequest = {
+    headers: GetInterfaceByNameRequestHeaders;
+    query: GetInterfaceByNameRequestQuery;
+    params: GetInterfaceByNameRequestParams;
+    body: GetInterfaceByNameRequestBody;
+};
+export declare const parseReq: (input: GetInterfaceByNameInput) => GetInterfaceByNameRequest & {
+    path: string;
+};
+export interface GetInterfaceByNameResponse {
+    interface: {
+        /**
+         * ID of the [Interface](#schema_interface)
+         */
+        id: string;
+        /**
+         * Creation date of the [Interface](#schema_interface) in ISO 8601 format
+         */
+        createdAt: string;
+        /**
+         * Updating date of the [Interface](#schema_interface) in ISO 8601 format
+         */
+        updatedAt: string;
+        /**
+         * Name of the [Interface](#schema_interface)
+         */
+        name: string;
+        /**
+         * Version of the [Interface](#schema_interface)
+         */
+        version: string;
+        events: {
+            /**
+             * Event Definition
+             */
+            [k: string]: {
+                /**
+                 * Title of the event
+                 */
+                title?: string;
+                /**
+                 * Description of the event
+                 */
+                description?: string;
+                schema: {
+                    [k: string]: any;
+                };
+            };
+        };
+        actions: {
+            /**
+             * Action definition
+             */
+            [k: string]: {
+                /**
+                 * Title of the action
+                 */
+                title?: string;
+                /**
+                 * Description of the action
+                 */
+                description?: string;
+                input: {
+                    schema: {
+                        [k: string]: any;
+                    };
+                };
+                output: {
+                    schema: {
+                        [k: string]: any;
+                    };
+                };
+            };
+        };
+        entities: {
+            /**
+             * Entity definition
+             */
+            [k: string]: {
+                /**
+                 * Title of the entity
+                 */
+                title?: string;
+                /**
+                 * Description of the entity
+                 */
+                description?: string;
+                schema: {
+                    [k: string]: any;
+                };
+            };
+        };
+    };
+}

package/dist/gen/operations/listBots.d.ts

@@ -3,6 +3,8 @@ export interface ListBotsRequestHeaders {
 export interface ListBotsRequestQuery {
     dev?: boolean;
     nextToken?: string;
+    sortField?: "createdAt" | "updatedAt";
+    sortDirection?: "asc" | "desc";
 }
 export interface ListBotsRequestParams {
 }

package/dist/gen/operations/listFiles.d.ts

@@ -35,11 +35,11 @@ export interface ListFilesResponse {
          */
         key: string;
         /**
-         * If the file is not uploaded yet, this will be set to a `null` value.
+         * URL to retrieve the file content. This URL will be ready to use once the file is uploaded.
          *
          * If the file has a `public_content` policy, this will contain the permanent public URL to retrieve the file, otherwise this will contain a temporary pre-signed URL to download the file which should be used shortly after retrieving and should not be stored long-term as the URL will expire after a short timeframe.
          */
-        url: string | null;
+        url: string;
         /**
          * File size in bytes. Non-null if file upload status is "COMPLETE".
          */

package/dist/gen/operations/listInterfaces.d.ts

@@ -0,0 +1,49 @@
+export interface ListInterfacesRequestHeaders {
+}
+export interface ListInterfacesRequestQuery {
+    nextToken?: string;
+}
+export interface ListInterfacesRequestParams {
+}
+export interface ListInterfacesRequestBody {
+}
+export type ListInterfacesInput = ListInterfacesRequestBody & ListInterfacesRequestHeaders & ListInterfacesRequestQuery & ListInterfacesRequestParams;
+export type ListInterfacesRequest = {
+    headers: ListInterfacesRequestHeaders;
+    query: ListInterfacesRequestQuery;
+    params: ListInterfacesRequestParams;
+    body: ListInterfacesRequestBody;
+};
+export declare const parseReq: (input: ListInterfacesInput) => ListInterfacesRequest & {
+    path: string;
+};
+export interface ListInterfacesResponse {
+    interfaces: {
+        /**
+         * ID of the [Interface](#schema_interface)
+         */
+        id: string;
+        /**
+         * Creation date of the [Interface](#schema_interface) in ISO 8601 format
+         */
+        createdAt: string;
+        /**
+         * Updating date of the [Interface](#schema_interface) in ISO 8601 format
+         */
+        updatedAt: string;
+        /**
+         * Name of the [Interface](#schema_interface)
+         */
+        name: string;
+        /**
+         * Version of the [Interface](#schema_interface)
+         */
+        version: string;
+    }[];
+    meta: {
+        /**
+         * The token to use to retrieve the next page of results, passed as a query string parameter (value should be URL-encoded) to this API endpoint.
+         */
+        nextToken?: string;
+    };
+}

package/dist/gen/operations/updateFileMetadata.d.ts

@@ -42,11 +42,11 @@ export interface UpdateFileMetadataResponse {
          */
         key: string;
         /**
-         * If the file is not uploaded yet, this will be set to a `null` value.
+         * URL to retrieve the file content. This URL will be ready to use once the file is uploaded.
          *
          * If the file has a `public_content` policy, this will contain the permanent public URL to retrieve the file, otherwise this will contain a temporary pre-signed URL to download the file which should be used shortly after retrieving and should not be stored long-term as the URL will expire after a short timeframe.
          */
-        url: string | null;
+        url: string;
         /**
          * File size in bytes. Non-null if file upload status is "COMPLETE".
          */