@holocronlab/botruntime-sdk 6.13.3

package/LICENSE

@@ -0,0 +1,8 @@
+Copyright 2023 Botpress Technologies, Inc.
+Portions Copyright (c) 2026 HolocronLab.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/dist/base-logger.d.ts

@@ -0,0 +1,34 @@
+export type LogLevel = 'info' | 'debug' | 'warn' | 'error';
+export type IssueLogEvent = {
+    type: 'issue';
+    code: string;
+    category: 'user_code' | 'limits' | 'configuration' | 'other';
+    title: string;
+    description: string;
+    data: Record<string, {
+        raw: string;
+        pretty?: string;
+    }>;
+    /** This groups by data fields */
+    groupBy: string[];
+    traceId?: string;
+};
+export declare abstract class BaseLogger<TOptions extends object> {
+    protected defaultOptions: TOptions;
+    protected constructor(defaultOptions: TOptions);
+    abstract with(options: TOptions): BaseLogger<TOptions>;
+    info(...args: Parameters<typeof console.info>): void;
+    debug(...args: Parameters<typeof console.debug>): void;
+    warn(...args: Parameters<typeof console.warn>): void;
+    error(...args: Parameters<typeof console.error>): void;
+    issue(args: IssueLogEvent): void;
+    /**
+     * Identity fields merged into every issue line so downstream ingestion can
+     * attribute and validate the issue without out-of-band context.
+     */
+    protected getIssueContext(): Record<string, string>;
+    private _log;
+    private _serializeMessage;
+    protected getJsonMessage(level: LogLevel, msg: string): string;
+    private _getConsoleMethod;
+}

package/dist/base-logger.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/bot/bot-logger.d.ts

@@ -0,0 +1,18 @@
+import { BaseLogger } from '../base-logger';
+type BotLogOptions = {
+    userId?: string;
+    conversationId?: string;
+    workflowId?: string;
+    eventId?: string;
+    messageId?: string;
+};
+export declare class BotLogger extends BaseLogger<BotLogOptions> {
+    constructor(options?: BotLogOptions);
+    with(options: BotLogOptions): BotLogger;
+    withUserId(userId: string): BotLogger;
+    withConversationId(conversationId: string): BotLogger;
+    withWorkflowId(workflowId: string): BotLogger;
+    withEventId(eventId: string): BotLogger;
+    withMessageId(messageId: string): BotLogger;
+}
+export {};

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

