@botpress/client 0.17.0 → 0.18.2

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

@@ -0,0 +1,98 @@
+export interface CreateMessageRequestHeaders {
+}
+export interface CreateMessageRequestQuery {
+}
+export interface CreateMessageRequestParams {
+}
+export interface CreateMessageRequestBody {
+    /**
+     * 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;
+    };
+    /**
+     * ID of the [User](#schema_user)
+     */
+    userId: string;
+    /**
+     * ID of the [Conversation](#schema_conversation)
+     */
+    conversationId: string;
+    /**
+     * Type of the [Message](#schema_message) represents the resource type that the message is related to
+     */
+    type: string;
+    /**
+     * Set of [Tags](/docs/developers/concepts/tags) that you can attach to a [Message](#schema_message). The set of [Tags](/docs/developers/concepts/tags) available on a [Message](#schema_message) 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;
+    };
+    /**
+     * Schedule the Message to be sent at a specific time. Either dateTime or delay must be provided.
+     */
+    schedule?: {
+        /**
+         * When the [Message](#schema_message) will be sent, in the ISO 8601 format
+         */
+        dateTime?: string;
+        /**
+         * Delay in milliseconds before sending the [Message](#schema_message)
+         */
+        delay?: number;
+    };
+}
+export type CreateMessageInput = CreateMessageRequestBody & CreateMessageRequestHeaders & CreateMessageRequestQuery & CreateMessageRequestParams;
+export type CreateMessageRequest = {
+    headers: CreateMessageRequestHeaders;
+    query: CreateMessageRequestQuery;
+    params: CreateMessageRequestParams;
+    body: CreateMessageRequestBody;
+};
+export declare const parseReq: (input: CreateMessageInput) => CreateMessageRequest & {
+    path: string;
+};
+export interface CreateMessageResponse {
+    /**
+     * 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;
+        };
+    };
+}

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

@@ -0,0 +1,33 @@
+export interface CreatePersonalAccessTokenRequestHeaders {
+}
+export interface CreatePersonalAccessTokenRequestQuery {
+}
+export interface CreatePersonalAccessTokenRequestParams {
+}
+export interface CreatePersonalAccessTokenRequestBody {
+    /**
+     * Note to identify the PAT
+     */
+    note: string;
+}
+export type CreatePersonalAccessTokenInput = CreatePersonalAccessTokenRequestBody & CreatePersonalAccessTokenRequestHeaders & CreatePersonalAccessTokenRequestQuery & CreatePersonalAccessTokenRequestParams;
+export type CreatePersonalAccessTokenRequest = {
+    headers: CreatePersonalAccessTokenRequestHeaders;
+    query: CreatePersonalAccessTokenRequestQuery;
+    params: CreatePersonalAccessTokenRequestParams;
+    body: CreatePersonalAccessTokenRequestBody;
+};
+export declare const parseReq: (input: CreatePersonalAccessTokenInput) => CreatePersonalAccessTokenRequest & {
+    path: string;
+};
+export interface CreatePersonalAccessTokenResponse {
+    pat: {
+        id: string;
+        createdAt: string;
+        note: string;
+        /**
+         * The PAT value. This will only be returned here when created and cannot be retrieved later.
+         */
+        value: string;
+    };
+}

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

