@botpress/client 0.16.2 → 0.18.0

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

@@ -0,0 +1,308 @@
+export interface GetBotRequestHeaders {
+}
+export interface GetBotRequestQuery {
+}
+export interface GetBotRequestParams {
+    id: string;
+}
+export interface GetBotRequestBody {
+}
+export type GetBotInput = GetBotRequestBody & GetBotRequestHeaders & GetBotRequestQuery & GetBotRequestParams;
+export type GetBotRequest = {
+    headers: GetBotRequestHeaders;
+    query: GetBotRequestQuery;
+    params: GetBotRequestParams;
+    body: GetBotRequestBody;
+};
+export declare const parseReq: (input: GetBotInput) => GetBotRequest & {
+    path: string;
+};
+export interface GetBotResponse {
+    bot: {
+        /**
+         * Id of the [Bot](#schema_bot)
+         */
+        id: string;
+        /**
+         * Creation date of the [Bot](#schema_bot) in ISO 8601 format
+         */
+        createdAt: string;
+        /**
+         * Updating date of the [Bot](#schema_bot) in ISO 8601 format
+         */
+        updatedAt: string;
+        /**
+         * Signing secret of the [Bot](#schema_bot)
+         */
+        signingSecret: string;
+        /**
+         * A mapping of integrations to their configuration
+         */
+        integrations: {
+            [k: string]: {
+                enabled: boolean;
+                /**
+                 * Name of the [Integration](#schema_integration)
+                 */
+                name: string;
+                /**
+                 * Version of the [Integration](#schema_integration)
+                 */
+                version: string;
+                webhookUrl: string;
+                webhookId: string;
+                identifier?: string;
+                configuration: {
+                    [k: string]: any;
+                };
+                status: "registration_pending" | "registered" | "registration_failed" | "unregistration_pending" | "unregistered" | "unregistration_failed";
+                statusReason: string | null;
+                /**
+                 * 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;
+                /**
+                 * 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;
+                /**
+                 * Idicates if the integration is public. Public integrations are available to all and cannot be updated without creating a new version.
+                 */
+                public: boolean;
+            };
+        };
+        /**
+         * 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;
+                };
+            };
+        };
+        /**
+         * 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;
+                };
+            };
+        };
+        /**
+         * 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;
+                };
+            };
+        };
+        /**
+         * A mapping of states to their definition
+         */
+        states: {
+            [k: string]: {
+                /**
+                 * Type of the [State](#schema_state) (`conversation`, `user`, `bot` or `task`)
+                 */
+                type: "conversation" | "user" | "bot" | "task";
+                /**
+                 * 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;
+                };
+                /**
+                 * Expiry of the [State](#schema_state) in milliseconds. The state will expire if it is idle for the configured value. By default, a state doesn't expire.
+                 */
+                expiry?: number;
+            };
+        };
+        /**
+         * Configuration of the bot
+         */
+        configuration: {
+            /**
+             * Configuration data
+             */
+            data: {
+                [k: string]: any;
+            };
+            /**
+             * Schema of the configuration in the `JSON schema` format. The configuration data is validated against this `JSON schema`.
+             */
+            schema: {
+                [k: string]: any;
+            };
+        };
+        /**
+         * Events definition
+         */
+        events: {
+            /**
+             * Event Definition
+             */
+            [k: string]: {
+                /**
+                 * Title of the event
+                 */
+                title?: string;
+                /**
+                 * Description of the event
+                 */
+                description?: string;
+                schema: {
+                    [k: string]: any;
+                };
+            };
+        };
+        /**
+         * Recurring events
+         */
+        recurringEvents: {
+            [k: string]: {
+                schedule: {
+                    cron: string;
+                };
+                type: string;
+                payload: {
+                    [k: string]: any;
+                };
+                /**
+                 * The number of times the recurring event failed to run. This counter resets once the recurring event runs successfully.
+                 */
+                failedAttempts: number;
+                /**
+                 * The reason why the recurring event failed to run in the last attempt.
+                 */
+                lastFailureReason: string | null;
+            };
+        };
+        /**
+         * Subscriptions of the bot
+         */
+        subscriptions: {
+            /**
+             * Events that the bot is currently subscribed on (ex: "slack:reactionAdded"). If null, the bot is subscribed to all events.
+             */
+            events: {
+                [k: string]: {};
+            } | null;
+        };
+        /**
+         * Actions definition
+         */
+        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;
+                    };
+                };
+            };
+        };
+        /**
+         * Name of the [Bot](#schema_bot)
+         */
+        name: string;
+        /**
+         * Last deployment date of the [Bot](#schema_bot) in the ISO 8601 format
+         */
+        deployedAt?: string;
+        /**
+         * Indicates if the [Bot](#schema_bot) is a development bot; Development bots run locally and can install dev integrations
+         */
+        dev: boolean;
+        /**
+         * Id of the user that created the bot
+         */
+        createdBy?: string;
+        /**
+         * Indicates if the [Bot](#schema_bot) should be in always alive mode
+         */
+        alwaysAlive: boolean;
+        /**
+         * Status of the bot
+         */
+        status: "active" | "deploying";
+        /**
+         * Media files associated with the [Bot](#schema_bot)
+         */
+        medias: {
+            /**
+             * URL of the media file
+             */
+            url: string;
+            /**
+             * Name of the media file
+             */
+            name: string;
+        }[];
+    };
+}

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

