@botpress/client 0.17.0 → 0.18.2

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

@@ -0,0 +1,108 @@
+export interface CreateFileRequestHeaders {
+}
+export interface CreateFileRequestQuery {
+}
+export interface CreateFileRequestParams {
+}
+export interface CreateFileRequestBody {
+    /**
+     * File name
+     */
+    name?: string;
+    /**
+     * File tags as an object of key/value pairs
+     */
+    tags?: {
+        [k: string]: string;
+    };
+    /**
+     * File size in bytes. This will count against your file storage quota. If the `index` parameter is set to `true`, this will also count against your vector database storage quota.
+     */
+    size: number;
+    /**
+     * Set to a value of 'true' to index the file in vector storage. Only PDFs, Office documents, and text-based files are currently supported. Note that if a file is indexed, it will count towards the Vector Storage quota of the workspace rather than the File Storage quota.
+     */
+    index?: boolean;
+    /**
+     * File access policies. Add "public_content" to allow public access to the file content. Add "integrations" to allow read, search and list operations for any integration installed in the bot.
+     */
+    accessPolicies?: ("public_content" | "integrations")[];
+    /**
+     * File content type. If omitted, the content type will be inferred from the file extension. If a type cannot be inferred, the default is "application/octet-stream".
+     */
+    contentType?: string;
+}
+export type CreateFileInput = CreateFileRequestBody & CreateFileRequestHeaders & CreateFileRequestQuery & CreateFileRequestParams;
+export type CreateFileRequest = {
+    headers: CreateFileRequestHeaders;
+    query: CreateFileRequestQuery;
+    params: CreateFileRequestParams;
+    body: CreateFileRequestBody;
+};
+export declare const parseReq: (input: CreateFileInput) => CreateFileRequest & {
+    path: string;
+};
+export interface CreateFileResponse {
+    file: {
+        /**
+         * File ID
+         */
+        id: string;
+        /**
+         * The ID of the bot the file belongs to
+         */
+        botId: string;
+        /**
+         * File name
+         */
+        name: string | null;
+        /**
+         * File size in bytes. Non-null if file upload status is "COMPLETE".
+         */
+        size: number | null;
+        /**
+         * MIME type of the file's content
+         */
+        contentType: string;
+        /**
+         * The tags of the file as an object of key/value pairs
+         */
+        tags: {
+            [k: string]: string;
+        };
+        /**
+         * File creation timestamp in ISO 8601 format
+         */
+        createdAt: string;
+        /**
+         * File last update timestamp in ISO 8601 format
+         */
+        updatedAt: string;
+        /**
+         * Access policies configured for the file.
+         */
+        accessPolicies: ("integrations" | "public_content")[];
+        /**
+         * Whether the file was requested to be indexed for search or not.
+         */
+        index: boolean;
+        /**
+         * Status of the file. If the status is "upload_pending", the file content has not been uploaded yet. The status will be set to "upload_completed" once the file content has been uploaded successfully.
+         *
+         * If the upload failed for any reason (e.g. exceeding the storage quota or the maximum file size limit) the status will be set to "upload_failed" and the reason for the failure will be available in the `failedStatusReason` field of the file.
+         *
+         * However, if the file has been uploaded and the `index` attribute was set to `true` on the file, the status will immediately transition to the "indexing_pending" status (the "upload_completed" status step will be skipped).
+         *
+         * Once the indexing is completed and the file is ready to be used for searching its status will be set to "indexing_completed". If the indexing failed the status will be set to "indexing_failed" and the reason for the failure will be available in the `failedStatusReason` field.
+         */
+        status: "upload_pending" | "upload_failed" | "upload_completed" | "indexing_pending" | "indexing_failed" | "indexing_completed";
+        /**
+         * If the file status is "upload_failed" or "indexing_failed" this will contain the reason of the failure.
+         */
+        failedStatusReason?: string;
+        /**
+         * URL to upload the file content. File content needs to be sent to this URL via a PUT request.
+         */
+        uploadUrl: string;
+    };
+}

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

@@ -0,0 +1,533 @@
+export interface CreateIntegrationRequestHeaders {
+}
+export interface CreateIntegrationRequestQuery {
+}
+export interface CreateIntegrationRequestParams {
+}
+export interface CreateIntegrationRequestBody {
+    /**
+     * Name of the [Integration](#schema_integration)
+     */
+    name: string;
+    /**
+     * Version of the [Integration](#schema_integration)
+     */
+    version: string;
+    configuration?: {
+        /**
+         * Schema of the configuration in the `JSON schema` format. The configuration data is validated against this `JSON schema`.
+         */
+        schema?: {
+            [k: string]: any;
+        };
+        identifier?: {
+            required?: boolean;
+            linkTemplateScript?: 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;
+                };
+            };
+        };
+    };
+    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]: {
+            /**
+             * Title of the channel
+             */
+            title?: string;
+            /**
+             * Description of the channel
+             */
+            description?: string;
+            messages: {
+                /**
+                 * Message definition
+                 */
+                [k: string]: {
+                    schema: {
+                        [k: string]: any;
+                    };
+                };
+            };
+            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;
+                    };
+                };
+            };
+            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;
+                    };
+                };
+            };
+        };
+    };
+    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;
+            };
+        };
+    };
+    /**
+     * 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;
+    };
+    /**
+     * 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.
+     */
+    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;
+    /**
+     * Idicates if the integration is public. Public integrations are available to all and cannot be updated without creating a new version.
+     */
+    public?: boolean;
+}
+export type CreateIntegrationInput = CreateIntegrationRequestBody & CreateIntegrationRequestHeaders & CreateIntegrationRequestQuery & CreateIntegrationRequestParams;
+export type CreateIntegrationRequest = {
+    headers: CreateIntegrationRequestHeaders;
+    query: CreateIntegrationRequestQuery;
+    params: CreateIntegrationRequestParams;
+    body: CreateIntegrationRequestBody;
+};
+export declare const parseReq: (input: CreateIntegrationInput) => CreateIntegrationRequest & {
+    path: string;
+};
+export interface CreateIntegrationResponse {
+    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/createIntegrationApiKey.d.ts

@@ -0,0 +1,29 @@
+export interface CreateIntegrationApiKeyRequestHeaders {
+}
+export interface CreateIntegrationApiKeyRequestQuery {
+}
+export interface CreateIntegrationApiKeyRequestParams {
+}
+export interface CreateIntegrationApiKeyRequestBody {
+    integrationId: string;
+    note?: string;
+}
+export type CreateIntegrationApiKeyInput = CreateIntegrationApiKeyRequestBody & CreateIntegrationApiKeyRequestHeaders & CreateIntegrationApiKeyRequestQuery & CreateIntegrationApiKeyRequestParams;
+export type CreateIntegrationApiKeyRequest = {
+    headers: CreateIntegrationApiKeyRequestHeaders;
+    query: CreateIntegrationApiKeyRequestQuery;
+    params: CreateIntegrationApiKeyRequestParams;
+    body: CreateIntegrationApiKeyRequestBody;
+};
+export declare const parseReq: (input: CreateIntegrationApiKeyInput) => CreateIntegrationApiKeyRequest & {
+    path: string;
+};
+export interface CreateIntegrationApiKeyResponse {
+    id: string;
+    createdAt: string;
+    note: string;
+    /**
+     * The IAK value. This will only be returned here when created and cannot be retrieved later.
+     */
+    value: string;
+}