@@ -0,0 +1,80 @@
+import * as client from '@holocronlab/botruntime-client';
+import * as common from '../common';
+import * as types from './types';
+export * from './types';
+/**
+ * Just like the regular botpress client, but typed with the bot's properties.
+ */
+export declare class BotSpecificClient<TBot extends common.BaseBot> implements types.ClientOperations<TBot> {
+    private _client;
+    private _hooks;
+    constructor(_client: client.Client, _hooks?: types.ClientHooks);
+    /**
+     * Access the underlying Botpress client.
+     * This is useful for operations that are not available in the BotSpecificClient.
+     * You probably shouldn't use this directly if you don't know what you're doing.
+     */
+    get _inner(): client.Client;
+    getConversation: types.GetConversation<TBot>;
+    listConversations: types.ListConversations<TBot>;
+    updateConversation: types.UpdateConversation<TBot>;
+    deleteConversation: types.DeleteConversation<TBot>;
+    listParticipants: types.ListParticipants<TBot>;
+    addParticipant: types.AddParticipant<TBot>;
+    getParticipant: types.GetParticipant<TBot>;
+    removeParticipant: types.RemoveParticipant<TBot>;
+    createEvent: types.CreateEvent<TBot>;
+    getEvent: types.GetEvent<TBot>;
+    listEvents: types.ListEvents<TBot>;
+    createMessage: types.CreateMessage<TBot>;
+    getMessage: types.GetMessage<TBot>;
+    updateMessage: types.UpdateMessage<TBot>;
+    listMessages: types.ListMessages<TBot>;
+    deleteMessage: types.DeleteMessage<TBot>;
+    getUser: types.GetUser<TBot>;
+    listUsers: types.ListUsers<TBot>;
+    updateUser: types.UpdateUser<TBot>;
+    deleteUser: types.DeleteUser<TBot>;
+    getState: types.GetState<TBot>;
+    setState: types.SetState<TBot>;
+    getOrSetState: types.GetOrSetState<TBot>;
+    patchState: types.PatchState<TBot>;
+    callAction: types.CallAction<TBot>;
+    uploadFile: types.UploadFile<TBot>;
+    upsertFile: types.UpsertFile<TBot>;
+    deleteFile: types.DeleteFile<TBot>;
+    listFiles: types.ListFiles<TBot>;
+    getFile: types.GetFile<TBot>;
+    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>;
+    createWorkflow: types.CreateWorkflow<TBot>;
+    getOrCreateWorkflow: types.GetOrCreateWorkflow<TBot>;
+    getWorkflow: types.GetWorkflow<TBot>;
+    updateWorkflow: types.UpdateWorkflow<TBot>;
+    deleteWorkflow: types.DeleteWorkflow<TBot>;
+    listWorkflows: types.ListWorkflows<TBot>;
+    /**
+     * @deprecated Use `callAction` to delegate the conversation creation to an integration.
+     */
+    createConversation: types.CreateConversation<TBot>;
+    /**
+     * @deprecated Use `callAction` to delegate the conversation creation to an integration.
+     */
+    getOrCreateConversation: types.GetOrCreateConversation<TBot>;
+    /**
+     * @deprecated Use `callAction` to delegate the user creation to an integration.
+     */
+    createUser: types.CreateUser<TBot>;
+    /**
+     * @deprecated Use `callAction` to delegate the user creation to an integration.
+     */
+    getOrCreateUser: types.GetOrCreateUser<TBot>;
+    private _run;
+}

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

