@botpress/sdk 2.0.3 → 2.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botpress/sdk",
-  "version": "2.0.3",
+  "version": "2.0.4",
   "description": "Botpress SDK",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -14,7 +14,7 @@
   "author": "",
   "license": "MIT",
   "dependencies": {
-    "@botpress/client": "0.37.1",
+    "@botpress/client": "0.38.0",
     "@bpinternal/zui": "0.12.0"
   },
   "devDependencies": {

package/.turbo/turbo-build.log

@@ -1,12 +0,0 @@
-
-> @botpress/sdk@2.0.3 build /home/runner/work/botpress/botpress/packages/sdk
-> pnpm build:type && pnpm build:node
-
-
-> @botpress/sdk@2.0.3 build:type /home/runner/work/botpress/botpress/packages/sdk
-> tsc --emitDeclarationOnly --declaration
-
-
-> @botpress/sdk@2.0.3 build:node /home/runner/work/botpress/botpress/packages/sdk
-> ts-node -T build.ts
-

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

@@ -1,62 +0,0 @@
-import * as client from '@botpress/client';
-import * as common from '../types';
-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);
-    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>;
-    getEvent: types.GetEvent<TBot>;
-    listEvents: types.ListEvents<TBot>;
-    createMessage: types.CreateMessage<TBot>;
-    getOrCreateMessage: types.GetOrCreateMessage<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>;
-    /**
-     * @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

@@ -1,141 +0,0 @@
-import * as client from '@botpress/client';
-import * as utils from '../../utils/type-utils';
-import * as common from '../types';
-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'], {
-        payload: TBot['states'][TState];
-    }>;
-}>;
-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 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 GetOrCreateMessage<TBot extends common.BaseBot> = <TMessage extends keyof common.GetMessages<TBot>>(x: utils.Merge<Arg<client.Client['getOrCreateMessage']>, {
-    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>;
-}>) => 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>;
-    payload: TBot['states'][TState] | 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>;
-    payload: TBot['states'][TState];
-}>) => 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>;
-    payload: Partial<TBot['states'][TState]>;
-}>) => Promise<{
-    state: utils.Merge<Awaited<Res<client.Client['patchState']>>['state'], {
-        payload: TBot['states'][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 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>;
-    listEvents: ListEvents<TBot>;
-    createMessage: CreateMessage<TBot>;
-    getOrCreateMessage: GetOrCreateMessage<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>;
-};
-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]?: (x: client.ClientOutputs[K]) => Promise<client.ClientOutputs[K]>;
-};
-export type ClientHooks = {
-    before: ClientHooksBefore;
-    after: ClientHooksAfter;
-};
-export {};

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

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

package/dist/bot/definition.d.ts

@@ -1,111 +0,0 @@
-import { IntegrationPackage, PluginPackage } from '../package';
-import { SchemaDefinition } from '../schema';
-import { ValueOf } 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>;
-export type TagDefinition = {
-    title?: string;
-    description?: string;
-};
-export type StateType = 'conversation' | 'user' | 'bot';
-export type StateDefinition<TState extends BaseStates[string] = BaseStates[string]> = SchemaDefinition<TState> & {
-    type: StateType;
-    expiry?: number;
-};
-export type RecurringEventDefinition<TEvents extends BaseEvents = BaseEvents> = {
-    [K in keyof TEvents]: {
-        type: K;
-        payload: z.infer<TEvents[K]>;
-        schedule: {
-            cron: string;
-        };
-    };
-}[keyof TEvents];
-export type EventDefinition<TEvent extends BaseEvents[string] = BaseEvents[string]> = SchemaDefinition<TEvent>;
-export type ConfigurationDefinition<TConfig extends BaseConfig = BaseConfig> = SchemaDefinition<TConfig>;
-export type UserDefinition = {
-    tags?: Record<string, TagDefinition>;
-};
-export type ConversationDefinition = {
-    tags?: Record<string, TagDefinition>;
-};
-export type MessageDefinition = {
-    tags?: Record<string, TagDefinition>;
-};
-export type ActionDefinition<TAction extends BaseActions[string] = BaseActions[string]> = {
-    title?: string;
-    description?: string;
-    input: SchemaDefinition<TAction>;
-    output: SchemaDefinition<ZuiObjectSchema>;
-};
-export type IntegrationConfigInstance<I extends IntegrationPackage = IntegrationPackage> = {
-    enabled: boolean;
-} & ({
-    configurationType?: null;
-    configuration: z.infer<NonNullable<I['definition']['configuration']>['schema']>;
-} | ValueOf<{
-    [K in keyof NonNullable<I['definition']['configurations']>]: {
-        configurationType: K;
-        configuration: z.infer<NonNullable<I['definition']['configurations']>[K]['schema']>;
-    };
-}>);
-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;
-        };
-    };
-};
-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> = {
-    integrations?: {
-        [K: string]: IntegrationInstance;
-    };
-    plugins?: {
-        [K: string]: PluginInstance;
-    };
-    user?: UserDefinition;
-    conversation?: ConversationDefinition;
-    message?: MessageDefinition;
-    states?: {
-        [K in keyof TStates]: StateDefinition<TStates[K]>;
-    };
-    configuration?: ConfigurationDefinition;
-    events?: {
-        [K in keyof TEvents]: EventDefinition<TEvents[K]>;
-    };
-    recurringEvents?: Record<string, RecurringEventDefinition<TEvents>>;
-    actions?: {
-        [K in keyof TActions]: ActionDefinition<TActions[K]>;
-    };
-};
-export declare class BotDefinition<TStates extends BaseStates = BaseStates, TEvents extends BaseEvents = BaseEvents, TActions extends BaseActions = BaseActions> {
-    readonly props: BotDefinitionProps<TStates, TEvents, TActions>;
-    readonly integrations: this['props']['integrations'];
-    readonly plugins: this['props']['plugins'];
-    readonly user: this['props']['user'];
-    readonly conversation: this['props']['conversation'];
-    readonly message: this['props']['message'];
-    readonly states: this['props']['states'];
-    readonly configuration: this['props']['configuration'];
-    readonly events: this['props']['events'];
-    readonly recurringEvents: this['props']['recurringEvents'];
-    readonly actions: this['props']['actions'];
-    constructor(props: BotDefinitionProps<TStates, TEvents, TActions>);
-    addIntegration<I extends IntegrationPackage>(integrationPkg: I, config: IntegrationConfigInstance<I>): this;
-    addPlugin<P extends PluginPackage>(pluginPkg: P, config: PluginConfigInstance<P>): this;
-    private _mergeUser;
-    private _mergeConversation;
-    private _mergeMessage;
-    private _mergeStates;
-    private _mergeEvents;
-    private _mergeRecurringEvents;
-    private _mergeActions;
-}
-export {};

package/dist/bot/implementation.d.ts

@@ -1,39 +0,0 @@
-import type { Server } from 'node:http';
-import { BasePlugin, PluginImplementation } from '../plugin';
-import { MessageHandlersMap, MessageHandlers, EventHandlersMap, EventHandlers, StateExpiredHandlersMap, StateExpiredHandlers, HookHandlersMap, HookData, HookHandlers, ActionHandlers, BotHandlers, UnimplementedActionHandlers } from './server';
-import { BaseBot } from './types';
-export type BotImplementationProps<TBot extends BaseBot = BaseBot, TPlugins extends Record<string, BasePlugin> = {}> = {
-    actions: UnimplementedActionHandlers<TBot, TPlugins>;
-    plugins: {
-        [K in keyof TPlugins]: PluginImplementation<TPlugins[K]>;
-    };
-};
-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>;
-    constructor(props: BotImplementationProps<TBot, TPlugins>);
-    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;
-        stateExpired: <T extends keyof StateExpiredHandlersMap<TBot>>(type: T, handler: StateExpiredHandlers<TBot>[T]) => void;
-        beforeIncomingEvent: <T extends keyof HookData<TBot>["before_incoming_event"]>(type: T, handler: HookHandlers<TBot>["before_incoming_event"][T]) => void;
-        beforeIncomingMessage: <T extends keyof HookData<TBot>["before_incoming_message"]>(type: T, handler: HookHandlers<TBot>["before_incoming_message"][T]) => void;
-        beforeOutgoingMessage: <T extends keyof HookData<TBot>["before_outgoing_message"]>(type: T, handler: HookHandlers<TBot>["before_outgoing_message"][T]) => void;
-        beforeOutgoingCallAction: <T extends keyof HookData<TBot>["before_outgoing_call_action"]>(type: T, handler: HookHandlers<TBot>["before_outgoing_call_action"][T]) => void;
-        afterIncomingEvent: <T extends keyof HookData<TBot>["after_incoming_event"]>(type: T, handler: HookHandlers<TBot>["after_incoming_event"][T]) => void;
-        afterIncomingMessage: <T extends keyof HookData<TBot>["after_incoming_message"]>(type: T, handler: HookHandlers<TBot>["after_incoming_message"][T]) => void;
-        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

@@ -1,5 +0,0 @@
-export * from './definition';
-export * from './implementation';
-export * from './client';
-export * from './server';
-export * from './types/generic';

package/dist/bot/merge-bots.d.ts

@@ -1,2 +0,0 @@
-import { BotHandlers } from './server';
-export declare const mergeBots: (dest: BotHandlers<any>, src: BotHandlers<any>) => void;

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

@@ -1,2 +0,0 @@
-import { BotContext } from './types';
-export declare const extractContext: (headers: Record<string, string | undefined>) => BotContext;

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

@@ -1,5 +0,0 @@
-import { Request, Response } from '../../serve';
-import * as common from '../types';
-import * as types from './types';
-export * from './types';
-export declare const botHandler: (bot: types.BotHandlers<common.BaseBot>) => (req: Request) => Promise<Response | void>;

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

@@ -1,252 +0,0 @@
-import * as client from '@botpress/client';
-import * as plugin from '../../plugin';
-import * as utils from '../../utils/type-utils';
-import { BotSpecificClient } from '../client';
-import * as types from '../types';
-export type BotOperation = 'event_received' | 'register' | 'unregister' | 'ping' | 'action_triggered';
-export type BotContext = {
-    botId: string;
-    type: string;
-    operation: BotOperation;
-    configuration: {
-        payload: string;
-    };
-};
-type _IncomingEvents<TBot extends types.BaseBot> = {
-    [K in keyof types.EnumerateEvents<TBot>]: utils.Merge<client.Event, {
-        type: K;
-        payload: types.EnumerateEvents<TBot>[K];
-    }>;
-};
-type _IncomingMessages<TBot extends types.BaseBot> = {
-    [K in keyof types.GetMessages<TBot>]: utils.Merge<client.Message, {
-        type: K;
-        payload: types.GetMessages<TBot>[K];
-    }>;
-};
-type _OutgoingMessageRequests<TBot extends types.BaseBot> = {
-    [K in keyof types.GetMessages<TBot>]: utils.Merge<client.ClientInputs['createMessage'], {
-        type: K;
-        payload: types.GetMessages<TBot>[K];
-    }>;
-};
-type _OutgoingMessageResponses<TBot extends types.BaseBot> = {
-    [K in keyof types.GetMessages<TBot>]: utils.Merge<client.ClientOutputs['createMessage'], {
-        message: utils.Merge<client.Message, {
-            type: K;
-            payload: types.GetMessages<TBot>[K];
-        }>;
-    }>;
-};
-type _OutgoingCallActionRequests<TBot extends types.BaseBot> = {
-    [K in keyof types.EnumerateActionInputs<TBot>]: utils.Merge<client.ClientInputs['callAction'], {
-        type: K;
-        input: types.EnumerateActionInputs<TBot>[K];
-    }>;
-};
-type _OutgoingCallActionResponses<TBot extends types.BaseBot> = {
-    [K in keyof types.EnumerateActionOutputs<TBot>]: utils.Merge<client.ClientOutputs['callAction'], {
-        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 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> = {
-    '*': client.State;
-};
-export type OutgoingMessageRequests<TBot extends types.BaseBot> = _OutgoingMessageRequests<TBot> & {
-    '*': AnyOutgoingMessageRequest<TBot>;
-};
-export type OutgoingMessageResponses<TBot extends types.BaseBot> = _OutgoingMessageResponses<TBot> & {
-    '*': AnyOutgoingMessageResponse<TBot>;
-};
-export type OutgoingCallActionRequests<TBot extends types.BaseBot> = _OutgoingCallActionRequests<TBot> & {
-    '*': AnyOutgoingCallActionRequest<TBot>;
-};
-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 CommonHandlerProps<TBot extends types.BaseBot> = {
-    ctx: BotContext;
-    client: BotClient<TBot>;
-};
-export type MessagePayloads<TBot extends types.BaseBot> = {
-    [K in keyof IncomingMessages<TBot>]: {
-        message: IncomingMessages<TBot>[K];
-        user: client.User;
-        conversation: client.Conversation;
-        event: client.Event;
-        states: {
-            [TState in keyof TBot['states']]: {
-                type: 'user' | 'conversation' | 'bot';
-                payload: TBot['states'][TState];
-            };
-        };
-    };
-};
-export type MessageHandlers<TBot extends types.BaseBot> = {
-    [K in keyof IncomingMessages<TBot>]: (args: CommonHandlerProps<TBot> & MessagePayloads<TBot>[K]) => Promise<void>;
-};
-export type EventPayloads<TBot extends types.BaseBot> = {
-    [K in keyof IncomingEvents<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>;
-};
-export type StateExpiredPayloads<TBot extends types.BaseBot> = {
-    [K in keyof IncomingStates<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>;
-};
-export type ActionHandlerPayloads<TBot extends types.BaseBot> = {
-    [K in keyof TBot['actions']]: {
-        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']>;
-};
-type BaseHookDefinition = {
-    stoppable?: boolean;
-    data: any;
-};
-type HookDefinition<THookDef extends BaseHookDefinition = BaseHookDefinition> = THookDef;
-/**
- * TODO: add hooks for:
- *   - before_register
- *   - after_register
- *   - before_state_expired
- *   - after_state_expired
- *   - before_incoming_call_action
- *   - after_incoming_call_action
- */
-export type HookDefinitions<TBot extends types.BaseBot> = {
-    before_incoming_event: HookDefinition<{
-        stoppable: true;
-        data: _IncomingEvents<TBot> & {
-            '*': AnyIncomingEvent<TBot>;
-        };
-    }>;
-    before_incoming_message: HookDefinition<{
-        stoppable: true;
-        data: _IncomingMessages<TBot> & {
-            '*': AnyIncomingMessage<TBot>;
-        };
-    }>;
-    before_outgoing_message: HookDefinition<{
-        stoppable: false;
-        data: _OutgoingMessageRequests<TBot> & {
-            '*': AnyOutgoingMessageRequest<TBot>;
-        };
-    }>;
-    before_outgoing_call_action: HookDefinition<{
-        stoppable: false;
-        data: _OutgoingCallActionRequests<TBot> & {
-            '*': AnyOutgoingCallActionRequest<TBot>;
-        };
-    }>;
-    after_incoming_event: HookDefinition<{
-        stoppable: true;
-        data: _IncomingEvents<TBot> & {
-            '*': AnyIncomingEvent<TBot>;
-        };
-    }>;
-    after_incoming_message: HookDefinition<{
-        stoppable: true;
-        data: _IncomingMessages<TBot> & {
-            '*': AnyIncomingMessage<TBot>;
-        };
-    }>;
-    after_outgoing_message: HookDefinition<{
-        stoppable: false;
-        data: _OutgoingMessageResponses<TBot> & {
-            '*': AnyOutgoingMessageResponse<TBot>;
-        };
-    }>;
-    after_outgoing_call_action: HookDefinition<{
-        stoppable: false;
-        data: _OutgoingCallActionResponses<TBot> & {
-            '*': AnyOutgoingCallActionResponse<TBot>;
-        };
-    }>;
-};
-export type HookData<TBot extends types.BaseBot> = {
-    [H in keyof HookDefinitions<TBot>]: {
-        [T in keyof HookDefinitions<TBot>[H]['data']]: HookDefinitions<TBot>[H]['data'][T];
-    };
-};
-export type HookInputs<TBot extends types.BaseBot> = {
-    [H in keyof HookData<TBot>]: {
-        [T in keyof HookData<TBot>[H]]: CommonHandlerProps<TBot> & {
-            data: HookData<TBot>[H][T];
-        };
-    };
-};
-export type HookOutputs<TBot extends types.BaseBot> = {
-    [H in keyof HookData<TBot>]: {
-        [T in keyof HookData<TBot>[H]]: {
-            data?: HookData<TBot>[H][T];
-        } & (HookDefinitions<TBot>[H]['stoppable'] extends true ? {
-            stop?: boolean;
-        } : {});
-    };
-};
-export type HookHandlers<TBot extends types.BaseBot> = {
-    [H in keyof HookData<TBot>]: {
-        [T in keyof HookData<TBot>[H]]: (input: HookInputs<TBot>[H][T]) => Promise<HookOutputs<TBot>[H][T] | undefined>;
-    };
-};
-export type MessageHandlersMap<TBot extends types.BaseBot> = {
-    [T in keyof IncomingMessages<TBot>]?: MessageHandlers<TBot>[T][];
-};
-export type EventHandlersMap<TBot extends types.BaseBot> = {
-    [T in keyof IncomingEvents<TBot>]?: EventHandlers<TBot>[T][];
-};
-export type StateExpiredHandlersMap<TBot extends types.BaseBot> = {
-    [T in keyof IncomingStates<TBot>]?: StateExpiredHandlers<TBot>[T][];
-};
-export type HookHandlersMap<TBot extends types.BaseBot> = {
-    [H in keyof HookData<TBot>]: {
-        [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>;
-export type BotHandlers<TBot extends types.BaseBot> = {
-    actionHandlers: BotActionHandlers<TBot>;
-    messageHandlers: BotMessageHandlers<TBot>;
-    eventHandlers: BotEventHandlers<TBot>;
-    stateExpiredHandlers: BotStateExpiredHandlers<TBot>;
-    hookHandlers: BotHookHandlers<TBot>;
-};
-type ImplementedActions<_TBot extends types.BaseBot, TPlugins extends Record<string, plugin.BasePlugin>> = utils.UnionToIntersection<utils.ValueOf<{
-    [K in keyof TPlugins]: TPlugins[K]['actions'];
-}>>;
-type UnimplementedActions<TBot extends types.BaseBot, TPlugins extends Record<string, plugin.BasePlugin>> = Omit<TBot['actions'], keyof ImplementedActions<TBot, TPlugins>>;
-export type ImplementedActionHandlers<TBot extends types.BaseBot, TPlugins extends Record<string, plugin.BasePlugin>> = {
-    [K in keyof ImplementedActions<TBot, TPlugins>]: ActionHandlers<TBot>[utils.Cast<K, keyof ActionHandlers<TBot>>];
-};
-export type UnimplementedActionHandlers<TBot extends types.BaseBot, TPlugins extends Record<string, plugin.BasePlugin>> = {
-    [K in keyof UnimplementedActions<TBot, TPlugins>]: ActionHandlers<TBot>[utils.Cast<K, keyof ActionHandlers<TBot>>];
-};
-export {};