@@ -0,0 +1,49 @@
+export interface GetBotAnalyticsRequestHeaders {
+}
+export interface GetBotAnalyticsRequestQuery {
+    startDate: string;
+    endDate: string;
+}
+export interface GetBotAnalyticsRequestParams {
+    id: string;
+}
+export interface GetBotAnalyticsRequestBody {
+}
+export type GetBotAnalyticsInput = GetBotAnalyticsRequestBody & GetBotAnalyticsRequestHeaders & GetBotAnalyticsRequestQuery & GetBotAnalyticsRequestParams;
+export type GetBotAnalyticsRequest = {
+    headers: GetBotAnalyticsRequestHeaders;
+    query: GetBotAnalyticsRequestQuery;
+    params: GetBotAnalyticsRequestParams;
+    body: GetBotAnalyticsRequestBody;
+};
+export declare const parseReq: (input: GetBotAnalyticsInput) => GetBotAnalyticsRequest & {
+    path: string;
+};
+export interface GetBotAnalyticsResponse {
+    records: {
+        /**
+         * ISO 8601 date string of the beginning (inclusive) of the period
+         */
+        startDateTimeUtc: string;
+        /**
+         * ISO 8601 date string of the end (exclusive) of the period
+         */
+        endDateTimeUtc: string;
+        returningUsers: number;
+        newUsers: number;
+        sessions: number;
+        /**
+         * Deprecated. Use `userMessages` instead.
+         */
+        messages: number;
+        userMessages: number;
+        botMessages: number;
+        events: number;
+        eventTypes: {
+            [k: string]: number;
+        };
+        customEvents: {
+            [k: string]: number;
+        };
+    }[];
+}

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

@@ -0,0 +1,30 @@
+export interface GetBotLogsRequestHeaders {
+}
+export interface GetBotLogsRequestQuery {
+    timeStart: string;
+    timeEnd: string;
+    nextToken?: string;
+}
+export interface GetBotLogsRequestParams {
+    id: string;
+}
+export interface GetBotLogsRequestBody {
+}
+export type GetBotLogsInput = GetBotLogsRequestBody & GetBotLogsRequestHeaders & GetBotLogsRequestQuery & GetBotLogsRequestParams;
+export type GetBotLogsRequest = {
+    headers: GetBotLogsRequestHeaders;
+    query: GetBotLogsRequestQuery;
+    params: GetBotLogsRequestParams;
+    body: GetBotLogsRequestBody;
+};
+export declare const parseReq: (input: GetBotLogsInput) => GetBotLogsRequest & {
+    path: string;
+};
+export interface GetBotLogsResponse {
+    logs: {
+        timestamp: string;
+        level: string;
+        message: string;
+    }[];
+    nextToken?: string;
+}

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

@@ -0,0 +1,23 @@
+export interface GetBotWebchatRequestHeaders {
+}
+export interface GetBotWebchatRequestQuery {
+    type: "preconfigured" | "configurable" | "fullscreen" | "sharableUrl";
+}
+export interface GetBotWebchatRequestParams {
+    id: string;
+}
+export interface GetBotWebchatRequestBody {
+}
+export type GetBotWebchatInput = GetBotWebchatRequestBody & GetBotWebchatRequestHeaders & GetBotWebchatRequestQuery & GetBotWebchatRequestParams;
+export type GetBotWebchatRequest = {
+    headers: GetBotWebchatRequestHeaders;
+    query: GetBotWebchatRequestQuery;
+    params: GetBotWebchatRequestParams;
+    body: GetBotWebchatRequestBody;
+};
+export declare const parseReq: (input: GetBotWebchatInput) => GetBotWebchatRequest & {
+    path: string;
+};
+export interface GetBotWebchatResponse {
+    code: string;
+}

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

