@botpress/client 0.16.2 → 0.18.0

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

@@ -0,0 +1,295 @@
+export interface GetIntegrationRequestHeaders {
+}
+export interface GetIntegrationRequestQuery {
+}
+export interface GetIntegrationRequestParams {
+    id: string;
+}
+export interface GetIntegrationRequestBody {
+}
+export type GetIntegrationInput = GetIntegrationRequestBody & GetIntegrationRequestHeaders & GetIntegrationRequestQuery & GetIntegrationRequestParams;
+export type GetIntegrationRequest = {
+    headers: GetIntegrationRequestHeaders;
+    query: GetIntegrationRequestQuery;
+    params: GetIntegrationRequestParams;
+    body: GetIntegrationRequestBody;
+};
+export declare const parseReq: (input: GetIntegrationInput) => GetIntegrationRequest & {
+    path: string;
+};
+export interface GetIntegrationResponse {
+    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;
+        /**
+         * Configuration definition
+         */
+        configuration: {
+            /**
+             * 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;
+                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]: {
+                /**
+                 * Title of the entity
+                 */
+                title?: string;
+                /**
+                 * Description of the entity
+                 */
+                description?: string;
+                schema: {
+                    [k: string]: any;
+                };
+            };
+        };
+        /**
+         * 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;
+        /**
+         * 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[];
+    };
+}

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

@@ -0,0 +1,296 @@
+export interface GetIntegrationByNameRequestHeaders {
+}
+export interface GetIntegrationByNameRequestQuery {
+}
+export interface GetIntegrationByNameRequestParams {
+    name: string;
+    version: string;
+}
+export interface GetIntegrationByNameRequestBody {
+}
+export type GetIntegrationByNameInput = GetIntegrationByNameRequestBody & GetIntegrationByNameRequestHeaders & GetIntegrationByNameRequestQuery & GetIntegrationByNameRequestParams;
+export type GetIntegrationByNameRequest = {
+    headers: GetIntegrationByNameRequestHeaders;
+    query: GetIntegrationByNameRequestQuery;
+    params: GetIntegrationByNameRequestParams;
+    body: GetIntegrationByNameRequestBody;
+};
+export declare const parseReq: (input: GetIntegrationByNameInput) => GetIntegrationByNameRequest & {
+    path: string;
+};
+export interface GetIntegrationByNameResponse {
+    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;
+        /**
+         * Configuration definition
+         */
+        configuration: {
+            /**
+             * 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;
+                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]: {
+                /**
+                 * Title of the entity
+                 */
+                title?: string;
+                /**
+                 * Description of the entity
+                 */
+                description?: string;
+                schema: {
+                    [k: string]: any;
+                };
+            };
+        };
+        /**
+         * 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;
+        /**
+         * 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[];
+    };
+}

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

@@ -0,0 +1,30 @@
+export interface GetIntegrationLogsRequestHeaders {
+}
+export interface GetIntegrationLogsRequestQuery {
+    timeStart: string;
+    timeEnd: string;
+    nextToken?: string;
+}
+export interface GetIntegrationLogsRequestParams {
+    id: string;
+}
+export interface GetIntegrationLogsRequestBody {
+}
+export type GetIntegrationLogsInput = GetIntegrationLogsRequestBody & GetIntegrationLogsRequestHeaders & GetIntegrationLogsRequestQuery & GetIntegrationLogsRequestParams;
+export type GetIntegrationLogsRequest = {
+    headers: GetIntegrationLogsRequestHeaders;
+    query: GetIntegrationLogsRequestQuery;
+    params: GetIntegrationLogsRequestParams;
+    body: GetIntegrationLogsRequestBody;
+};
+export declare const parseReq: (input: GetIntegrationLogsInput) => GetIntegrationLogsRequest & {
+    path: string;
+};
+export interface GetIntegrationLogsResponse {
+    logs: {
+        timestamp: string;
+        level: string;
+        message: string;
+    }[];
+    nextToken?: string;
+}

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

@@ -0,0 +1,62 @@
+export interface GetMessageRequestHeaders {
+}
+export interface GetMessageRequestQuery {
+}
+export interface GetMessageRequestParams {
+    id: string;
+}
+export interface GetMessageRequestBody {
+}
+export type GetMessageInput = GetMessageRequestBody & GetMessageRequestHeaders & GetMessageRequestQuery & GetMessageRequestParams;
+export type GetMessageRequest = {
+    headers: GetMessageRequestHeaders;
+    query: GetMessageRequestQuery;
+    params: GetMessageRequestParams;
+    body: GetMessageRequestBody;
+};
+export declare const parseReq: (input: GetMessageInput) => GetMessageRequest & {
+    path: string;
+};
+export interface GetMessageResponse {
+    /**
+     * The Message object represents a message in a [Conversation](#schema_conversation) for a specific [User](#schema_user).
+     */
+    message: {
+        /**
+         * Id of the [Message](#schema_message)
+         */
+        id: string;
+        /**
+         * Creation date of the [Message](#schema_message) in ISO 8601 format
+         */
+        createdAt: string;
+        /**
+         * Type of the [Message](#schema_message) represents the resource type that the message is related to
+         */
+        type: string;
+        /**
+         * Payload is the content type of the message. Accepted payload options: Text, Image, Choice, Dropdown, Card, Carousel, File, Audio, Video, Location
+         */
+        payload: {
+            [k: string]: any;
+        };
+        /**
+         * Direction of the message (`incoming` or `outgoing`).
+         */
+        direction: "incoming" | "outgoing";
+        /**
+         * ID of the [User](#schema_user)
+         */
+        userId: string;
+        /**
+         * ID of the [Conversation](#schema_conversation)
+         */
+        conversationId: string;
+        /**
+         * Set of [Tags](/docs/developers/concepts/tags) that you can attach to a [Conversation](#schema_conversation). The set of [Tags](/docs/developers/concepts/tags) available on a [Conversation](#schema_conversation) is restricted by the list of [Tags](/docs/developers/concepts/tags) defined previously by the [Bot](#schema_bot). Individual keys can be unset by posting an empty value to them.
+         */
+        tags: {
+            [k: string]: string;
+        };
+    };
+}