@@ -0,0 +1,254 @@
+import * as client from '@holocronlab/botruntime-client';
+import * as utils from '../../utils/type-utils';
+import * as common from '../common';
+type Arg<F extends (...args: any[]) => any> = Parameters<F>[number];
+type Res<F extends (...args: any[]) => any> = ReturnType<F>;
+type EventResponse<TBot extends common.BaseBot> = {
+    event: {
+        [K in keyof common.EnumerateEvents<TBot>]: utils.Merge<client.Event, {
+            type: K;
+            payload: common.EnumerateEvents<TBot>[K];
+        }>;
+    }[keyof common.EnumerateEvents<TBot>];
+};
+type MessageResponse<TBot extends common.BaseBot, TMessage extends keyof common.GetMessages<TBot> = keyof common.GetMessages<TBot>> = {
+    message: utils.ValueOf<{
+        [K in keyof common.GetMessages<TBot> as K extends TMessage ? K : never]: utils.Merge<client.Message, {
+            type: K;
+            payload: common.GetMessages<TBot>[K];
+        }>;
+    }>;
+};
+type StateResponse<TBot extends common.BaseBot, TState extends keyof TBot['states'] = keyof TBot['states']> = utils.Merge<Awaited<Res<client.Client['getState']>>, {
+    state: utils.Merge<Awaited<Res<client.Client['getState']>>['state'], {
+        type: utils.Cast<TBot['states'][TState]['type'], string>;
+        payload: TBot['states'][TState]['payload'];
+    }>;
+}>;
+export type CreateConversation<_TBot extends common.BaseBot> = client.Client['createConversation'];
+export type GetConversation<_TBot extends common.BaseBot> = client.Client['getConversation'];
+export type ListConversations<_TBot extends common.BaseBot> = client.Client['listConversations'];
+export type GetOrCreateConversation<_TBot extends common.BaseBot> = client.Client['getOrCreateConversation'];
+export type UpdateConversation<_TBot extends common.BaseBot> = client.Client['updateConversation'];
+export type DeleteConversation<_TBot extends common.BaseBot> = client.Client['deleteConversation'];
+export type ListParticipants<_TBot extends common.BaseBot> = client.Client['listParticipants'];
+export type AddParticipant<_TBot extends common.BaseBot> = client.Client['addParticipant'];
+export type GetParticipant<_TBot extends common.BaseBot> = client.Client['getParticipant'];
+export type RemoveParticipant<_TBot extends common.BaseBot> = client.Client['removeParticipant'];
+export type CreateEvent<TBot extends common.BaseBot> = <TEvent extends keyof TBot['events']>(x: utils.Merge<Arg<client.Client['createEvent']>, {
+    type: utils.Cast<TEvent, string>;
+    payload: TBot['events'][TEvent];
+}>) => Promise<EventResponse<TBot>>;
+export type GetEvent<TBot extends common.BaseBot> = (x: Arg<client.Client['getEvent']>) => Promise<EventResponse<TBot>>;
+export type ListEvents<_TBot extends common.BaseBot> = client.Client['listEvents'];
+export type CreateMessage<TBot extends common.BaseBot> = <TMessage extends keyof common.GetMessages<TBot>>(x: utils.Merge<Arg<client.Client['createMessage']>, {
+    type: utils.Cast<TMessage, string>;
+    payload: utils.Cast<common.GetMessages<TBot>[TMessage], Record<string, any>>;
+}>) => Promise<MessageResponse<TBot, TMessage>>;
+export type GetMessage<TBot extends common.BaseBot> = (x: Arg<client.Client['getMessage']>) => Promise<MessageResponse<TBot>>;
+export type UpdateMessage<TBot extends common.BaseBot> = (x: Arg<client.Client['updateMessage']>) => Promise<MessageResponse<TBot>>;
+export type ListMessages<_TBot extends common.BaseBot> = client.Client['listMessages'];
+export type DeleteMessage<_TBot extends common.BaseBot> = client.Client['deleteMessage'];
+export type CreateUser<_TBot extends common.BaseBot> = client.Client['createUser'];
+export type GetUser<_TBot extends common.BaseBot> = client.Client['getUser'];
+export type ListUsers<_TBot extends common.BaseBot> = client.Client['listUsers'];
+export type GetOrCreateUser<_TBot extends common.BaseBot> = client.Client['getOrCreateUser'];
+export type UpdateUser<_TBot extends common.BaseBot> = client.Client['updateUser'];
+export type DeleteUser<_TBot extends common.BaseBot> = client.Client['deleteUser'];
+export type GetState<TBot extends common.BaseBot> = <TState extends keyof TBot['states']>(x: utils.Merge<Arg<client.Client['getState']>, {
+    name: utils.Cast<TState, string>;
+    type: utils.Cast<TBot['states'][TState]['type'], string>;
+}>) => Promise<StateResponse<TBot, TState>>;
+export type SetState<TBot extends common.BaseBot> = <TState extends keyof TBot['states']>(x: utils.Merge<Arg<client.Client['setState']>, {
+    name: utils.Cast<TState, string>;
+    type: utils.Cast<TBot['states'][TState]['type'], string>;
+    payload: TBot['states'][TState]['payload'] | null;
+}>) => Promise<StateResponse<TBot, TState>>;
+export type GetOrSetState<TBot extends common.BaseBot> = <TState extends keyof TBot['states']>(x: utils.Merge<Arg<client.Client['getOrSetState']>, {
+    name: utils.Cast<TState, string>;
+    type: utils.Cast<TBot['states'][TState]['type'], string>;
+    payload: TBot['states'][TState]['payload'];
+}>) => Promise<StateResponse<TBot, TState>>;
+export type PatchState<TBot extends common.BaseBot> = <TState extends keyof TBot['states']>(x: utils.Merge<Arg<client.Client['patchState']>, {
+    name: utils.Cast<TState, string>;
+    type: utils.Cast<TBot['states'][TState]['type'], string>;
+    payload: Partial<TBot['states'][TState]['payload']>;
+}>) => Promise<StateResponse<TBot, TState>>;
+export type CallAction<TBot extends common.BaseBot> = <ActionType extends keyof common.EnumerateActions<TBot>>(x: utils.Merge<Arg<client.Client['callAction']>, {
+    type: utils.Cast<ActionType, string>;
+    input: utils.Cast<common.EnumerateActions<TBot>[ActionType], common.IntegrationInstanceActionDefinition>['input'];
+}>) => Promise<utils.Merge<Awaited<Res<client.Client['callAction']>>, {
+    output: utils.Cast<common.EnumerateActions<TBot>[ActionType], common.IntegrationInstanceActionDefinition>['output'];
+}>>;
+export type UploadFile<_TBot extends common.BaseBot> = client.Client['uploadFile'];
+export type UpsertFile<_TBot extends common.BaseBot> = client.Client['upsertFile'];
+export type DeleteFile<_TBot extends common.BaseBot> = client.Client['deleteFile'];
+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 CreateWorkflow<TBot extends common.BaseBot> = <TWorkflowName extends utils.StringKeys<TBot['workflows']>>(x: utils.Merge<Arg<client.Client['createWorkflow']>, {
+    name: utils.Cast<TWorkflowName, string>;
+    input: utils.Cast<TBot['workflows'][TWorkflowName], common.IntegrationInstanceActionDefinition>['input'];
+    tags?: utils.AtLeastOneProperty<TBot['workflows'][TWorkflowName]['tags']>;
+}>) => Promise<Readonly<{
+    workflow: utils.Merge<Awaited<Res<client.Client['createWorkflow']>>['workflow'], {
+        name: NoInfer<TWorkflowName>;
+    }>;
+}>>;
+export type GetOrCreateWorkflow<TBot extends common.BaseBot> = <TWorkflowName extends utils.StringKeys<TBot['workflows']>>(x: utils.Merge<Arg<client.Client['getOrCreateWorkflow']>, {
+    name: utils.Cast<TWorkflowName, string>;
+    input: utils.Cast<TBot['workflows'][TWorkflowName], common.IntegrationInstanceActionDefinition>['input'];
+    tags?: utils.AtLeastOneProperty<TBot['workflows'][TWorkflowName]['tags']>;
+}>) => Promise<Readonly<{
+    workflow: utils.Merge<Awaited<Res<client.Client['getOrCreateWorkflow']>>['workflow'], {
+        name: NoInfer<TWorkflowName>;
+    }>;
+}>>;
+export type GetWorkflow<_TBot extends common.BaseBot> = client.Client['getWorkflow'];
+export type UpdateWorkflow<_TBot extends common.BaseBot> = client.Client['updateWorkflow'];
+export type DeleteWorkflow<_TBot extends common.BaseBot> = client.Client['deleteWorkflow'];
+export type ListWorkflows<TBot extends common.BaseBot> = <TWorkflowName extends utils.StringKeys<TBot['workflows']>>(x: utils.Merge<Arg<client.Client['listWorkflows']>, {
+    name?: utils.Cast<TWorkflowName, string>;
+    tags?: utils.AtLeastOneProperty<TBot['workflows'][TWorkflowName]['tags']>;
+}>) => Promise<Readonly<Awaited<Res<client.Client['listWorkflows']>>>>;
+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, NoInfer<TableName>, NoInfer<Columns>>;
+    group?: NoInfer<utils.AtLeastOneProperty<{
+        [K in Extract<keyof Columns, string>]: TableRowQueryGroup | TableRowQueryGroup[];
+    }>>;
+    orderBy?: NoInfer<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?: NoInfer<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>;
+    listConversations: ListConversations<TBot>;
+    updateConversation: UpdateConversation<TBot>;
+    deleteConversation: DeleteConversation<TBot>;
+    listParticipants: ListParticipants<TBot>;
+    addParticipant: AddParticipant<TBot>;
+    getParticipant: GetParticipant<TBot>;
+    removeParticipant: RemoveParticipant<TBot>;
+    getEvent: GetEvent<TBot>;
+    createEvent: CreateEvent<TBot>;
+    listEvents: ListEvents<TBot>;
+    createMessage: CreateMessage<TBot>;
+    getMessage: GetMessage<TBot>;
+    updateMessage: UpdateMessage<TBot>;
+    listMessages: ListMessages<TBot>;
+    deleteMessage: DeleteMessage<TBot>;
+    getUser: GetUser<TBot>;
+    listUsers: ListUsers<TBot>;
+    updateUser: UpdateUser<TBot>;
+    deleteUser: DeleteUser<TBot>;
+    getState: GetState<TBot>;
+    setState: SetState<TBot>;
+    getOrSetState: GetOrSetState<TBot>;
+    patchState: PatchState<TBot>;
+    callAction: CallAction<TBot>;
+    uploadFile: UploadFile<TBot>;
+    upsertFile: UpsertFile<TBot>;
+    deleteFile: DeleteFile<TBot>;
+    listFiles: ListFiles<TBot>;
+    getFile: GetFile<TBot>;
+    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]>;
+};
+export type ClientOutputs<TBot extends common.BaseBot> = {
+    [K in keyof ClientOperations<TBot>]: Awaited<Res<ClientOperations<TBot>[K]>>;
+};
+type ClientHooksBefore = {
+    [K in client.Operation]?: (x: client.ClientInputs[K]) => Promise<client.ClientInputs[K]>;
+};
+type ClientHooksAfter = {
+    [K in client.Operation]?: (y: client.ClientOutputs[K], x: client.ClientInputs[K]) => Promise<client.ClientOutputs[K]>;
+};
+export type ClientHooks = {
+    before: ClientHooksBefore;
+    after: ClientHooksAfter;
+};
+export {};

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,41 @@
+import { BaseIntegration, DefaultIntegration, InputBaseIntegration } from '../../integration/common/generic';
+import * as utils from '../../utils/type-utils';
+import * as def from '../definition';
+export * from '../../integration/common/generic';
+export type BaseAction = {
+    input: any;
+    output: any;
+};
+export type BaseTable = {
+    [k: string]: any;
+};
+export type BaseWorkflow = {
+    input: any;
+    output: any;
+    tags?: {
+        [k: string]: string;
+    };
+};
+export type BaseState = {
+    type: def.StateType;
+    payload: any;
+};
+export type BaseBot = {
+    integrations: Record<string, BaseIntegration>;
+    events: Record<string, any>;
+    states: Record<string, BaseState>;
+    actions: Record<string, BaseAction>;
+    tables: Record<string, BaseTable>;
+    workflows: Record<string, BaseWorkflow>;
+};
+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']>;
+    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']>;
+    workflows: utils.Default<B['workflows'], BaseBot['workflows']>;
+};