@@ -0,0 +1,151 @@
+export interface CreateTableRequestHeaders {
+}
+export interface CreateTableRequestQuery {
+}
+export interface CreateTableRequestParams {
+}
+export interface CreateTableRequestBody {
+    /**
+     * Required. This name is used to identify your table.
+     */
+    name: string;
+    /**
+     * The 'factor' multiplies the row's data storage limit by 4KB and its quota count, but can only be set at table creation and not modified later. For instance, a factor of 2 increases storage to 8KB but counts as 2 rows in your quota. The default factor is 1.
+     */
+    factor?: number;
+    /**
+     * A table designated as "frozen" is immutable in terms of its name and schema structure; modifications to its schema or a renaming operation are not permitted. The only action that can be taken on such a table is deletion. The schema established at the time of creation is locked in as the final structure. To implement any changes, the table must be duplicated with the desired alterations.
+     */
+    frozen?: boolean;
+    /**
+     * Provide an object or a JSON schema to define the columns of the table. A maximum of 20 keys in the object/schema is allowed.
+     */
+    schema: {
+        [k: string]: any;
+    };
+    /**
+     * Optional tags to help organize your tables. These should be passed here as an object representing key/value pairs.
+     */
+    tags?: {
+        [k: string]: string;
+    };
+    /**
+     * Indicates if the table is enabled for computation.
+     */
+    isComputeEnabled?: boolean;
+}
+export type CreateTableInput = CreateTableRequestBody & CreateTableRequestHeaders & CreateTableRequestQuery & CreateTableRequestParams;
+export type CreateTableRequest = {
+    headers: CreateTableRequestHeaders;
+    query: CreateTableRequestQuery;
+    params: CreateTableRequestParams;
+    body: CreateTableRequestBody;
+};
+export declare const parseReq: (input: CreateTableInput) => CreateTableRequest & {
+    path: string;
+};
+export interface CreateTableResponse {
+    table: {
+        /**
+         * Unique identifier for the table
+         */
+        id: string;
+        /**
+         * Required. This name is used to identify your table.
+         */
+        name: string;
+        /**
+         * The 'factor' multiplies the row's data storage limit by 4KB and its quota count, but can only be set at table creation and not modified later. For instance, a factor of 2 increases storage to 8KB but counts as 2 rows in your quota. The default factor is 1.
+         */
+        factor?: number;
+        /**
+         * A table designated as "frozen" is immutable in terms of its name and schema structure; modifications to its schema or a renaming operation are not permitted. The only action that can be taken on such a table is deletion. The schema established at the time of creation is locked in as the final structure. To implement any changes, the table must be duplicated with the desired alterations.
+         */
+        frozen?: boolean;
+        schema: {
+            $schema: string;
+            /**
+             * List of keys/columns in the table.
+             */
+            properties: {
+                [k: string]: {
+                    type: "string" | "number" | "boolean" | "object" | "null";
+                    format?: "date-time";
+                    description?: string;
+                    nullable?: boolean;
+                    "x-zui": {
+                        index: number;
+                        /**
+                         * [deprecated] ID of the column.
+                         */
+                        id?: string;
+                        /**
+                         * Indicates if the column is vectorized and searchable.
+                         */
+                        searchable?: boolean;
+                        /**
+                         * Indicates if the field is hidden in the UI
+                         */
+                        hidden?: boolean;
+                        /**
+                         * Order of the column in the UI
+                         */
+                        order?: number;
+                        /**
+                         * Width of the column in the UI
+                         */
+                        width?: number;
+                        computed?: {
+                            action: "ai" | "code";
+                            dependencies?: string[];
+                            /**
+                             * Prompt when action is "ai"
+                             */
+                            prompt?: string;
+                            /**
+                             * Model to use when action is "ai"
+                             */
+                            model?: "gpt-3.5-turbo" | "gpt-3.5-turbo-0125" | "gpt-3.5-turbo-1106" | "gpt-3.5-turbo-16k" | "gpt-4o" | "gpt-4" | "gpt-4-turbo" | "gpt-4-0125-preview" | "gpt-4-1106-preview";
+                            /**
+                             * Code to execute when action is "code"
+                             */
+                            code?: string;
+                            enabled?: boolean;
+                        };
+                        /**
+                         * TypeScript typings for the column. Recommended if the type is "object", ex: "\{ foo: string; bar: number \}"
+                         */
+                        typings?: string;
+                    };
+                };
+            };
+            /**
+             * Additional properties can be provided, but they will be ignored if no column matches.
+             */
+            additionalProperties: true;
+            /**
+             * Array of required properties.
+             */
+            required?: string[];
+            type: "object";
+        };
+        /**
+         * Optional tags to help organize your tables. These should be passed here as an object representing key/value pairs.
+         */
+        tags?: {
+            [k: string]: string;
+        };
+        /**
+         * Indicates if the table is enabled for computation.
+         */
+        isComputeEnabled?: boolean;
+        /**
+         * Timestamp of table creation.
+         */
+        createdAt?: string;
+        /**
+         * Timestamp of the last table update.
+         */
+        updatedAt?: string;
+    };
+}

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

