@botpress/sdk 2.5.0 → 3.0.1

package/.turbo/turbo-build.log

@@ -1,12 +1,18 @@
 
-> @botpress/sdk@2.5.0 build /home/runner/work/botpress/botpress/packages/sdk
-> pnpm build:type && pnpm build:node
+> @botpress/sdk@3.0.1 build /home/runner/work/botpress/botpress/packages/sdk
+> pnpm build:type && pnpm build:node && pnpm build:browser
 
 
-> @botpress/sdk@2.5.0 build:type /home/runner/work/botpress/botpress/packages/sdk
+> @botpress/sdk@3.0.1 build:type /home/runner/work/botpress/botpress/packages/sdk
 > tsc --emitDeclarationOnly --declaration
 
 
-> @botpress/sdk@2.5.0 build:node /home/runner/work/botpress/botpress/packages/sdk
-> ts-node -T build.ts
+> @botpress/sdk@3.0.1 build:node /home/runner/work/botpress/botpress/packages/sdk
+> ts-node -T ./build.ts --node
 
+Done
+
+> @botpress/sdk@3.0.1 build:browser /home/runner/work/botpress/botpress/packages/sdk
+> ts-node -T ./build.ts --browser
+
+Done

package/dist/bot/client/index.d.ts

@@ -42,6 +42,12 @@ export declare class BotSpecificClient<TBot extends common.BaseBot> implements t
     updateFileMetadata: types.UpdateFileMetadata<TBot>;
     searchFiles: types.SearchFiles<TBot>;
     trackAnalytics: types.TrackAnalytics<TBot>;
+    getTableRow: types.GetTableRow<TBot>;
+    createTableRows: types.CreateTableRows<TBot>;
+    findTableRows: types.FindTableRows<TBot>;
+    deleteTableRows: types.DeleteTableRows<TBot>;
+    updateTableRows: types.UpdateTableRows<TBot>;
+    upsertTableRows: types.UpsertTableRows<TBot>;
     /**
      * @deprecated Use `callAction` to delegate the conversation creation to an integration.
      */

package/dist/bot/client/types.d.ts

@@ -86,6 +86,87 @@ export type ListFiles<_TBot extends common.BaseBot> = client.Client['listFiles']
 export type GetFile<_TBot extends common.BaseBot> = client.Client['getFile'];
 export type UpdateFileMetadata<_TBot extends common.BaseBot> = client.Client['updateFileMetadata'];
 export type SearchFiles<_TBot extends common.BaseBot> = client.Client['searchFiles'];
