@botpress/client 0.41.2 → 0.43.0

package/dist/index.d.ts

@@ -4697,6 +4697,9 @@ interface ListBotsRequestHeaders {
 }
 interface ListBotsRequestQuery {
     dev?: boolean;
+    tags?: {
+        [k: string]: string;
+    };
     nextToken?: string;
     sortField?: "createdAt" | "updatedAt";
     sortDirection?: "asc" | "desc";
@@ -4722,6 +4725,12 @@ interface ListBotsResponse {
         updatedAt: string;
         name: string;
         deployedAt?: string;
+        /**
+         * Tags of [Bot](#schema_bot)
+         */
+        tags: {
+            [k: string]: string;
+        };
     }[];
     meta: {
         /**
@@ -5721,6 +5730,7 @@ interface ListWorkspacesRequestHeaders {
 }
 interface ListWorkspacesRequestQuery {
     nextToken?: string;
+    handle?: string;
 }
 interface ListWorkspacesRequestParams {
 }
@@ -6657,14 +6667,21 @@ interface CreateIntegrationResponse {
     };
 }
 
-interface UpdateIntegrationRequestHeaders {
+interface ValidateIntegrationCreationRequestHeaders {
 }
-interface UpdateIntegrationRequestQuery {
+interface ValidateIntegrationCreationRequestQuery {
 }
-interface UpdateIntegrationRequestParams {
-    id: string;
+interface ValidateIntegrationCreationRequestParams {
 }
-interface UpdateIntegrationRequestBody {
+interface ValidateIntegrationCreationRequestBody {
+    /**
+     * Name of the [Integration](#schema_integration)
+     */
+    name: string;
+    /**
+     * Version of the [Integration](#schema_integration)
+     */
+    version: string;
     /**
      * Default configuration definition of the integration
      */
@@ -6684,8 +6701,8 @@ interface UpdateIntegrationRequestBody {
             [k: string]: any;
         };
         identifier?: {
-            linkTemplateScript?: string | null;
             required?: boolean;
+            linkTemplateScript?: string;
         };
     };
     /**
@@ -6708,10 +6725,94 @@ interface UpdateIntegrationRequestBody {
                 [k: string]: any;
             };
             identifier?: {
-                linkTemplateScript?: string | null;
                 required?: boolean;
+                linkTemplateScript?: string;
             };
-        } | null;
+        };
+    };
+    states?: {
+        /**
+         * State definition
+         */
+        [k: string]: {
+            /**
+             * Type of the [State](#schema_state) (`conversation`, `user` or `integration`)
+             */
+            type: "conversation" | "user" | "integration";
+            /**
+             * Schema of the [State](#schema_state) in the `JSON schema` format. This `JSON schema` is going to be used for validating the state data.
+             */
+            schema: {
+                [k: string]: any;
+            };
+        };
+    };
+    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;
+            billable?: boolean;
+            cacheable?: boolean;
+            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;
+            };
+        };
+    };
+    identifier?: {
+        fallbackHandlerScript?: string;
+        extractScript?: string;
     };
     channels?: {
         [k: string]: {
@@ -6723,7 +6824,7 @@ interface UpdateIntegrationRequestBody {
              * Description of the channel
              */
             description?: string;
-            messages?: {
+            messages: {
                 /**
                  * Message definition
                  */
@@ -6731,7 +6832,7 @@ interface UpdateIntegrationRequestBody {
                     schema: {
                         [k: string]: any;
                     };
-                } | null;
+                };
             };
             conversation?: {
                 /**
@@ -6760,7 +6861,7 @@ interface UpdateIntegrationRequestBody {
                          * Description of the tag
                          */
                         description?: string;
-                    } | null;
+                    };
                 };
             };
             message?: {
@@ -6777,76 +6878,10 @@ interface UpdateIntegrationRequestBody {
                          * Description of the tag
                          */
                         description?: string;
-                    } | null;
-                };
-            };
-        } | null;
-    };
-    identifier?: {
-        extractScript?: string | null;
-        fallbackHandlerScript?: string | null;
-    };
-    actions?: {
-        /**
-         * Action definition
-         */
-        [k: string]: {
-            /**
-             * Title of the action
-             */
-            title?: string;
-            /**
-             * Description of the action
-             */
-            description?: string;
-            billable?: boolean;
-            cacheable?: boolean;
-            input: {
-                schema: {
-                    [k: string]: any;
-                };
-            };
-            output: {
-                schema: {
-                    [k: string]: any;
+                    };
                 };
             };
-        } | null;
-    };
-    events?: {
-        /**
-         * Event Definition
-         */
-        [k: string]: {
-            /**
-             * Title of the event
-             */
-            title?: string;
-            /**
-             * Description of the event
-             */
-            description?: string;
-            schema: {
-                [k: string]: any;
-            };
-        } | null;
-    };
-    states?: {
-        /**
-         * State definition
-         */
-        [k: string]: {
-            /**
-             * Type of the [State](#schema_state) (`conversation`, `user` or `integration`)
-             */
-            type: "conversation" | "user" | "integration";
-            /**
-             * Schema of the [State](#schema_state) in the `JSON schema` format. This `JSON schema` is going to be used for validating the state data.
-             */
-            schema: {
-                [k: string]: any;
-            };
-        } | null;
+        };
     };
     user?: {
         /**
@@ -6875,26 +6910,8 @@ interface UpdateIntegrationRequestBody {
                  * Description of the tag
                  */
                 description?: string;
-            } | null;
-        };
-    };
-    entities?: {
-        /**
-         * Entity definition
-         */
-        [k: string]: {
-            /**
-             * Title of the entity
-             */
-            title?: string;
-            /**
-             * Description of the entity
-             */
-            description?: string;
-            schema: {
-                [k: string]: any;
             };
-        } | null;
+        };
     };
     interfaces?: {
         [k: string]: {
@@ -6922,18 +6939,26 @@ interface UpdateIntegrationRequestBody {
                     name: string;
                 };
             };
-        } | null;
+        };
     };
     /**
      * Secrets are integration-wide values available in the code via environment variables formatted with a SECRET_ prefix followed by your secret name. A secret name must respect SCREAMING_SNAKE casing.
      */
     secrets?: {
-        [k: string]: string | null;
+        [k: string]: string;
     };
     /**
      * JavaScript code of the integration
      */
     code?: string;