@@ -0,0 +1,71 @@
+export interface CreateTableRowsRequestHeaders {
+}
+export interface CreateTableRowsRequestQuery {
+}
+export interface CreateTableRowsRequestParams {
+    table: string;
+}
+export interface CreateTableRowsRequestBody {
+    /**
+     * @minItems 1
+     * @maxItems 1000
+     */
+    rows: {
+        [k: string]: any;
+    }[];
+    /**
+     * Ensure computed columns are fully processed before returning the result. This is applicable only when the number of rows involved is fewer than 1.
+     */
+    waitComputed?: boolean;
+}
+export type CreateTableRowsInput = CreateTableRowsRequestBody & CreateTableRowsRequestHeaders & CreateTableRowsRequestQuery & CreateTableRowsRequestParams;
+export type CreateTableRowsRequest = {
+    headers: CreateTableRowsRequestHeaders;
+    query: CreateTableRowsRequestQuery;
+    params: CreateTableRowsRequestParams;
+    body: CreateTableRowsRequestBody;
+};
+export declare const parseReq: (input: CreateTableRowsInput) => CreateTableRowsRequest & {
+    path: string;
+};
+export interface CreateTableRowsResponse {
+    rows: {
+        /**
+         * Unique identifier for the row.
+         */
+        id: number;
+        /**
+         * Timestamp of row creation.
+         */
+        createdAt?: string;
+        /**
+         * Timestamp of the last row update.
+         */
+        updatedAt?: string;
+        computed: {
+            [k: string]: {
+                status: string;
+                error?: string;
+                updatedBy?: string;
+                updatedAt?: string;
+            };
+        };
+        /**
+         * [Read-only] List of stale values that are waiting to be recomputed.
+         */
+        stale?: string[];
+        /**
+         * Optional numeric value indicating similarity, when using findTableRows.
+         */
+        similarity?: number;
+        [k: string]: any;
+    }[];
+    /**
+     * Alerts for minor issues that don't block the operation but suggest possible improvements.
+     */
+    warnings?: string[];
+    /**
+     * Critical issues in specific elements that prevent their successful processing, allowing partial operation success.
+     */
+    errors?: string[];
+}

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

@@ -0,0 +1,125 @@
+export interface CreateTaskRequestHeaders {
+}
+export interface CreateTaskRequestQuery {
+}
+export interface CreateTaskRequestParams {
+}
+export interface CreateTaskRequestBody {
+    /**
+     * Title describing the task
+     */
+    title?: string;
+    /**
+     * All the notes related to the execution of the current task
+     */
+    description?: string;
+    /**
+     * Type of the task
+     */
+    type: string;
+    /**
+     * Content related to the task
+     */
+    data?: {
+        [k: string]: any;
+    };
+    /**
+     * Parent task id is the parent task that created this task
+     */
+    parentTaskId?: string;
+    /**
+     * Conversation id related to this task
+     */
+    conversationId: string;
+    /**
+     * Specific user related to this task
+     */
+    userId?: string;
+    /**
+     * The timeout date where the task should be failed in the ISO 8601 format
+     */
+    timeoutAt?: string;
+    /**
+     * Tags for the [Task](#schema_task)
+     */
+    tags?: {
+        [k: string]: string;
+    };
+}
+export type CreateTaskInput = CreateTaskRequestBody & CreateTaskRequestHeaders & CreateTaskRequestQuery & CreateTaskRequestParams;
+export type CreateTaskRequest = {
+    headers: CreateTaskRequestHeaders;
+    query: CreateTaskRequestQuery;
+    params: CreateTaskRequestParams;
+    body: CreateTaskRequestBody;
+};
+export declare const parseReq: (input: CreateTaskInput) => CreateTaskRequest & {
+    path: string;
+};
+export interface CreateTaskResponse {
+    /**
+     * Task definition
+     */
+    task: {
+        /**
+         * Id of the [Task](#schema_task)
+         */
+        id: string;
+        /**
+         * Title describing the task
+         */
+        title: string;
+        /**
+         * All the notes related to the execution of the current task
+         */
+        description: string;
+        /**
+         * Type of the task
+         */
+        type: string;
+        /**
+         * Content related to the task
+         */
+        data: {
+            [k: string]: any;
+        };
+        /**
+         * Status of the task
+         */
+        status: "pending" | "in_progress" | "failed" | "completed" | "blocked" | "paused" | "timeout" | "cancelled";
+        /**
+         * Parent task id is the parent task that created this task
+         */
+        parentTaskId?: string;
+        /**
+         * Conversation id related to this task
+         */
+        conversationId?: string;
+        /**
+         * Specific user related to this task
+         */
+        userId?: string;
+        /**
+         * The timeout date where the task should be failed in the ISO 8601 format
+         */
+        timeoutAt: string;
+        /**
+         * Creation date of the task in ISO 8601 format
+         */
+        createdAt: string;
+        /**
+         * Updating date of the task in ISO 8601 format
+         */
+        updatedAt: string;
+        /**
+         * If the task fails this is the reason behind it
+         */
+        failureReason?: string;
+        /**
+         * Set of [Tags](/docs/developers/concepts/tags) that you can attach to a [Task](#schema_task). Individual keys can be unset by posting an empty value to them.
+         */
+        tags: {
+            [k: string]: string;
+        };
+    };
+}

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