@@ -0,0 +1,56 @@
+export interface GetConversationRequestHeaders {
+}
+export interface GetConversationRequestQuery {
+}
+export interface GetConversationRequestParams {
+    id: string;
+}
+export interface GetConversationRequestBody {
+}
+export type GetConversationInput = GetConversationRequestBody & GetConversationRequestHeaders & GetConversationRequestQuery & GetConversationRequestParams;
+export type GetConversationRequest = {
+    headers: GetConversationRequestHeaders;
+    query: GetConversationRequestQuery;
+    params: GetConversationRequestParams;
+    body: GetConversationRequestBody;
+};
+export declare const parseReq: (input: GetConversationInput) => GetConversationRequest & {
+    path: string;
+};
+export interface GetConversationResponse {
+    /**
+     * The conversation object represents an exchange of messages between one or more users. A [Conversation](#schema_conversation) is always linked to an integration's channels. For example, a Slack channel represents a conversation.
+     */
+    conversation: {
+        /**
+         * Id of the [Conversation](#schema_conversation)
+         */
+        id: string;
+        /**
+         * Id of the current [Task](#schema_task)
+         */
+        currentTaskId?: string;
+        /**
+         * Creation date of the [Conversation](#schema_conversation) in ISO 8601 format
+         */
+        createdAt: string;
+        /**
+         * Updating date of the [Conversation](#schema_conversation) in ISO 8601 format
+         */
+        updatedAt: string;
+        /**
+         * Name of the channel where the [Conversation](#schema_conversation) is happening
+         */
+        channel: string;
+        /**
+         * Name of the integration that created the [Conversation](#schema_conversation)
+         */
+        integration: 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;
+        };
+    };
+}

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

@@ -0,0 +1,61 @@
+export interface GetEventRequestHeaders {
+}
+export interface GetEventRequestQuery {
+}
+export interface GetEventRequestParams {
+    id: string;
+}
+export interface GetEventRequestBody {
+}
+export type GetEventInput = GetEventRequestBody & GetEventRequestHeaders & GetEventRequestQuery & GetEventRequestParams;
+export type GetEventRequest = {
+    headers: GetEventRequestHeaders;
+    query: GetEventRequestQuery;
+    params: GetEventRequestParams;
+    body: GetEventRequestBody;
+};
+export declare const parseReq: (input: GetEventInput) => GetEventRequest & {
+    path: string;
+};
+export interface GetEventResponse {
+    /**
+     * The event object represents an action or an occurrence.
+     */
+    event: {
+        /**
+         * Id of the [Event](#schema_event)
+         */
+        id: string;
+        /**
+         * Creation date of the [Event](#schema_event) in ISO 8601 format
+         */
+        createdAt: string;
+        /**
+         * Type of the [Event](#schema_event).
+         */
+        type: string;
+        /**
+         * Payload is the content of the event defined by the integration installed on your bot or one of the default events created by our api.
+         */
+        payload: {
+            [k: string]: any;
+        };
+        /**
+         * ID of the [Conversation](#schema_conversation) to link the event to.
+         */
+        conversationId?: string;
+        /**
+         * ID of the [User](#schema_user) to link the event to.
+         */
+        userId?: string;
+        /**
+         * ID of the [Message](#schema_message) to link the event to.
+         */
+        messageId?: string;
+        status: "pending" | "processed" | "ignored" | "failed";
+        /**
+         * Reason why the event failed to be processed
+         */
+        failureReason: string | null;
+    };
+}

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

@@ -0,0 +1,85 @@
+export interface GetFileRequestHeaders {
+}
+export interface GetFileRequestQuery {
+}
+export interface GetFileRequestParams {
+    id: string;
+}
+export interface GetFileRequestBody {
+}
+export type GetFileInput = GetFileRequestBody & GetFileRequestHeaders & GetFileRequestQuery & GetFileRequestParams;
+export type GetFileRequest = {
+    headers: GetFileRequestHeaders;
+    query: GetFileRequestQuery;
+    params: GetFileRequestParams;
+    body: GetFileRequestBody;
+};
+export declare const parseReq: (input: GetFileInput) => GetFileRequest & {
+    path: string;
+};
+export interface GetFileResponse {
+    file: {
+        /**
+         * File ID
+         */
+        id: string;
+        /**
+         * The ID of the bot the file belongs to
+         */
+        botId: string;
+        /**
+         * File name
+         */
+        name: string | null;
+        /**
+         * If the file is not uploaded yet, this will be set to a `null` value.
+         *
+         * If the file has a `public_content` policy, this will contain the permanent public URL to retrieve the file, otherwise this will contain a temporary pre-signed URL to download the file which should be used shortly after retrieving and should not be stored long-term as the URL will expire after a short timeframe.
+         */
+        url: string | null;
+        /**
+         * 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;
+    };
+}