+export type GetTableRow<TBot extends common.BaseBot> = <TableName extends keyof common.EnumerateTables<TBot>, Columns = utils.Cast<common.EnumerateTables<TBot>[TableName], Record<string, any>>>(x: utils.Merge<Arg<client.Client['getTableRow']>, {
+    table: utils.Cast<TableName, string>;
+    id: client.Row['id'];
+}>) => Promise<Readonly<utils.Merge<Awaited<Res<client.Client['getTableRow']>>, {
+    row: Awaited<Res<client.Client['getTableRow']>>['row'] & Columns;
+}>>>;
+export type CreateTableRows<TBot extends common.BaseBot> = <TableName extends keyof common.EnumerateTables<TBot>, Columns = utils.Cast<common.EnumerateTables<TBot>[TableName], Record<string, any>>>(x: utils.Merge<Arg<client.Client['createTableRows']>, {
+    table: utils.Cast<TableName, string>;
+    rows: utils.AtLeastOne<utils.Cast<common.EnumerateTables<TBot>[TableName], Record<string, any>>>;
+}>) => Promise<Readonly<utils.Merge<Awaited<Res<client.Client['createTableRows']>>, {
+    rows: Awaited<Res<client.Client['createTableRows']>>['rows'] & Columns[];
+}>>>;
+type TableRowQueryGroup = 'key' | 'avg' | 'max' | 'min' | 'sum' | 'count';
+type TableRowExtraColumns = {
+    /**
+     * Unique identifier for the row.
+     */
+    id: number;
+    /**
+     * Timestamp of row creation.
+     */
+    createdAt: string;
+    /**
+     * Timestamp of the last row update.
+     */
+    updatedAt: string;
+};
+type TableRowFilter<TBot extends common.BaseBot, TableName extends keyof common.EnumerateTables<TBot>, Columns = utils.Cast<common.EnumerateTables<TBot>[TableName], Record<string, any>> & TableRowExtraColumns> = TableRowColumnFilters<Columns> | TableRowLogicalFilter<TBot, TableName, Columns>;
+type TableRowColumnFilters<Columns> = utils.AtLeastOneProperty<{
+    [K in Extract<keyof Columns, string>]: TableColumnComparisonFilter<Columns[K]>;
+}>;
+type TableRowLogicalFilter<TBot extends common.BaseBot, TableName extends keyof common.EnumerateTables<TBot>, Columns = utils.Cast<common.EnumerateTables<TBot>[TableName], Record<string, any>> & TableRowExtraColumns> = utils.ExactlyOneProperty<{
+    $and: utils.AtLeastOne<TableRowFilter<TBot, TableName, Columns>>;
+    $or: utils.AtLeastOne<TableRowFilter<TBot, TableName, Columns>>;
+    $not: TableRowColumnFilters<Columns>;
+}>;
+type TableColumnComparisonFilter<ColumnType> = ColumnType | utils.ExactlyOneProperty<{
+    $eq: ColumnType;
+    $gt: ColumnType;
+    $gte: ColumnType;
+    $lt: ColumnType;
+    $lte: ColumnType;
+    $ne: ColumnType;
+    $mod: [number, number];
+    $in: utils.AtLeastOne<ColumnType>;
+    $nin: utils.AtLeastOne<ColumnType>;
+    $exists: boolean;
+    $size: number;
+}>;
+export type FindTableRows<TBot extends common.BaseBot> = <TableName extends keyof common.EnumerateTables<TBot>, Columns = utils.Cast<common.EnumerateTables<TBot>[TableName], Record<string, any>> & TableRowExtraColumns>(x: utils.Merge<Arg<client.Client['findTableRows']>, {
+    table: utils.Cast<TableName, string>;
+    filter?: TableRowFilter<TBot, TableName, Columns>;
+    group?: utils.AtLeastOneProperty<{
+        [K in Extract<keyof Columns, string>]: TableRowQueryGroup | TableRowQueryGroup[];
+    }>;
+    orderBy?: Extract<keyof Columns, string>;
+}>) => Promise<Readonly<utils.Merge<Awaited<Res<client.Client['findTableRows']>>, {
+    rows: Awaited<Res<client.Client['findTableRows']>>['rows'] & Columns[];
+}>>>;
+export type DeleteTableRows<TBot extends common.BaseBot> = <TableName extends keyof common.EnumerateTables<TBot>>(x: utils.Merge<Arg<client.Client['deleteTableRows']>, {
+    table: utils.Cast<TableName, string>;
+    filter?: TableRowFilter<TBot, TableName>;
+}>) => Promise<Readonly<Awaited<Res<client.Client['deleteTableRows']>>>>;
+export type UpdateTableRows<TBot extends common.BaseBot> = <TableName extends keyof common.EnumerateTables<TBot>, Columns = utils.Cast<common.EnumerateTables<TBot>[TableName], Record<string, any>>>(x: utils.Merge<Arg<client.Client['updateTableRows']>, {
+    table: utils.Cast<TableName, string>;
+    rows: utils.AtLeastOne<utils.Cast<common.EnumerateTables<TBot>[TableName], Record<string, any>> & {
+        id: number;
+    }>;
+}>) => Promise<Readonly<utils.Merge<Awaited<Res<client.Client['updateTableRows']>>, {
+    rows: Awaited<Res<client.Client['updateTableRows']>>['rows'] & Columns[];
+}>>>;
+export type UpsertTableRows<TBot extends common.BaseBot> = <TableName extends keyof common.EnumerateTables<TBot>, Columns = utils.Cast<common.EnumerateTables<TBot>[TableName], Record<string, any>>>(x: utils.Merge<Arg<client.Client['upsertTableRows']>, {
+    table: utils.Cast<TableName, string>;
+    rows: utils.AtLeastOne<utils.Cast<common.EnumerateTables<TBot>[TableName], Record<string, any>> & {
+        id: number;
+    }>;
+    keyColumn?: Extract<keyof common.EnumerateTables<TBot>[TableName], string> | 'id';
+}>) => Promise<Readonly<utils.Merge<Awaited<Res<client.Client['upsertTableRows']>>, {
+    inserted: Awaited<Res<client.Client['upsertTableRows']>>['inserted'] & Columns[];
+    updated: Awaited<Res<client.Client['upsertTableRows']>>['updated'] & Columns[];
+}>>>;
 export type TrackAnalytics<_TBot extends common.BaseBot> = client.Client['trackAnalytics'];
 export type ClientOperations<TBot extends common.BaseBot> = {
     getConversation: GetConversation<TBot>;
@@ -121,6 +202,12 @@ export type ClientOperations<TBot extends common.BaseBot> = {
     updateFileMetadata: UpdateFileMetadata<TBot>;
     searchFiles: SearchFiles<TBot>;
     trackAnalytics: TrackAnalytics<TBot>;
+    getTableRow: GetTableRow<TBot>;
+    createTableRows: CreateTableRows<TBot>;
+    findTableRows: FindTableRows<TBot>;
+    deleteTableRows: DeleteTableRows<TBot>;
+    updateTableRows: UpdateTableRows<TBot>;
+    upsertTableRows: UpsertTableRows<TBot>;
 };
 export type ClientInputs<TBot extends common.BaseBot> = {
     [K in keyof ClientOperations<TBot>]: Arg<ClientOperations<TBot>[K]>;

package/dist/bot/definition.d.ts

@@ -1,11 +1,14 @@
+import { Table } from '@botpress/client';
 import { IntegrationPackage, PluginPackage } from '../package';
+import { PluginInterfaceExtension } from '../plugin';
 import { SchemaDefinition } from '../schema';
-import { ValueOf } from '../utils/type-utils';
+import { ValueOf, Merge } from '../utils/type-utils';
 import z, { ZuiObjectSchema } from '../zui';
 type BaseConfig = ZuiObjectSchema;
 type BaseStates = Record<string, ZuiObjectSchema>;
 type BaseEvents = Record<string, ZuiObjectSchema>;
 type BaseActions = Record<string, ZuiObjectSchema>;
+type BaseTables = Record<string, ZuiObjectSchema>;
 export type TagDefinition = {
     title?: string;
     description?: string;
@@ -41,6 +44,9 @@ export type ActionDefinition<TAction extends BaseActions[string] = BaseActions[s
     input: SchemaDefinition<TAction>;
     output: SchemaDefinition<ZuiObjectSchema>;
 };
+export type TableDefinition<TTable extends BaseTables[string] = BaseTables[string]> = Merge<Omit<Table, 'id' | 'createdAt' | 'updatedAt' | 'name'>, {
+    schema: TTable;
+}>;
 export type IntegrationConfigInstance<I extends IntegrationPackage = IntegrationPackage> = {
     enabled: boolean;
 } & ({
@@ -55,15 +61,12 @@ export type IntegrationConfigInstance<I extends IntegrationPackage = Integration
 export type PluginConfigInstance<P extends PluginPackage = PluginPackage> = {
     configuration: z.infer<NonNullable<P['definition']['configuration']>['schema']>;
     interfaces: {
-        [I in keyof NonNullable<P['definition']['interfaces']>]: {
-            name: string;
-            version: string;
-        };
+        [I in keyof NonNullable<P['definition']['interfaces']>]: PluginInterfaceExtension;
     };
 };
 export type IntegrationInstance = IntegrationPackage & IntegrationConfigInstance;
 export type PluginInstance = PluginPackage & PluginConfigInstance;
-export type BotDefinitionProps<TStates extends BaseStates = BaseStates, TEvents extends BaseEvents = BaseEvents, TActions extends BaseActions = BaseActions> = {
+export type BotDefinitionProps<TStates extends BaseStates = BaseStates, TEvents extends BaseEvents = BaseEvents, TActions extends BaseActions = BaseActions, TTables extends BaseTables = BaseTables> = {
     integrations?: {
         [K: string]: IntegrationInstance;
     };
@@ -84,9 +87,12 @@ export type BotDefinitionProps<TStates extends BaseStates = BaseStates, TEvents
     actions?: {
         [K in keyof TActions]: ActionDefinition<TActions[K]>;
     };
+    tables?: {
+        [K in keyof TTables]: TableDefinition<TTables[K]>;
+    };
 };
-export declare class BotDefinition<TStates extends BaseStates = BaseStates, TEvents extends BaseEvents = BaseEvents, TActions extends BaseActions = BaseActions> {
-    readonly props: BotDefinitionProps<TStates, TEvents, TActions>;
+export declare class BotDefinition<TStates extends BaseStates = BaseStates, TEvents extends BaseEvents = BaseEvents, TActions extends BaseActions = BaseActions, TTables extends BaseTables = BaseTables> {
+    readonly props: BotDefinitionProps<TStates, TEvents, TActions, TTables>;
     readonly integrations: this['props']['integrations'];
     readonly plugins: this['props']['plugins'];
     readonly user: this['props']['user'];
@@ -97,7 +103,8 @@ export declare class BotDefinition<TStates extends BaseStates = BaseStates, TEve
     readonly events: this['props']['events'];
     readonly recurringEvents: this['props']['recurringEvents'];
     readonly actions: this['props']['actions'];
-    constructor(props: BotDefinitionProps<TStates, TEvents, TActions>);
+    readonly tables: this['props']['tables'];
+    constructor(props: BotDefinitionProps<TStates, TEvents, TActions, TTables>);
     addIntegration<I extends IntegrationPackage>(integrationPkg: I, config: IntegrationConfigInstance<I>): this;
     addPlugin<P extends PluginPackage>(pluginPkg: P, config: PluginConfigInstance<P>): this;
     private _mergeUser;
@@ -107,5 +114,6 @@ export declare class BotDefinition<TStates extends BaseStates = BaseStates, TEve
     private _mergeEvents;
     private _mergeRecurringEvents;
     private _mergeActions;
+    private _mergeTables;
 }
 export {};

package/dist/bot/implementation.d.ts

@@ -10,16 +10,18 @@ export type BotImplementationProps<TBot extends BaseBot = BaseBot, TPlugins exte
 };
 export declare class BotImplementation<TBot extends BaseBot = BaseBot, TPlugins extends Record<string, BasePlugin> = {}> implements BotHandlers<TBot> {
     readonly props: BotImplementationProps<TBot, TPlugins>;
-    readonly actionHandlers: ActionHandlers<TBot>;
-    readonly messageHandlers: MessageHandlersMap<TBot>;
-    readonly eventHandlers: EventHandlersMap<TBot>;
-    readonly stateExpiredHandlers: StateExpiredHandlersMap<TBot>;
-    readonly hookHandlers: HookHandlersMap<TBot>;
-    /**
-     * alias for actionHandlers
-     */
-    get actions(): ActionHandlers<TBot>;
+    private _actionHandlers;
+    private _messageHandlers;
+    private _eventHandlers;
+    private _stateExpiredHandlers;
+    private _hookHandlers;
+    private _plugins;
     constructor(props: BotImplementationProps<TBot, TPlugins>);
+    get actionHandlers(): ActionHandlers<TBot>;
+    get messageHandlers(): MessageHandlersMap<TBot>;
+    get eventHandlers(): EventHandlersMap<TBot>;
+    get stateExpiredHandlers(): StateExpiredHandlersMap<TBot>;
+    get hookHandlers(): HookHandlersMap<TBot>;
     readonly on: {
         message: <T extends keyof MessageHandlersMap<TBot>>(type: T, handler: MessageHandlers<TBot>[T]) => void;
         event: <T extends keyof EventHandlersMap<TBot>>(type: T, handler: EventHandlers<TBot>[T]) => void;
@@ -33,7 +35,6 @@ export declare class BotImplementation<TBot extends BaseBot = BaseBot, TPlugins
         afterOutgoingMessage: <T extends keyof HookData<TBot>["after_outgoing_message"]>(type: T, handler: HookHandlers<TBot>["after_outgoing_message"][T]) => void;
         afterOutgoingCallAction: <T extends keyof HookData<TBot>["after_outgoing_call_action"]>(type: T, handler: HookHandlers<TBot>["after_outgoing_call_action"][T]) => void;
     };
-    private readonly _use;
     readonly handler: (req: import("../serve").Request) => Promise<import("../serve").Response | void>;
     readonly start: (port?: number) => Promise<Server>;
 }

package/dist/bot/index.d.ts

@@ -2,5 +2,5 @@ export * from './definition';
 export * from './implementation';
 export * from './client';
 export * from './server';
-export * from './types/generic';
+export * from './types';
 export * from './bot-logger';

package/dist/bot/server/types.d.ts

@@ -25,6 +25,12 @@ type _IncomingMessages<TBot extends types.BaseBot> = {
         payload: types.GetMessages<TBot>[K];
     }>;
 };
+type _IncomingStates<TBot extends types.BaseBot> = {
+    [K in keyof types.EnumerateStates<TBot>]: utils.Merge<client.State, {
+        name: K;
+        payload: types.EnumerateStates<TBot>[K];
+    }>;
+};
 type _OutgoingMessageRequests<TBot extends types.BaseBot> = {
     [K in keyof types.GetMessages<TBot>]: utils.Merge<client.ClientInputs['createMessage'], {
         type: K;
@@ -50,19 +56,19 @@ type _OutgoingCallActionResponses<TBot extends types.BaseBot> = {
         output: types.EnumerateActionOutputs<TBot>[K];
     }>;
 };
-export type AnyIncomingEvent<TBot extends types.BaseBot> = TBot['unknownDefinitions'] extends true ? client.Event : utils.ValueOf<_IncomingEvents<TBot>>;
-export type AnyIncomingMessage<TBot extends types.BaseBot> = TBot['unknownDefinitions'] extends true ? client.Message : utils.ValueOf<_IncomingMessages<TBot>>;
-export type AnyOutgoingMessageRequest<TBot extends types.BaseBot> = TBot['unknownDefinitions'] extends true ? client.ClientInputs['createMessage'] : utils.ValueOf<_OutgoingMessageRequests<TBot>>;
-export type AnyOutgoingMessageResponse<TBot extends types.BaseBot> = TBot['unknownDefinitions'] extends true ? client.ClientOutputs['createMessage'] : utils.ValueOf<_OutgoingMessageResponses<TBot>>;
-export type AnyOutgoingCallActionRequest<TBot extends types.BaseBot> = TBot['unknownDefinitions'] extends true ? client.ClientInputs['callAction'] : utils.ValueOf<_OutgoingCallActionRequests<TBot>>;
-export type AnyOutgoingCallActionResponse<TBot extends types.BaseBot> = TBot['unknownDefinitions'] extends true ? client.ClientOutputs['callAction'] : utils.ValueOf<_OutgoingCallActionResponses<TBot>>;
+export type AnyIncomingEvent<TBot extends types.BaseBot> = utils.ValueOf<_IncomingEvents<TBot>>;
+export type AnyIncomingMessage<TBot extends types.BaseBot> = utils.ValueOf<_IncomingMessages<TBot>>;
+export type AnyOutgoingMessageRequest<TBot extends types.BaseBot> = utils.ValueOf<_OutgoingMessageRequests<TBot>>;
+export type AnyOutgoingMessageResponse<TBot extends types.BaseBot> = utils.ValueOf<_OutgoingMessageResponses<TBot>>;
+export type AnyOutgoingCallActionRequest<TBot extends types.BaseBot> = utils.ValueOf<_OutgoingCallActionRequests<TBot>>;
+export type AnyOutgoingCallActionResponse<TBot extends types.BaseBot> = utils.ValueOf<_OutgoingCallActionResponses<TBot>>;
 export type IncomingEvents<TBot extends types.BaseBot> = _IncomingEvents<TBot> & {
     '*': AnyIncomingEvent<TBot>;
 };
 export type IncomingMessages<TBot extends types.BaseBot> = _IncomingMessages<TBot> & {
     '*': AnyIncomingMessage<TBot>;
 };
-export type IncomingStates<_TBot extends types.BaseBot> = {
+export type IncomingStates<_TBot extends types.BaseBot> = _IncomingStates<_TBot> & {
     '*': client.State;
 };
 export type OutgoingMessageRequests<TBot extends types.BaseBot> = _OutgoingMessageRequests<TBot> & {
@@ -77,14 +83,14 @@ export type OutgoingCallActionRequests<TBot extends types.BaseBot> = _OutgoingCa
 export type OutgoingCallActionResponses<TBot extends types.BaseBot> = _OutgoingCallActionResponses<TBot> & {
     '*': AnyOutgoingCallActionResponse<TBot>;
 };
-export type BotClient<TBot extends types.BaseBot> = TBot['unknownDefinitions'] extends true ? BotSpecificClient<types.BaseBot> : BotSpecificClient<TBot>;
+export type BotClient<TBot extends types.BaseBot> = BotSpecificClient<TBot>;
 export type CommonHandlerProps<TBot extends types.BaseBot> = {
     ctx: BotContext;
     logger: BotLogger;
     client: BotClient<TBot>;
 };
 export type MessagePayloads<TBot extends types.BaseBot> = {
-    [K in keyof IncomingMessages<TBot>]: {
+    [K in keyof IncomingMessages<TBot>]: CommonHandlerProps<TBot> & {
         message: IncomingMessages<TBot>[K];
         user: client.User;
         conversation: client.Conversation;
@@ -98,32 +104,32 @@ export type MessagePayloads<TBot extends types.BaseBot> = {
     };
 };
 export type MessageHandlers<TBot extends types.BaseBot> = {
-    [K in keyof IncomingMessages<TBot>]: (args: CommonHandlerProps<TBot> & MessagePayloads<TBot>[K]) => Promise<void>;
+    [K in keyof IncomingMessages<TBot>]: (args: MessagePayloads<TBot>[K]) => Promise<void>;
 };
 export type EventPayloads<TBot extends types.BaseBot> = {
-    [K in keyof IncomingEvents<TBot>]: {
+    [K in keyof IncomingEvents<TBot>]: CommonHandlerProps<TBot> & {
         event: IncomingEvents<TBot>[K];
     };
 };
 export type EventHandlers<TBot extends types.BaseBot> = {
-    [K in keyof IncomingEvents<TBot>]: (args: CommonHandlerProps<TBot> & EventPayloads<TBot>[K]) => Promise<void>;
+    [K in keyof IncomingEvents<TBot>]: (args: EventPayloads<TBot>[K]) => Promise<void>;
 };
 export type StateExpiredPayloads<TBot extends types.BaseBot> = {
-    [K in keyof IncomingStates<TBot>]: {
+    [K in keyof IncomingStates<TBot>]: CommonHandlerProps<TBot> & {
         state: IncomingStates<TBot>[K];
     };
 };
 export type StateExpiredHandlers<TBot extends types.BaseBot> = {
-    [K in keyof IncomingStates<TBot>]: (args: CommonHandlerProps<TBot> & StateExpiredPayloads<TBot>[K]) => Promise<void>;
+    [K in keyof IncomingStates<TBot>]: (args: StateExpiredPayloads<TBot>[K]) => Promise<void>;
 };
 export type ActionHandlerPayloads<TBot extends types.BaseBot> = {
-    [K in keyof TBot['actions']]: {
+    [K in keyof TBot['actions']]: CommonHandlerProps<TBot> & {
         type?: K;
         input: TBot['actions'][K]['input'];
     };
 };
 export type ActionHandlers<TBot extends types.BaseBot> = {
-    [K in keyof TBot['actions']]: (props: CommonHandlerProps<TBot> & ActionHandlerPayloads<TBot>[K]) => Promise<TBot['actions'][K]['output']>;
+    [K in keyof TBot['actions']]: (props: ActionHandlerPayloads<TBot>[K]) => Promise<TBot['actions'][K]['output']>;
 };
 type BaseHookDefinition = {
     stoppable?: boolean;
@@ -229,17 +235,17 @@ export type HookHandlersMap<TBot extends types.BaseBot> = {
         [T in keyof HookData<TBot>[H]]?: HookHandlers<TBot>[H][T][];
     };
 };
-export type BotActionHandlers<TBot extends types.BaseBot> = ActionHandlers<TBot>;
-export type BotMessageHandlers<TBot extends types.BaseBot> = MessageHandlersMap<TBot>;
-export type BotEventHandlers<TBot extends types.BaseBot> = EventHandlersMap<TBot>;
-export type BotStateExpiredHandlers<TBot extends types.BaseBot> = StateExpiredHandlersMap<TBot>;
-export type BotHookHandlers<TBot extends types.BaseBot> = HookHandlersMap<TBot>;
+/**
+ * TODO:
+ * the consumer of this type shouldnt be able to access "*" directly;
+ * "*" is meant the user who registers an handler, not for the user who calls the handler
+ */
 export type BotHandlers<TBot extends types.BaseBot> = {
-    actionHandlers: BotActionHandlers<TBot>;
-    messageHandlers: BotMessageHandlers<TBot>;
-    eventHandlers: BotEventHandlers<TBot>;
-    stateExpiredHandlers: BotStateExpiredHandlers<TBot>;
-    hookHandlers: BotHookHandlers<TBot>;
+    actionHandlers: ActionHandlers<TBot>;
+    messageHandlers: MessageHandlersMap<TBot>;
+    eventHandlers: EventHandlersMap<TBot>;
+    stateExpiredHandlers: StateExpiredHandlersMap<TBot>;
+    hookHandlers: HookHandlersMap<TBot>;
 };
 type ImplementedActions<_TBot extends types.BaseBot, TPlugins extends Record<string, plugin.BasePlugin>> = utils.UnionToIntersection<utils.ValueOf<{
     [K in keyof TPlugins]: TPlugins[K]['actions'];

package/dist/bot/types/common.d.ts

@@ -1,7 +1,5 @@
 import { Join, UnionToIntersection, Split, Cast } from '../../utils/type-utils';
 import { BaseBot } from './generic';
-export type EventDefinition = BaseBot['events'][string];
-export type StateDefinition = BaseBot['states'][string];
 export type IntegrationInstanceDefinition = BaseBot['integrations'][string];
 export type IntegrationInstanceConfigurationDefinition = IntegrationInstanceDefinition['configuration'];
 export type IntegrationInstanceActionDefinition = IntegrationInstanceDefinition['actions'][string];
@@ -47,4 +45,10 @@ export type EnumerateMessages<TBot extends BaseBot> = UnionToIntersection<{
 export type GetMessages<TBot extends BaseBot> = {
     [K in keyof EnumerateMessages<TBot> as Cast<Split<K, ':'>[2], string>]: EnumerateMessages<TBot>[K];
 };
+export type EnumerateStates<TBot extends BaseBot> = {
+    [K in keyof TBot['states']]: TBot['states'][K];
+};
+export type EnumerateTables<TBot extends BaseBot> = {
+    [K in keyof TBot['tables']]: TBot['tables'][K];
+};
 export {};

package/dist/bot/types/generic.d.ts

@@ -5,27 +5,128 @@ export type BaseAction = {
     input: any;
     output: any;
 };
+export type BaseTable = {
+    /**
+     * 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' | 'array' | 'null';
+                format?: 'date-time';
+                description?: string;
+                /**
+                 * String properties must match this pattern
+                 */
+                pattern?: string;
+                /**
+                 * String properties must be one of these values
+                 */
+                enum?: string[];
+                /**
+                 * Defines the shape of items in an array
+                 */
+                items?: {
+                    type: 'string' | 'number' | 'boolean' | 'object' | 'array' | 'null';
+                    [k: string]: any;
+                };
+                nullable?: boolean;
+                properties?: {
+                    [k: string]: {
+                        type: 'string' | 'number' | 'boolean' | 'object' | 'array' | 'null';
+                        [k: string]: any;
+                    };
+                };
+                'x-zui': {
+                    index: number;
+                    /**
+                     * 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' | 'workflow';
+                        dependencies?: string[];
+                        /**
+                         * Prompt when action is "ai"
+                         */
+                        prompt?: string;
+                        /**
+                         * Code to execute when action is "code"
+                         */
+                        code?: string;
+                        /**
+                         * Model to use when action is "ai"
+                         */
+                        model?: string;
+                        /**
+                         * ID of Workflow to execute when action is "workflow"
+                         */
+                        workflowId?: string;
+                        enabled?: boolean;
+                    };
+                };
+            };
+        };
+        /**
+         * 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;
+};
 export type BaseBot = {
     integrations: Record<string, BaseIntegration>;
     events: Record<string, any>;
     states: Record<string, any>;
     actions: Record<string, BaseAction>;
-    /**
-     * In a bot, all events, actions, states, and integrations definitions are known.
-     * This mean the Bot typings should not allow for unknown types.
-     *
-     * In a plugin, we don't known about extra definitions of the bot that installed the plugin.
-     * This mean the Plugin typings should allow for unknown types.
-     */
-    unknownDefinitions: boolean;
+    tables: Record<string, BaseTable>;
 };
 export type InputBaseBot = utils.DeepPartial<BaseBot>;
 export type DefaultBot<B extends InputBaseBot> = {
     events: utils.Default<B['events'], BaseBot['events']>;
     states: utils.Default<B['states'], BaseBot['states']>;
     actions: utils.Default<B['actions'], BaseBot['actions']>;
-    unknownDefinitions: utils.Default<B['unknownDefinitions'], BaseBot['unknownDefinitions']>;
     integrations: undefined extends B['integrations'] ? BaseBot['integrations'] : {
         [K in keyof B['integrations']]: DefaultIntegration<utils.Cast<B['integrations'][K], InputBaseIntegration>>;
     };
+    tables: utils.Default<B['tables'], BaseBot['tables']>;
 };

package/dist/fixtures.d.ts

@@ -63,7 +63,47 @@ type _FooBarBazIntegration = {
         }>;
     };
 };
+type _TotoTutuTataInterface = {
+    actions: {
+        doToto: {
+            input: {
+                inputToto: string;
+            };
+            output: {
+                outputToto: string;
+            };
+        };
+        doTutu: {
+            input: {
+                inputTutu: number;
+            };
+            output: {
+                outputTutu: number;
+            };
+        };
+        doTata: {
+            input: {
+                inputTata: boolean;
+            };
+            output: {
+                outputTata: boolean;
+            };
+        };
+    };
+    events: {
+        onToto: {
+            eventToto: string;
+        };
+        onTutu: {
+            eventTutu: number;
+        };
+        onTata: {
+            eventTata: boolean;
+        };
+    };
+};
 export type FooBarBazIntegration = DefaultIntegration<_FooBarBazIntegration>;
+export type TotoTutuTataIntegration = DefaultIntegration<_TotoTutuTataInterface>;
 export type FooBarBazBot = DefaultBot<{
     integrations: {
         fooBarBaz: _FooBarBazIntegration;
@@ -78,11 +118,20 @@ export type FooBarBazBot = DefaultBot<{
             };
         };
     };
+    states: {
+        currentUser: {
+            name: string;
+            age: number;
+        };
+    };
 }>;
 export type FooBarBazPlugin = DefaultPlugin<{
     integrations: {
         fooBarBaz: _FooBarBazIntegration;
     };
+    interfaces: {
+        totoTutuTata: _TotoTutuTataInterface;
+    };
     actions: {
         act: {
             input: {