@@ -0,0 +1,70 @@
+export interface CreateUserRequestHeaders {
+}
+export interface CreateUserRequestQuery {
+}
+export interface CreateUserRequestParams {
+}
+export interface CreateUserRequestBody {
+    /**
+     * Tags for the [User](#schema_user)
+     */
+    tags: {
+        [k: string]: string;
+    };
+    /**
+     * @deprecated
+     * [DEPRECATED] To create a [User](#schema_user) from within a bot, call an action of the integration instead.
+     */
+    integrationName?: string;
+    /**
+     * Name of the user
+     */
+    name?: string;
+    /**
+     * URI of the user picture
+     */
+    pictureUrl?: string;
+}
+export type CreateUserInput = CreateUserRequestBody & CreateUserRequestHeaders & CreateUserRequestQuery & CreateUserRequestParams;
+export type CreateUserRequest = {
+    headers: CreateUserRequestHeaders;
+    query: CreateUserRequestQuery;
+    params: CreateUserRequestParams;
+    body: CreateUserRequestBody;
+};
+export declare const parseReq: (input: CreateUserInput) => CreateUserRequest & {
+    path: string;
+};
+export interface CreateUserResponse {
+    /**
+     * The user object represents someone interacting with the bot within a specific integration. The same person interacting with a bot in slack and messenger will be represented with two different users.
+     */
+    user: {
+        /**
+         * Id of the [User](#schema_user)
+         */
+        id: string;
+        /**
+         * Creation date of the [User](#schema_user) in ISO 8601 format
+         */
+        createdAt: string;
+        /**
+         * Updating date of the [User](#schema_user) in ISO 8601 format
+         */
+        updatedAt: string;
+        /**
+         * Set of [Tags](/docs/developers/concepts/tags) that you can attach to a [User](#schema_user). The set of [Tags](/docs/developers/concepts/tags) available on a [User](#schema_user) 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;
+        };
+        /**
+         * Name of the [User](#schema_user)
+         */
+        name?: string;
+        /**
+         * Picture URL of the [User](#schema_user)
+         */
+        pictureUrl?: string;
+    };
+}

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

@@ -0,0 +1,38 @@
+export interface CreateWorkspaceRequestHeaders {
+}
+export interface CreateWorkspaceRequestQuery {
+}
+export interface CreateWorkspaceRequestParams {
+}
+export interface CreateWorkspaceRequestBody {
+    name: string;
+}
+export type CreateWorkspaceInput = CreateWorkspaceRequestBody & CreateWorkspaceRequestHeaders & CreateWorkspaceRequestQuery & CreateWorkspaceRequestParams;
+export type CreateWorkspaceRequest = {
+    headers: CreateWorkspaceRequestHeaders;
+    query: CreateWorkspaceRequestQuery;
+    params: CreateWorkspaceRequestParams;
+    body: CreateWorkspaceRequestBody;
+};
+export declare const parseReq: (input: CreateWorkspaceInput) => CreateWorkspaceRequest & {
+    path: string;
+};
+export interface CreateWorkspaceResponse {
+    id: string;
+    name: string;
+    ownerId: string;
+    createdAt: string;
+    updatedAt: string;
+    botCount: number;
+    billingVersion: "v1" | "v2";
+    plan: "community" | "team" | "enterprise";
+    blocked: boolean;
+    spendingLimit: number;
+    about?: string;
+    profilePicture?: string;
+    contactEmail?: string;
+    website?: string;
+    socialAccounts?: string[];
+    isPublic?: boolean;
+    handle?: string;
+}

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