package/dist/bot/common/generic.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,2 @@
+export * from './generic';
+export * from './types';

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

@@ -0,0 +1,54 @@
+import { Join, UnionToIntersection, Split, Cast } from '../../utils/type-utils';
+import { BaseBot } from './generic';
+export type IntegrationInstanceDefinition = BaseBot['integrations'][string];
+export type IntegrationInstanceConfigurationDefinition = IntegrationInstanceDefinition['configuration'];
+export type IntegrationInstanceActionDefinition = IntegrationInstanceDefinition['actions'][string];
+export type IntegrationInstanceChannelDefinition = IntegrationInstanceDefinition['channels'][string];
+export type IntegrationInstanceMessageDefinition = IntegrationInstanceChannelDefinition['messages'][string];
+export type IntegrationInstanceEventDefinition = IntegrationInstanceDefinition['events'][string];
+export type IntegrationInstanceStateDefinition = IntegrationInstanceDefinition['states'][string];
+export type IntegrationInstanceUserDefinition = IntegrationInstanceDefinition['user'];
+type ActionKey<TIntegrationName extends string, TActionName extends string> = string extends TIntegrationName ? string : string extends TActionName ? string : Join<[TIntegrationName, ':', TActionName]>;
+export type EnumerateActions<TBot extends BaseBot> = UnionToIntersection<{
+    [TIntegrationName in keyof TBot['integrations']]: {
+        [TActionName in keyof TBot['integrations'][TIntegrationName]['actions'] as ActionKey<Cast<TIntegrationName, string>, Cast<TActionName, string>>]: TBot['integrations'][TIntegrationName]['actions'][TActionName];
+    };
+}[keyof TBot['integrations']]> & {};
+export type EnumerateActionInputs<TBot extends BaseBot> = {
+    [K in keyof EnumerateActions<TBot>]: Cast<EnumerateActions<TBot>[K], IntegrationInstanceActionDefinition>['input'];
+};
+export type EnumerateActionOutputs<TBot extends BaseBot> = {
+    [K in keyof EnumerateActions<TBot>]: Cast<EnumerateActions<TBot>[K], IntegrationInstanceActionDefinition>['output'];
+};
+type EventKey<TIntegrationName extends string, TEventName extends string> = string extends TIntegrationName ? string : string extends TEventName ? string : Join<[TIntegrationName, ':', TEventName]>;
+export type EnumerateEvents<TBot extends BaseBot> = UnionToIntersection<{
+    [TIntegrationName in keyof TBot['integrations']]: {
+        [TEventName in keyof TBot['integrations'][TIntegrationName]['events'] as EventKey<Cast<TIntegrationName, string>, Cast<TEventName, string>>]: TBot['integrations'][TIntegrationName]['events'][TEventName];
+    };
+}[keyof TBot['integrations']]> & {
+    [TEventName in keyof TBot['events']]: TBot['events'][TEventName];
+};
+type ChannelKey<TIntegrationName extends string, TChannelName extends string> = string extends TIntegrationName ? string : string extends TChannelName ? string : Join<[TIntegrationName, ':', TChannelName]>;
+export type EnumerateChannels<TBot extends BaseBot> = UnionToIntersection<{
+    [TIntegrationName in keyof TBot['integrations']]: {
+        [TChannelName in keyof TBot['integrations'][TIntegrationName]['channels'] as ChannelKey<Cast<TIntegrationName, string>, Cast<TChannelName, string>>]: TBot['integrations'][TIntegrationName]['channels'][TChannelName];
+    };
+}[keyof TBot['integrations']]> & {};
+type MessageKey<TIntegrationName extends string, TChannelName extends string, TMessageName extends string> = string extends TIntegrationName ? string : string extends TChannelName ? string : string extends TMessageName ? string : Join<[TIntegrationName, ':', TChannelName, ':', TMessageName]>;
+export type EnumerateMessages<TBot extends BaseBot> = UnionToIntersection<{
+    [TIntegrationName in keyof TBot['integrations']]: {
+        [TChannelName in keyof TBot['integrations'][TIntegrationName]['channels']]: {
+            [TMessageName in keyof TBot['integrations'][TIntegrationName]['channels'][TChannelName]['messages'] as MessageKey<Cast<TIntegrationName, string>, Cast<TChannelName, string>, Cast<TMessageName, string>>]: TBot['integrations'][TIntegrationName]['channels'][TChannelName]['messages'][TMessageName];
+        };
+    }[keyof TBot['integrations'][TIntegrationName]['channels']];
+}[keyof TBot['integrations']]> & {};
+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/common/types.test.d.ts

@@ -0,0 +1 @@
+export {};