+    /**
+     * URL of the integration
+     */
+    url?: string;
+    /**
+     * Indicates if the integration is a development integration; Dev integrations run locally
+     */
+    dev?: boolean;
     /**
      * Base64 encoded svg of the integration icon. This icon is global to the integration each versions will be updated when this changes.
      */
@@ -6950,96 +6975,711 @@ interface UpdateIntegrationRequestBody {
      * Description of the integration. This is the description that will be displayed in the UI
      */
     description?: string;
-    /**
-     * URL of the integration
-     */
-    url?: string | null;
     /**
      * Idicates if the integration is public. Public integrations are available to all and cannot be updated without creating a new version.
      */
     public?: boolean;
     layers?: string[];
 }
-type UpdateIntegrationInput = UpdateIntegrationRequestBody & UpdateIntegrationRequestHeaders & UpdateIntegrationRequestQuery & UpdateIntegrationRequestParams;
-interface UpdateIntegrationResponse {
-    integration: {
-        /**
-         * ID of the [Integration](#schema_integration)
-         */
-        id: string;
+type ValidateIntegrationCreationInput = ValidateIntegrationCreationRequestBody & ValidateIntegrationCreationRequestHeaders & ValidateIntegrationCreationRequestQuery & ValidateIntegrationCreationRequestParams;
+interface ValidateIntegrationCreationResponse {
+}
+
+interface UpdateIntegrationRequestHeaders {
+}
+interface UpdateIntegrationRequestQuery {
+}
+interface UpdateIntegrationRequestParams {
+    id: string;
+}
+interface UpdateIntegrationRequestBody {
+    /**
+     * Default configuration definition of the integration
+     */
+    configuration?: {
         /**
-         * Creation date of the [Integration](#schema_integration) in ISO 8601 format
+         * Title of the configuration
          */
-        createdAt: string;
+        title?: string;
         /**
-         * Updating date of the [Integration](#schema_integration) in ISO 8601 format
+         * Description of the configuration
          */
-        updatedAt: string;
+        description?: string;
         /**
-         * Global identifier configuration of the [Integration](#schema_integration)
+         * Schema of the configuration in the `JSON schema` format. The configuration data is validated against this `JSON schema`.
          */
-        identifier: {
+        schema?: {
+            [k: string]: any;
+        };
+        identifier?: {
+            linkTemplateScript?: string | null;
+            required?: boolean;
+        };
+    };
+    /**
+     * Additional configuration definitions of the integration
+     */
+    configurations?: {
+        [k: string]: {
             /**
-             * VRL Script of the [Integration](#schema_integration) to handle incoming requests for a request that doesn't have an identifier
+             * Title of the configuration
              */
-            fallbackHandlerScript?: string;
+            title?: string;
             /**
-             * VRL Script of the [Integration](#schema_integration) to extract the identifier from an incoming webhook often use for OAuth
+             * Description of the configuration
              */
-            extractScript?: string;
-        };
+            description?: string;
+            /**
+             * Schema of the configuration in the `JSON schema` format. The configuration data is validated against this `JSON schema`.
+             */
+            schema?: {
+                [k: string]: any;
+            };
+            identifier?: {
+                linkTemplateScript?: string | null;
+                required?: boolean;
+            };
+        } | null;
+    };
+    channels?: {
+        [k: string]: {
+            /**
+             * Title of the channel
+             */
+            title?: string;
+            /**
+             * Description of the channel
+             */
+            description?: string;
+            messages?: {
+                /**
+                 * Message definition
+                 */
+                [k: string]: {
+                    schema: {
+                        [k: string]: any;
+                    };
+                } | null;
+            };
+            conversation?: {
+                /**
+                 * The conversation creation setting determines how to create a conversation through the API directly. The integration will have to implement the `createConversation` functionality to support this setting.
+                 */
+                creation?: {
+                    /**
+                     * Enable conversation creation
+                     */
+                    enabled: boolean;
+                    /**
+                     * The list of tags that are required to be specified when calling the API directly to create a conversation.
+                     */
+                    requiredTags: string[];
+                };
+                tags?: {
+                    /**
+                     * Definition of a tag that can be provided on the object
+                     */
+                    [k: string]: {
+                        /**
+                         * Title of the tag
+                         */
+                        title?: string;
+                        /**
+                         * Description of the tag
+                         */
+                        description?: string;
+                    } | null;
+                };
+            };
+            message?: {
+                tags?: {
+                    /**
+                     * Definition of a tag that can be provided on the object
+                     */
+                    [k: string]: {
+                        /**
+                         * Title of the tag
+                         */
+                        title?: string;
+                        /**
+                         * Description of the tag
+                         */
+                        description?: string;
+                    } | null;
+                };
+            };
+        } | null;
+    };
+    identifier?: {
+        extractScript?: string | null;
+        fallbackHandlerScript?: string | null;
+    };
+    actions?: {
         /**
-         * URL of the [Integration](#schema_integration)
+         * Action definition
          */
-        url: string;
+        [k: string]: {
+            /**
+             * Title of the action
+             */
+            title?: string;
+            /**
+             * Description of the action
+             */
+            description?: string;
+            billable?: boolean;
+            cacheable?: boolean;
+            input: {
+                schema: {
+                    [k: string]: any;
+                };
+            };
+            output: {
+                schema: {
+                    [k: string]: any;
+                };
+            };
+        } | null;
+    };
+    events?: {
         /**
-         * Name of the [Integration](#schema_integration)
+         * Event Definition
          */
-        name: string;
+        [k: string]: {
+            /**
+             * Title of the event
+             */
+            title?: string;
+            /**
+             * Description of the event
+             */
+            description?: string;
+            schema: {
+                [k: string]: any;
+            };
+        } | null;
+    };
+    states?: {
         /**
-         * Version of the [Integration](#schema_integration)
+         * State definition
          */
-        version: string;
-        interfaces: {
+        [k: string]: {
+            /**
+             * Type of the [State](#schema_state) (`conversation`, `user` or `integration`)
+             */
+            type: "conversation" | "user" | "integration";
+            /**
+             * Schema of the [State](#schema_state) in the `JSON schema` format. This `JSON schema` is going to be used for validating the state data.
+             */
+            schema: {
+                [k: string]: any;
+            };
+        } | null;
+    };
+    user?: {
+        /**
+         * The user creation setting determines how to create a user through the API directly. The integration will have to implement the `createUser` functionality to support this setting.
+         */
+        creation?: {
+            /**
+             * Enable user creation
+             */
+            enabled: boolean;
+            /**
+             * The list of tags that are required to be specified when calling the API directly to create a user.
+             */
+            requiredTags: string[];
+        };
+        tags?: {
+            /**
+             * Definition of a tag that can be provided on the object
+             */
+            [k: string]: {
+                /**
+                 * Title of the tag
+                 */
+                title?: string;
+                /**
+                 * Description of the tag
+                 */
+                description?: string;
+            } | null;
+        };
+    };
+    entities?: {
+        /**
+         * Entity definition
+         */
+        [k: string]: {
+            /**
+             * Title of the entity
+             */
+            title?: string;
+            /**
+             * Description of the entity
+             */
+            description?: string;
+            schema: {
+                [k: string]: any;
+            };
+        } | null;
+    };
+    interfaces?: {
+        [k: string]: {
+            /**
+             * ID of the interface
+             */
+            id: string;
+            entities?: {
+                [k: string]: {
+                    name: string;
+                };
+            };
+            actions?: {
+                [k: string]: {
+                    name: string;
+                };
+            };
+            events?: {
+                [k: string]: {
+                    name: string;
+                };
+            };
+            channels?: {
+                [k: string]: {
+                    name: string;
+                };
+            };
+        } | null;
+    };
+    /**
+     * Secrets are integration-wide values available in the code via environment variables formatted with a SECRET_ prefix followed by your secret name. A secret name must respect SCREAMING_SNAKE casing.
+     */
+    secrets?: {
+        [k: string]: string | null;
+    };
+    /**
+     * JavaScript code of the integration
+     */
+    code?: string;
+    /**
+     * Base64 encoded svg of the integration icon. This icon is global to the integration each versions will be updated when this changes.
+     */
+    icon?: string;
+    /**
+     * Base64 encoded markdown of the integration readme. The readme is specific to each integration versions.
+     */
+    readme?: string;
+    /**
+     * Title of the integration. This is the name that will be displayed in the UI
+     */
+    title?: string;
+    /**
+     * Description of the integration. This is the description that will be displayed in the UI
+     */
+    description?: string;
+    /**
+     * URL of the integration
+     */
+    url?: string | null;
+    /**
+     * Idicates if the integration is public. Public integrations are available to all and cannot be updated without creating a new version.
+     */
+    public?: boolean;
+    layers?: string[];
+}
+type UpdateIntegrationInput = UpdateIntegrationRequestBody & UpdateIntegrationRequestHeaders & UpdateIntegrationRequestQuery & UpdateIntegrationRequestParams;
+interface UpdateIntegrationResponse {
+    integration: {
+        /**
+         * ID of the [Integration](#schema_integration)
+         */
+        id: string;
+        /**
+         * Creation date of the [Integration](#schema_integration) in ISO 8601 format
+         */
+        createdAt: string;
+        /**
+         * Updating date of the [Integration](#schema_integration) in ISO 8601 format
+         */
+        updatedAt: string;
+        /**
+         * Global identifier configuration of the [Integration](#schema_integration)
+         */
+        identifier: {
+            /**
+             * VRL Script of the [Integration](#schema_integration) to handle incoming requests for a request that doesn't have an identifier
+             */
+            fallbackHandlerScript?: string;
+            /**
+             * VRL Script of the [Integration](#schema_integration) to extract the identifier from an incoming webhook often use for OAuth
+             */
+            extractScript?: string;
+        };
+        /**
+         * URL of the [Integration](#schema_integration)
+         */
+        url: string;
+        /**
+         * Name of the [Integration](#schema_integration)
+         */
+        name: string;
+        /**
+         * Version of the [Integration](#schema_integration)
+         */
+        version: string;
+        interfaces: {
+            [k: string]: {
+                /**
+                 * ID of the interface
+                 */
+                id: string;
+                /**
+                 * Name of the interface
+                 */
+                name: string;
+                /**
+                 * Version of the interface
+                 */
+                version: string;
+                entities: {
+                    [k: string]: {
+                        name: string;
+                    };
+                };
+                actions: {
+                    [k: string]: {
+                        name: string;
+                    };
+                };
+                events: {
+                    [k: string]: {
+                        name: string;
+                    };
+                };
+                channels: {
+                    [k: string]: {
+                        name: string;
+                    };
+                };
+            };
+        };
+        /**
+         * Configuration definition
+         */
+        configuration: {
+            /**
+             * Title of the configuration
+             */
+            title?: string;
+            /**
+             * Description of the configuration
+             */
+            description?: string;
+            /**
+             * Identifier configuration of the [Integration](#schema_integration)
+             */
+            identifier: {
+                linkTemplateScript?: string;
+                required: boolean;
+            };
+            /**
+             * Schema of the configuration in the `JSON schema` format. The configuration data is validated against this `JSON schema`.
+             */
+            schema: {
+                [k: string]: any;
+            };
+        };
+        configurations: {
+            /**
+             * Configuration definition
+             */
+            [k: string]: {
+                /**
+                 * Title of the configuration
+                 */
+                title?: string;
+                /**
+                 * Description of the configuration
+                 */
+                description?: string;
+                /**
+                 * Identifier configuration of the [Integration](#schema_integration)
+                 */
+                identifier: {
+                    linkTemplateScript?: string;
+                    required: boolean;
+                };
+                /**
+                 * Schema of the configuration in the `JSON schema` format. The configuration data is validated against this `JSON schema`.
+                 */
+                schema: {
+                    [k: string]: any;
+                };
+            };
+        };
+        channels: {
+            /**
+             * Channel definition
+             */
+            [k: string]: {
+                /**
+                 * Title of the channel
+                 */
+                title?: string;
+                /**
+                 * Description of the channel
+                 */
+                description?: string;
+                messages: {
+                    /**
+                     * Message definition
+                     */
+                    [k: string]: {
+                        schema: {
+                            [k: string]: any;
+                        };
+                    };
+                };
+                /**
+                 * Conversation object configuration
+                 */
+                conversation: {
+                    tags: {
+                        /**
+                         * Definition of a tag that can be provided on the object
+                         */
+                        [k: string]: {
+                            /**
+                             * Title of the tag
+                             */
+                            title?: string;
+                            /**
+                             * Description of the tag
+                             */
+                            description?: string;
+                        };
+                    };
+                    /**
+                     * The conversation creation setting determines how to create a conversation through the API directly. The integration will have to implement the `createConversation` functionality to support this setting.
+                     */
+                    creation: {
+                        /**
+                         * Enable conversation creation
+                         */
+                        enabled: boolean;
+                        /**
+                         * The list of tags that are required to be specified when calling the API directly to create a conversation.
+                         */
+                        requiredTags: string[];
+                    };
+                };
+                /**
+                 * Message object configuration
+                 */
+                message: {
+                    tags: {
+                        /**
+                         * Definition of a tag that can be provided on the object
+                         */
+                        [k: string]: {
+                            /**
+                             * Title of the tag
+                             */
+                            title?: string;
+                            /**
+                             * Description of the tag
+                             */
+                            description?: string;
+                        };
+                    };
+                };
+            };
+        };
+        states: {
+            /**
+             * State definition
+             */
+            [k: string]: {
+                /**
+                 * Type of the [State](#schema_state) (`conversation`, `user` or `integration`)
+                 */
+                type: "conversation" | "user" | "integration";
+                /**
+                 * Schema of the [State](#schema_state) in the `JSON schema` format. This `JSON schema` is going to be used for validating the state data.
+                 */
+                schema: {
+                    [k: string]: any;
+                };
+            };
+        };
+        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;
+                billable?: boolean;
+                cacheable?: boolean;
+                input: {
+                    schema: {
+                        [k: string]: any;
+                    };
+                };
+                output: {
+                    schema: {
+                        [k: string]: any;
+                    };
+                };
+            };
+        };
+        /**
+         * User object configuration
+         */
+        user: {
+            tags: {
+                /**
+                 * Definition of a tag that can be provided on the object
+                 */
+                [k: string]: {
+                    /**
+                     * Title of the tag
+                     */
+                    title?: string;
+                    /**
+                     * Description of the tag
+                     */
+                    description?: string;
+                };
+            };
+            /**
+             * The user creation setting determines how to create a user through the API directly. The integration will have to implement the `createUser` functionality to support this setting.
+             */
+            creation: {
+                /**
+                 * Enable user creation
+                 */
+                enabled: boolean;
+                /**
+                 * The list of tags that are required to be specified when calling the API directly to create a user.
+                 */
+                requiredTags: string[];
+            };
+        };
+        entities: {
+            /**
+             * Entity definition
+             */
             [k: string]: {
                 /**
-                 * ID of the interface
-                 */
-                id: string;
-                /**
-                 * Name of the interface
+                 * Title of the entity
                  */
-                name: string;
+                title?: string;
                 /**
-                 * Version of the interface
+                 * Description of the entity
                  */
-                version: string;
-                entities: {
-                    [k: string]: {
-                        name: string;
-                    };
-                };
-                actions: {
-                    [k: string]: {
-                        name: string;
-                    };
-                };
-                events: {
-                    [k: string]: {
-                        name: string;
-                    };
-                };
-                channels: {
-                    [k: string]: {
-                        name: string;
-                    };
+                description?: string;
+                schema: {
+                    [k: string]: any;
                 };
             };
         };
         /**
-         * Configuration definition
+         * Indicates if the integration is a development integration; Dev integrations run locally
          */
-        configuration: {
+        dev: boolean;
+        /**
+         * Title of the integration. This is the name that will be displayed in the UI
+         */
+        title: string;
+        /**
+         * Description of the integration. This is the description that will be displayed in the UI
+         */
+        description: string;
+        /**
+         * URL of the icon of the integration. This is the icon that will be displayed in the UI
+         */
+        iconUrl: string;
+        /**
+         * URL of the readme of the integration. This is the readme that will be displayed in the UI
+         */
+        readmeUrl: string;
+        /**
+         * Idicates if the integration is public. Public integrations are available to all and cannot be updated without creating a new version.
+         */
+        public: boolean;
+        /**
+         * Status of the integration version verification
+         */
+        verificationStatus: "unapproved" | "pending" | "approved" | "rejected";
+        /**
+         * Secrets are integration-wide values available in the code via environment variables formatted with a SECRET_ prefix followed by your secret name. A secret name must respect SCREAMING_SNAKE casing.
+         */
+        secrets: string[];
+    };
+}
+
+interface ValidateIntegrationUpdateRequestHeaders {
+}
+interface ValidateIntegrationUpdateRequestQuery {
+}
+interface ValidateIntegrationUpdateRequestParams {
+    id: string;
+}
+interface ValidateIntegrationUpdateRequestBody {
+    /**
+     * Default configuration definition of the integration
+     */
+    configuration?: {
+        /**
+         * Title of the configuration
+         */
+        title?: string;
+        /**
+         * Description of the configuration
+         */
+        description?: string;
+        /**
+         * Schema of the configuration in the `JSON schema` format. The configuration data is validated against this `JSON schema`.
+         */
+        schema?: {
+            [k: string]: any;
+        };
+        identifier?: {
+            linkTemplateScript?: string | null;
+            required?: boolean;
+        };
+    };
+    /**
+     * Additional configuration definitions of the integration
+     */
+    configurations?: {
+        [k: string]: {
             /**
              * Title of the configuration
              */
@@ -7048,272 +7688,267 @@ interface UpdateIntegrationResponse {
              * Description of the configuration
              */
             description?: string;
-            /**
-             * Identifier configuration of the [Integration](#schema_integration)
-             */
-            identifier: {
-                linkTemplateScript?: string;
-                required: boolean;
-            };
             /**
              * Schema of the configuration in the `JSON schema` format. The configuration data is validated against this `JSON schema`.
              */
-            schema: {
+            schema?: {
                 [k: string]: any;
             };
-        };
-        configurations: {
+            identifier?: {
+                linkTemplateScript?: string | null;
+                required?: boolean;
+            };
+        } | null;
+    };
+    channels?: {
+        [k: string]: {
             /**
-             * Configuration definition
+             * Title of the channel
              */
-            [k: string]: {
-                /**
-                 * Title of the configuration
-                 */
-                title?: string;
-                /**
-                 * Description of the configuration
-                 */
-                description?: string;
-                /**
-                 * Identifier configuration of the [Integration](#schema_integration)
-                 */
-                identifier: {
-                    linkTemplateScript?: string;
-                    required: boolean;
-                };
-                /**
-                 * Schema of the configuration in the `JSON schema` format. The configuration data is validated against this `JSON schema`.
-                 */
-                schema: {
-                    [k: string]: any;
-                };
-            };
-        };
-        channels: {
+            title?: string;
             /**
-             * Channel definition
+             * Description of the channel
              */
-            [k: string]: {
+            description?: string;
+            messages?: {
                 /**
-                 * Title of the channel
+                 * Message definition
                  */
-                title?: string;
+                [k: string]: {
+                    schema: {
+                        [k: string]: any;
+                    };
+                } | null;
+            };
+            conversation?: {
                 /**
-                 * Description of the channel
+                 * The conversation creation setting determines how to create a conversation through the API directly. The integration will have to implement the `createConversation` functionality to support this setting.
                  */
-                description?: string;
-                messages: {
+                creation?: {
                     /**
-                     * Message definition
+                     * Enable conversation creation
                      */
-                    [k: string]: {
-                        schema: {
-                            [k: string]: any;
-                        };
-                    };
+                    enabled: boolean;
+                    /**
+                     * The list of tags that are required to be specified when calling the API directly to create a conversation.
+                     */
+                    requiredTags: string[];
                 };
-                /**
-                 * Conversation object configuration
-                 */
-                conversation: {
-                    tags: {
-                        /**
-                         * Definition of a tag that can be provided on the object
-                         */
-                        [k: string]: {
-                            /**
-                             * Title of the tag
-                             */
-                            title?: string;
-                            /**
-                             * Description of the tag
-                             */
-                            description?: string;
-                        };
-                    };
+                tags?: {
                     /**
-                     * The conversation creation setting determines how to create a conversation through the API directly. The integration will have to implement the `createConversation` functionality to support this setting.
+                     * Definition of a tag that can be provided on the object
                      */
-                    creation: {
+                    [k: string]: {
                         /**
-                         * Enable conversation creation
+                         * Title of the tag
                          */
-                        enabled: boolean;
+                        title?: string;
                         /**
-                         * The list of tags that are required to be specified when calling the API directly to create a conversation.
+                         * Description of the tag
                          */
-                        requiredTags: string[];
-                    };
+                        description?: string;
+                    } | null;
                 };
-                /**
-                 * Message object configuration
-                 */
-                message: {
-                    tags: {
+            };
+            message?: {
+                tags?: {
+                    /**
+                     * Definition of a tag that can be provided on the object
+                     */
+                    [k: string]: {
                         /**
-                         * Definition of a tag that can be provided on the object
+                         * Title of the tag
                          */
-                        [k: string]: {
-                            /**
-                             * Title of the tag
-                             */
-                            title?: string;
-                            /**
-                             * Description of the tag
-                             */
-                            description?: string;
-                        };
-                    };
+                        title?: string;
+                        /**
+                         * Description of the tag
+                         */
+                        description?: string;
+                    } | null;
                 };
             };
-        };
-        states: {
+        } | null;
+    };
+    identifier?: {
+        extractScript?: string | null;
+        fallbackHandlerScript?: string | null;
+    };
+    actions?: {
+        /**
+         * Action definition
+         */
+        [k: string]: {
             /**
-             * State definition
+             * Title of the action
              */
-            [k: string]: {
-                /**
-                 * Type of the [State](#schema_state) (`conversation`, `user` or `integration`)
-                 */
-                type: "conversation" | "user" | "integration";
-                /**
-                 * Schema of the [State](#schema_state) in the `JSON schema` format. This `JSON schema` is going to be used for validating the state data.
-                 */
+            title?: string;
+            /**
+             * Description of the action
+             */
+            description?: string;
+            billable?: boolean;
+            cacheable?: boolean;
+            input: {
                 schema: {
                     [k: string]: any;
                 };
             };
-        };
-        events: {
-            /**
-             * Event Definition
-             */
-            [k: string]: {
-                /**
-                 * Title of the event
-                 */
-                title?: string;
-                /**
-                 * Description of the event
-                 */
-                description?: string;
+            output: {
                 schema: {
                     [k: string]: any;
                 };
             };
-        };
-        actions: {
+        } | null;
+    };
+    events?: {
+        /**
+         * Event Definition
+         */
+        [k: string]: {
             /**
-             * Action definition
+             * Title of the event
              */
-            [k: string]: {
-                /**
-                 * Title of the action
-                 */
-                title?: string;
-                /**
-                 * Description of the action
-                 */
-                description?: string;
-                billable?: boolean;
-                cacheable?: boolean;
-                input: {
-                    schema: {
-                        [k: string]: any;
-                    };
-                };
-                output: {
-                    schema: {
-                        [k: string]: any;
-                    };
-                };
+            title?: string;
+            /**
+             * Description of the event
+             */
+            description?: string;
+            schema: {
+                [k: string]: any;
             };
-        };
+        } | null;
+    };
+    states?: {
         /**
-         * User object configuration
+         * State definition
          */
-        user: {
-            tags: {
-                /**
-                 * Definition of a tag that can be provided on the object
-                 */
-                [k: string]: {
-                    /**
-                     * Title of the tag
-                     */
-                    title?: string;
-                    /**
-                     * Description of the tag
-                     */
-                    description?: string;
-                };
-            };
+        [k: string]: {
             /**
-             * The user creation setting determines how to create a user through the API directly. The integration will have to implement the `createUser` functionality to support this setting.
+             * Type of the [State](#schema_state) (`conversation`, `user` or `integration`)
              */
-            creation: {
-                /**
-                 * Enable user creation
-                 */
-                enabled: boolean;
-                /**
-                 * The list of tags that are required to be specified when calling the API directly to create a user.
-                 */
-                requiredTags: string[];
+            type: "conversation" | "user" | "integration";
+            /**
+             * Schema of the [State](#schema_state) in the `JSON schema` format. This `JSON schema` is going to be used for validating the state data.
+             */
+            schema: {
+                [k: string]: any;
             };
+        } | null;
+    };
+    user?: {
+        /**
+         * The user creation setting determines how to create a user through the API directly. The integration will have to implement the `createUser` functionality to support this setting.
+         */
+        creation?: {
+            /**
+             * Enable user creation
+             */
+            enabled: boolean;
+            /**
+             * The list of tags that are required to be specified when calling the API directly to create a user.
+             */
+            requiredTags: string[];
         };
-        entities: {
+        tags?: {
             /**
-             * Entity definition
+             * Definition of a tag that can be provided on the object
              */
             [k: string]: {
                 /**
-                 * Title of the entity
+                 * Title of the tag
                  */
                 title?: string;
                 /**
-                 * Description of the entity
+                 * Description of the tag
                  */
                 description?: string;
-                schema: {
-                    [k: string]: any;
-                };
-            };
+            } | null;
         };
+    };
+    entities?: {
         /**
-         * Indicates if the integration is a development integration; Dev integrations run locally
-         */
-        dev: boolean;
-        /**
-         * Title of the integration. This is the name that will be displayed in the UI
-         */
-        title: string;
-        /**
-         * Description of the integration. This is the description that will be displayed in the UI
-         */
-        description: string;
-        /**
-         * URL of the icon of the integration. This is the icon that will be displayed in the UI
-         */
-        iconUrl: string;
-        /**
-         * URL of the readme of the integration. This is the readme that will be displayed in the UI
-         */
-        readmeUrl: string;
-        /**
-         * Idicates if the integration is public. Public integrations are available to all and cannot be updated without creating a new version.
-         */
-        public: boolean;
-        /**
-         * Status of the integration version verification
-         */
-        verificationStatus: "unapproved" | "pending" | "approved" | "rejected";
-        /**
-         * Secrets are integration-wide values available in the code via environment variables formatted with a SECRET_ prefix followed by your secret name. A secret name must respect SCREAMING_SNAKE casing.
+         * Entity definition
          */
-        secrets: string[];
+        [k: string]: {
+            /**
+             * Title of the entity
+             */
+            title?: string;
+            /**
+             * Description of the entity
+             */
+            description?: string;
+            schema: {
+                [k: string]: any;
+            };
+        } | null;
+    };
+    interfaces?: {
+        [k: string]: {
+            /**
+             * ID of the interface
+             */
+            id: string;
+            entities?: {
+                [k: string]: {
+                    name: string;
+                };
+            };
+            actions?: {
+                [k: string]: {
+                    name: string;
+                };
+            };
+            events?: {
+                [k: string]: {
+                    name: string;
+                };
+            };
+            channels?: {
+                [k: string]: {
+                    name: string;
+                };
+            };
+        } | null;
     };
+    /**
+     * Secrets are integration-wide values available in the code via environment variables formatted with a SECRET_ prefix followed by your secret name. A secret name must respect SCREAMING_SNAKE casing.
+     */
+    secrets?: {
+        [k: string]: string | null;
+    };
+    /**
+     * JavaScript code of the integration
+     */
+    code?: string;
+    /**
+     * Base64 encoded svg of the integration icon. This icon is global to the integration each versions will be updated when this changes.
+     */
+    icon?: string;
+    /**
+     * Base64 encoded markdown of the integration readme. The readme is specific to each integration versions.
+     */
+    readme?: string;
+    /**
+     * Title of the integration. This is the name that will be displayed in the UI
+     */
+    title?: string;
+    /**
+     * Description of the integration. This is the description that will be displayed in the UI
+     */
+    description?: string;
+    /**
+     * URL of the integration
+     */
+    url?: string | null;
+    /**
+     * Idicates if the integration is public. Public integrations are available to all and cannot be updated without creating a new version.
+     */
+    public?: boolean;
+    layers?: string[];
+}
+type ValidateIntegrationUpdateInput = ValidateIntegrationUpdateRequestBody & ValidateIntegrationUpdateRequestHeaders & ValidateIntegrationUpdateRequestQuery & ValidateIntegrationUpdateRequestParams;
+interface ValidateIntegrationUpdateResponse {
 }
 
 interface ListIntegrationsRequestHeaders {
@@ -10458,6 +11093,8 @@ interface ListFilesRequestHeaders {
 }
 interface ListFilesRequestQuery {
     nextToken?: string;
+    sortField?: "key" | "size" | "createdAt" | "updatedAt" | "status";
+    sortDirection?: "asc" | "desc";
     tags?: any;
     /**
      * @maxItems 50
@@ -14312,7 +14949,9 @@ declare class Client$1 {
     readonly createIntegrationApiKey: (input: CreateIntegrationApiKeyInput) => Promise<CreateIntegrationApiKeyResponse>;
     readonly deleteIntegrationApiKey: (input: DeleteIntegrationApiKeyInput) => Promise<DeleteIntegrationApiKeyResponse>;
     readonly createIntegration: (input: CreateIntegrationInput) => Promise<CreateIntegrationResponse>;
+    readonly validateIntegrationCreation: (input: ValidateIntegrationCreationInput) => Promise<ValidateIntegrationCreationResponse>;
     readonly updateIntegration: (input: UpdateIntegrationInput) => Promise<UpdateIntegrationResponse>;
+    readonly validateIntegrationUpdate: (input: ValidateIntegrationUpdateInput) => Promise<ValidateIntegrationUpdateResponse>;
     readonly listIntegrations: (input: ListIntegrationsInput) => Promise<ListIntegrationsResponse>;
     readonly getIntegration: (input: GetIntegrationInput) => Promise<GetIntegrationResponse>;
     readonly getIntegrationLogs: (input: GetIntegrationLogsInput) => Promise<GetIntegrationLogsResponse>;
@@ -14770,6 +15409,9 @@ declare class Lister {
         updatedAt: string;
         name: string;
         deployedAt?: string;
+        tags: {
+            [k: string]: string;
+        };
     }>;
     readonly botIssues: (props: ListInputs["listBotIssues"]) => AsyncCollection<{
         id: string;