@@ -0,0 +1,27 @@
+export interface CreateWorkspaceMemberRequestHeaders {
+}
+export interface CreateWorkspaceMemberRequestQuery {
+}
+export interface CreateWorkspaceMemberRequestParams {
+}
+export interface CreateWorkspaceMemberRequestBody {
+    email: string;
+    role: "viewer" | "billing" | "developer" | "manager" | "administrator" | "owner";
+}
+export type CreateWorkspaceMemberInput = CreateWorkspaceMemberRequestBody & CreateWorkspaceMemberRequestHeaders & CreateWorkspaceMemberRequestQuery & CreateWorkspaceMemberRequestParams;
+export type CreateWorkspaceMemberRequest = {
+    headers: CreateWorkspaceMemberRequestHeaders;
+    query: CreateWorkspaceMemberRequestQuery;
+    params: CreateWorkspaceMemberRequestParams;
+    body: CreateWorkspaceMemberRequestBody;
+};
+export declare const parseReq: (input: CreateWorkspaceMemberInput) => CreateWorkspaceMemberRequest & {
+    path: string;
+};
+export interface CreateWorkspaceMemberResponse {
+    id: string;
+    userId?: string;
+    email: string;
+    createdAt: string;
+    role: "viewer" | "billing" | "developer" | "manager" | "administrator" | "owner";
+}

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

@@ -0,0 +1,21 @@
+export interface DeleteBotRequestHeaders {
+}
+export interface DeleteBotRequestQuery {
+}
+export interface DeleteBotRequestParams {
+    id: string;
+}
+export interface DeleteBotRequestBody {
+}
+export type DeleteBotInput = DeleteBotRequestBody & DeleteBotRequestHeaders & DeleteBotRequestQuery & DeleteBotRequestParams;
+export type DeleteBotRequest = {
+    headers: DeleteBotRequestHeaders;
+    query: DeleteBotRequestQuery;
+    params: DeleteBotRequestParams;
+    body: DeleteBotRequestBody;
+};
+export declare const parseReq: (input: DeleteBotInput) => DeleteBotRequest & {
+    path: string;
+};
+export interface DeleteBotResponse {
+}

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

@@ -0,0 +1,22 @@
+export interface DeleteBotIssueRequestHeaders {
+}
+export interface DeleteBotIssueRequestQuery {
+}
+export interface DeleteBotIssueRequestParams {
+    id: string;
+    issueId: string;
+}
+export interface DeleteBotIssueRequestBody {
+}
+export type DeleteBotIssueInput = DeleteBotIssueRequestBody & DeleteBotIssueRequestHeaders & DeleteBotIssueRequestQuery & DeleteBotIssueRequestParams;
+export type DeleteBotIssueRequest = {
+    headers: DeleteBotIssueRequestHeaders;
+    query: DeleteBotIssueRequestQuery;
+    params: DeleteBotIssueRequestParams;
+    body: DeleteBotIssueRequestBody;
+};
+export declare const parseReq: (input: DeleteBotIssueInput) => DeleteBotIssueRequest & {
+    path: string;
+};
+export interface DeleteBotIssueResponse {
+}

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

@@ -0,0 +1,21 @@
+export interface DeleteConversationRequestHeaders {
+}
+export interface DeleteConversationRequestQuery {
+}
+export interface DeleteConversationRequestParams {
+    id: string;
+}
+export interface DeleteConversationRequestBody {
+}
+export type DeleteConversationInput = DeleteConversationRequestBody & DeleteConversationRequestHeaders & DeleteConversationRequestQuery & DeleteConversationRequestParams;
+export type DeleteConversationRequest = {
+    headers: DeleteConversationRequestHeaders;
+    query: DeleteConversationRequestQuery;
+    params: DeleteConversationRequestParams;
+    body: DeleteConversationRequestBody;
+};
+export declare const parseReq: (input: DeleteConversationInput) => DeleteConversationRequest & {
+    path: string;
+};
+export interface DeleteConversationResponse {
+}