@botpress/sdk 3.5.0 → 3.6.0

package/.turbo/turbo-build.log

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

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

@@ -3,6 +3,8 @@ type BotLogOptions = {
     userId?: string;
     conversationId?: string;
     workflowId?: string;
+    eventId?: string;
+    messageId?: string;
 };
 export declare class BotLogger extends BaseLogger<BotLogOptions> {
     constructor(options?: BotLogOptions);
@@ -10,5 +12,7 @@ export declare class BotLogger extends BaseLogger<BotLogOptions> {
     withUserId(userId: string): BotLogger;
     withConversationId(conversationId: string): BotLogger;
     withWorkflowId(workflowId: string): BotLogger;
+    withEventId(eventId: string): BotLogger;
+    withMessageId(messageId: string): BotLogger;
 }
 export {};

package/dist/bot/implementation.d.ts

@@ -1,11 +1,12 @@
 import type { Server } from 'node:http';
 import { BasePlugin, PluginImplementation } from '../plugin';
+import * as utils from '../utils';
 import { BaseBot } from './common';
-import { type MessageHandlersMap, type MessageHandlers, type EventHandlersMap, type EventHandlers, type StateExpiredHandlersMap, type StateExpiredHandlers, type HookHandlersMap, type HookData, type HookHandlers, type ActionHandlers, type BotHandlers, type UnimplementedActionHandlers, type WorkflowHandlersMap, type WorkflowHandlersFnMap } from './server';
+import { ActionHandlers, MessageHandlers, EventHandlers, StateExpiredHandlers, HookHandlers, WorkflowHandlers, MessageHandlersMap, EventHandlersMap, StateExpiredHandlersMap, HookHandlersMap, WorkflowHandlersMap, BotHandlers, UnimplementedActionHandlers } from './server';
 export type BotImplementationProps<TBot extends BaseBot = BaseBot, TPlugins extends Record<string, BasePlugin> = {}> = {
     actions: UnimplementedActionHandlers<TBot, TPlugins>;
     plugins: {
-        [K in keyof TPlugins]: PluginImplementation<TPlugins[K]>;
+        [K in utils.types.StringKeys<TPlugins>]: PluginImplementation<TPlugins[K]>;
     };
 };
 export declare class BotImplementation<TBot extends BaseBot = BaseBot, TPlugins extends Record<string, BasePlugin> = {}> implements BotHandlers<TBot> {
@@ -17,6 +18,7 @@ export declare class BotImplementation<TBot extends BaseBot = BaseBot, TPlugins
     private _hookHandlers;
     private _workflowHandlers;
     private _plugins;
+    private _registerOrder;
     constructor(props: BotImplementationProps<TBot, TPlugins>);
     get actionHandlers(): ActionHandlers<TBot>;
     get messageHandlers(): MessageHandlersMap<TBot>;
@@ -25,22 +27,32 @@ export declare class BotImplementation<TBot extends BaseBot = BaseBot, TPlugins
     get hookHandlers(): HookHandlersMap<TBot>;
     get workflowHandlers(): WorkflowHandlersMap<TBot>;
     readonly on: {
-        message: <T extends keyof MessageHandlersMap<TBot>>(type: T, handler: MessageHandlers<TBot>[T]) => void;
+        message: <T extends utils.types.StringKeys<MessageHandlersMap<TBot>>>(type: T, handler: MessageHandlers<TBot>[T]) => void;
+        event: <T extends utils.types.StringKeys<EventHandlersMap<TBot>>>(type: T, handler: EventHandlers<TBot>[T]) => void;
+        stateExpired: <T extends utils.types.StringKeys<StateExpiredHandlersMap<TBot>>>(type: T, handler: StateExpiredHandlers<TBot>[T]) => void;
+        beforeIncomingEvent: <T extends utils.types.StringKeys<HookHandlersMap<TBot>["before_incoming_event"]>>(type: T, handler: HookHandlers<TBot>["before_incoming_event"][T]) => void;
+        beforeIncomingMessage: <T extends utils.types.StringKeys<HookHandlersMap<TBot>["before_incoming_message"]>>(type: T, handler: HookHandlers<TBot>["before_incoming_message"][T]) => void;
+        beforeOutgoingMessage: <T extends utils.types.StringKeys<HookHandlersMap<TBot>["before_outgoing_message"]>>(type: T, handler: HookHandlers<TBot>["before_outgoing_message"][T]) => void;
+        beforeOutgoingCallAction: <T extends utils.types.StringKeys<HookHandlersMap<TBot>["before_outgoing_call_action"]>>(type: T, handler: HookHandlers<TBot>["before_outgoing_call_action"][T]) => void;
+        afterIncomingEvent: <T extends utils.types.StringKeys<HookHandlersMap<TBot>["after_incoming_event"]>>(type: T, handler: HookHandlers<TBot>["after_incoming_event"][T]) => void;
+        afterIncomingMessage: <T extends utils.types.StringKeys<HookHandlersMap<TBot>["after_incoming_message"]>>(type: T, handler: HookHandlers<TBot>["after_incoming_message"][T]) => void;
+        afterOutgoingMessage: <T extends utils.types.StringKeys<HookHandlersMap<TBot>["after_outgoing_message"]>>(type: T, handler: HookHandlers<TBot>["after_outgoing_message"][T]) => void;
+        afterOutgoingCallAction: <T extends utils.types.StringKeys<HookHandlersMap<TBot>["after_outgoing_call_action"]>>(type: T, handler: HookHandlers<TBot>["after_outgoing_call_action"][T]) => void;
         /**
          * # EXPERIMENTAL
          * This API is experimental and may change in the future.
          */
-        workflows: WorkflowHandlersFnMap<TBot>;
-        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;
+        workflowStart: <T extends utils.types.StringKeys<WorkflowHandlersMap<TBot>["started"]>>(type: T, handler: WorkflowHandlers<TBot>[T]) => void;
+        /**
+         * # EXPERIMENTAL
+         * This API is experimental and may change in the future.
+         */
+        workflowContinue: <T extends utils.types.StringKeys<WorkflowHandlersMap<TBot>["continued"]>>(type: T, handler: WorkflowHandlers<TBot>[T]) => void;
+        /**
+         * # EXPERIMENTAL
+         * This API is experimental and may change in the future.
+         */
+        workflowTimeout: <T extends utils.types.StringKeys<WorkflowHandlersMap<TBot>["timed_out"]>>(type: T, handler: WorkflowHandlers<TBot>[T]) => void;
     };
     readonly handler: (req: import("../serve").Request) => Promise<import("../serve").Response | void>;
     readonly start: (port?: number) => Promise<Server>;

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

@@ -16,31 +16,31 @@ export type BotContext = {
     };
 };
 type _IncomingEvents<TBot extends common.BaseBot> = {
-    [K in keyof common.EnumerateEvents<TBot>]: utils.Merge<client.Event, {
+    [K in utils.StringKeys<common.EnumerateEvents<TBot>>]: utils.Merge<client.Event, {
         type: K;
         payload: common.EnumerateEvents<TBot>[K];
     }>;
 };
 type _IncomingMessages<TBot extends common.BaseBot> = {
-    [K in keyof common.GetMessages<TBot>]: utils.Merge<client.Message, {
+    [K in utils.StringKeys<common.GetMessages<TBot>>]: utils.Merge<client.Message, {
         type: K;
         payload: common.GetMessages<TBot>[K];
     }>;
 };
 type _IncomingStates<TBot extends common.BaseBot> = {
-    [K in keyof common.EnumerateStates<TBot>]: utils.Merge<client.State, {
+    [K in utils.StringKeys<common.EnumerateStates<TBot>>]: utils.Merge<client.State, {
         name: K;
         payload: common.EnumerateStates<TBot>[K];
     }>;
 };
 type _OutgoingMessageRequests<TBot extends common.BaseBot> = {
-    [K in keyof common.GetMessages<TBot>]: utils.Merge<client.ClientInputs['createMessage'], {
+    [K in utils.StringKeys<common.GetMessages<TBot>>]: utils.Merge<client.ClientInputs['createMessage'], {
         type: K;
         payload: common.GetMessages<TBot>[K];
     }>;
 };
 type _OutgoingMessageResponses<TBot extends common.BaseBot> = {
-    [K in keyof common.GetMessages<TBot>]: utils.Merge<client.ClientOutputs['createMessage'], {
+    [K in utils.StringKeys<common.GetMessages<TBot>>]: utils.Merge<client.ClientOutputs['createMessage'], {
         message: utils.Merge<client.Message, {
             type: K;
             payload: common.GetMessages<TBot>[K];
@@ -48,13 +48,13 @@ type _OutgoingMessageResponses<TBot extends common.BaseBot> = {
     }>;
 };
 type _OutgoingCallActionRequests<TBot extends common.BaseBot> = {
-    [K in keyof common.EnumerateActionInputs<TBot>]: utils.Merge<client.ClientInputs['callAction'], {
+    [K in utils.StringKeys<common.EnumerateActionInputs<TBot>>]: utils.Merge<client.ClientInputs['callAction'], {
         type: K;
         input: common.EnumerateActionInputs<TBot>[K];
     }>;
 };
 type _OutgoingCallActionResponses<TBot extends common.BaseBot> = {
-    [K in keyof common.EnumerateActionOutputs<TBot>]: utils.Merge<client.ClientOutputs['callAction'], {
+    [K in utils.StringKeys<common.EnumerateActionOutputs<TBot>>]: utils.Merge<client.ClientOutputs['callAction'], {
         output: common.EnumerateActionOutputs<TBot>[K];
     }>;
 };
@@ -97,13 +97,13 @@ export type CommonHandlerProps<TBot extends common.BaseBot> = {
     workflows: workflowProxy.WorkflowProxy<TBot>;
 };
 export type MessagePayloads<TBot extends common.BaseBot> = {
-    [K in keyof IncomingMessages<TBot>]: CommonHandlerProps<TBot> & {
-        message: IncomingMessages<TBot>[K];
+    [TMessageName in utils.StringKeys<IncomingMessages<TBot>>]: CommonHandlerProps<TBot> & {
+        message: IncomingMessages<TBot>[TMessageName];
         user: client.User;
         conversation: client.Conversation;
         event: client.Event;
         states: {
-            [TState in keyof TBot['states']]: {
+            [TState in utils.StringKeys<TBot['states']>]: {
                 type: 'user' | 'conversation' | 'bot';
                 payload: TBot['states'][TState];
             };
@@ -111,32 +111,32 @@ export type MessagePayloads<TBot extends common.BaseBot> = {
     };
 };
 export type MessageHandlers<TBot extends common.BaseBot> = {
-    [K in keyof IncomingMessages<TBot>]: (args: MessagePayloads<TBot>[K]) => Promise<void>;
+    [TMessageName in utils.StringKeys<IncomingMessages<TBot>>]: (args: MessagePayloads<TBot>[TMessageName]) => Promise<void>;
 };
 export type EventPayloads<TBot extends common.BaseBot> = {
-    [K in keyof IncomingEvents<TBot>]: CommonHandlerProps<TBot> & {
-        event: IncomingEvents<TBot>[K];
+    [TEventName in utils.StringKeys<IncomingEvents<TBot>>]: CommonHandlerProps<TBot> & {
+        event: IncomingEvents<TBot>[TEventName];
     };
 };
 export type EventHandlers<TBot extends common.BaseBot> = {
-    [K in keyof IncomingEvents<TBot>]: (args: EventPayloads<TBot>[K]) => Promise<void>;
+    [TEventName in utils.StringKeys<IncomingEvents<TBot>>]: (args: EventPayloads<TBot>[TEventName]) => Promise<void>;
 };
 export type StateExpiredPayloads<TBot extends common.BaseBot> = {
-    [K in keyof IncomingStates<TBot>]: CommonHandlerProps<TBot> & {
-        state: IncomingStates<TBot>[K];
+    [TSateName in utils.StringKeys<IncomingStates<TBot>>]: CommonHandlerProps<TBot> & {
+        state: IncomingStates<TBot>[TSateName];
     };
 };
 export type StateExpiredHandlers<TBot extends common.BaseBot> = {
-    [K in keyof IncomingStates<TBot>]: (args: StateExpiredPayloads<TBot>[K]) => Promise<void>;
+    [TSateName in utils.StringKeys<IncomingStates<TBot>>]: (args: StateExpiredPayloads<TBot>[TSateName]) => Promise<void>;
 };
 export type ActionHandlerPayloads<TBot extends common.BaseBot> = {
-    [K in keyof TBot['actions']]: CommonHandlerProps<TBot> & {
-        type?: K;
-        input: TBot['actions'][K]['input'];
+    [TActionName in utils.StringKeys<TBot['actions']>]: CommonHandlerProps<TBot> & {
+        type?: TActionName;
+        input: TBot['actions'][TActionName]['input'];
     };
 };
 export type ActionHandlers<TBot extends common.BaseBot> = {
-    [K in keyof TBot['actions']]: (props: ActionHandlerPayloads<TBot>[K]) => Promise<TBot['actions'][K]['output']>;
+    [TActionName in utils.StringKeys<TBot['actions']>]: (props: ActionHandlerPayloads<TBot>[TActionName]) => Promise<TBot['actions'][TActionName]['output']>;
 };
 export type BridgeWorkflowUpdateType = 'child_workflow_deleted' | 'child_workflow_finished' | 'workflow_timedout' | 'workflow_started' | 'workflow_continued';
 export type WorkflowUpdateEventPayload = {
@@ -150,6 +150,20 @@ export type WorkflowUpdateEvent = utils.Merge<client.Event, {
     type: 'workflow_update';
     payload: WorkflowUpdateEventPayload;
 }>;
+export type WorkflowPayloads<TBot extends common.BaseBot> = {
+    [TWorkflowName in utils.StringKeys<TBot['workflows']>]: CommonHandlerProps<TBot> & {
+        conversation?: client.Conversation;
+        user?: client.User;
+        /**
+         * # EXPERIMENTAL
+         * This API is experimental and may change in the future.
+         */
+        workflow: workflowProxy.WorkflowWithUtilities<TBot, TWorkflowName>;
+    };
+};
+export type WorkflowHandlers<TBot extends common.BaseBot> = {
+    [TWorkflowName in utils.StringKeys<TBot['workflows']>]: (props: WorkflowPayloads<TBot>[TWorkflowName]) => Promise<void>;
+};
 type BaseHookDefinition = {
     stoppable?: boolean;
     data: any;
@@ -215,69 +229,83 @@ export type HookDefinitions<TBot extends common.BaseBot> = {
     }>;
 };
 export type HookData<TBot extends common.BaseBot> = {
-    [H in keyof HookDefinitions<TBot>]: {
-        [T in keyof HookDefinitions<TBot>[H]['data']]: HookDefinitions<TBot>[H]['data'][T];
+    [THookType in utils.StringKeys<HookDefinitions<TBot>>]: {
+        [THookDataName in utils.StringKeys<HookDefinitions<TBot>[THookType]['data']>]: HookDefinitions<TBot>[THookType]['data'][THookDataName];
     };
 };
 export type HookInputs<TBot extends common.BaseBot> = {
-    [H in keyof HookData<TBot>]: {
-        [T in keyof HookData<TBot>[H]]: CommonHandlerProps<TBot> & {
-            data: HookData<TBot>[H][T];
+    [THookType in utils.StringKeys<HookData<TBot>>]: {
+        [THookDataName in utils.StringKeys<HookData<TBot>[THookType]>]: CommonHandlerProps<TBot> & {
+            data: HookData<TBot>[THookType][THookDataName];
         };
     };
 };
 export type HookOutputs<TBot extends common.BaseBot> = {
-    [H in keyof HookData<TBot>]: {
-        [T in keyof HookData<TBot>[H]]: {
-            data?: HookData<TBot>[H][T];
-        } & (HookDefinitions<TBot>[H]['stoppable'] extends true ? {
+    [THookType in utils.StringKeys<HookData<TBot>>]: {
+        [THookDataName in utils.StringKeys<HookData<TBot>[THookType]>]: {
+            data?: HookData<TBot>[THookType][THookDataName];
+        } & (HookDefinitions<TBot>[THookType]['stoppable'] extends true ? {
             stop?: boolean;
         } : {});
     };
 };
 export type HookHandlers<TBot extends common.BaseBot> = {
-    [H in keyof HookData<TBot>]: {
-        [T in keyof HookData<TBot>[H]]: (input: HookInputs<TBot>[H][T]) => Promise<HookOutputs<TBot>[H][T] | undefined>;
+    [THookType in utils.StringKeys<HookData<TBot>>]: {
+        [THookDataName in utils.StringKeys<HookData<TBot>[THookType]>]: (input: HookInputs<TBot>[THookType][THookDataName]) => Promise<HookOutputs<TBot>[THookType][THookDataName] | undefined>;
     };
 };
 export type MessageHandlersMap<TBot extends common.BaseBot> = {
-    [T in keyof IncomingMessages<TBot>]?: MessageHandlers<TBot>[T][];
+    [TMessageName in utils.StringKeys<IncomingMessages<TBot>>]?: MessageHandlers<TBot>[TMessageName][];
 };
 export type EventHandlersMap<TBot extends common.BaseBot> = {
-    [T in keyof IncomingEvents<TBot>]?: EventHandlers<TBot>[T][];
+    [TEventName in utils.StringKeys<IncomingEvents<TBot>>]?: EventHandlers<TBot>[TEventName][];
 };
 export type StateExpiredHandlersMap<TBot extends common.BaseBot> = {
-    [T in keyof IncomingStates<TBot>]?: StateExpiredHandlers<TBot>[T][];
+    [TStateName in utils.StringKeys<IncomingStates<TBot>>]?: StateExpiredHandlers<TBot>[TStateName][];
 };
 export type HookHandlersMap<TBot extends common.BaseBot> = {
-    [H in keyof HookData<TBot>]: {
-        [T in keyof HookData<TBot>[H]]?: HookHandlers<TBot>[H][T][];
+    [THookType in utils.StringKeys<HookData<TBot>>]: {
+        [THookDataName in utils.StringKeys<HookData<TBot>[THookType]>]?: HookHandlers<TBot>[THookType][THookDataName][];
     };
 };
-export type WorkflowPayloads<TBot extends common.BaseBot, TExtraTools extends object = {}> = {
-    [WorkflowName in utils.StringKeys<TBot['workflows']>]: CommonHandlerProps<TBot> & {
-        conversation?: client.Conversation;
-        user?: client.User;
-        /**
-         * # EXPERIMENTAL
-         * This API is experimental and may change in the future.
-         */
-        workflow: workflowProxy.WorkflowWithUtilities<TBot, WorkflowName>;
-    } & TExtraTools;
-};
-export type WorkflowHandlers<TBot extends common.BaseBot, TExtraTools extends object = {}> = {
-    [K in utils.StringKeys<TBot['workflows']>]: (props: WorkflowPayloads<TBot, TExtraTools>[K]) => Promise<void>;
+export type WorkflowUpdateType = 'started' | 'continued' | 'timed_out';
+export type WorkflowHandlersMap<TBot extends common.BaseBot> = {
+    [TWorkflowUpdateType in WorkflowUpdateType]: {
+        [TWorkflowName in utils.StringKeys<TBot['workflows']>]?: WorkflowHandlers<TBot>[TWorkflowName][];
+    };
 };
-export type WorkflowUpdateTypeSnakeCase = 'started' | 'continued' | 'timed_out';
-export type WorkflowUpdateTypeCamelCase = 'started' | 'continued' | 'timedOut';
-export type WorkflowHandlersMap<TBot extends common.BaseBot, TExtraTools extends object = {}> = {
-    [UpdateType in WorkflowUpdateTypeSnakeCase]?: {
-        [WorkflowName in utils.StringKeys<TBot['workflows']>]?: WorkflowHandlers<TBot, TExtraTools>[WorkflowName][];
+export type OrderedMessageHandlersMap<TBot extends common.BaseBot> = {
+    [TMessageName in utils.StringKeys<IncomingMessages<TBot>>]?: {
+        handler: MessageHandlers<TBot>[TMessageName];
+        order: number;
+    }[];
+};
+export type OrderedEventHandlersMap<TBot extends common.BaseBot> = {
+    [TEventName in utils.StringKeys<IncomingEvents<TBot>>]?: {
+        handler: EventHandlers<TBot>[TEventName];
+        order: number;
+    }[];
+};
+export type OrderedStateExpiredHandlersMap<TBot extends common.BaseBot> = {
+    [TStateName in utils.StringKeys<IncomingStates<TBot>>]?: {
+        handler: StateExpiredHandlers<TBot>[TStateName];
+        order: number;
+    }[];
+};
+export type OrderedHookHandlersMap<TBot extends common.BaseBot> = {
+    [THookType in utils.StringKeys<HookData<TBot>>]: {
+        [THookDataName in utils.StringKeys<HookData<TBot>[THookType]>]?: {
+            handler: HookHandlers<TBot>[THookType][THookDataName];
+            order: number;
+        }[];
     };
 };
-export type WorkflowHandlersFnMap<TBot extends common.BaseBot, TExtraTools extends object = {}> = {
-    [WorkflowName in utils.StringKeys<TBot['workflows']>]: {
-        [UType in WorkflowUpdateTypeCamelCase]: (handler: WorkflowHandlers<TBot, TExtraTools>[WorkflowName]) => void;
+export type OrderedWorkflowHandlersMap<TBot extends common.BaseBot> = {
+    [TWorkflowUpdateType in WorkflowUpdateType]: {
+        [TWorkflowName in utils.StringKeys<TBot['workflows']>]?: {
+            handler: WorkflowHandlers<TBot>[TWorkflowName];
+            order: number;
+        }[];
     };
 };
 /**
@@ -295,16 +323,16 @@ export type BotHandlers<TBot extends common.BaseBot> = {
 };
 type _GetPluginPrefix<TKey extends string, TPlugin extends plugin.BasePlugin> = TKey extends TPlugin['name'] ? '' : `${TKey}#`;
 type ImplementedActions<_TBot extends common.BaseBot, TPlugins extends Record<string, plugin.BasePlugin>> = utils.UnionToIntersection<utils.ValueOf<{
-    [TPlugin in keyof TPlugins]: {
-        [TAction in keyof TPlugins[TPlugin]['actions'] as `${_GetPluginPrefix<utils.Cast<TPlugin, string>, TPlugins[TPlugin]>}${utils.Cast<TAction, string>}`]: TPlugins[TPlugin]['actions'][TAction];
+    [TPlugin in utils.StringKeys<TPlugins>]: {
+        [TAction in utils.StringKeys<TPlugins[TPlugin]['actions']> as `${_GetPluginPrefix<utils.Cast<TPlugin, string>, TPlugins[TPlugin]>}${utils.Cast<TAction, string>}`]: TPlugins[TPlugin]['actions'][TAction];
     };
 }>>;
-type UnimplementedActions<TBot extends common.BaseBot, TPlugins extends Record<string, plugin.BasePlugin>> = Omit<TBot['actions'], keyof ImplementedActions<TBot, TPlugins>>;
+type UnimplementedActions<TBot extends common.BaseBot, TPlugins extends Record<string, plugin.BasePlugin>> = Omit<TBot['actions'], utils.StringKeys<ImplementedActions<TBot, TPlugins>>>;
 export type ImplementedActionHandlers<TBot extends common.BaseBot, TPlugins extends Record<string, plugin.BasePlugin>> = {
-    [K in keyof ImplementedActions<TBot, TPlugins>]: ActionHandlers<TBot>[utils.Cast<K, keyof ActionHandlers<TBot>>];
+    [K in utils.StringKeys<ImplementedActions<TBot, TPlugins>>]: ActionHandlers<TBot>[utils.Cast<K, keyof ActionHandlers<TBot>>];
 };
 export type UnimplementedActionHandlers<TBot extends common.BaseBot, TPlugins extends Record<string, plugin.BasePlugin>> = {
-    [K in keyof UnimplementedActions<TBot, TPlugins>]: ActionHandlers<TBot>[utils.Cast<K, keyof ActionHandlers<TBot>>];
+    [K in utils.StringKeys<UnimplementedActions<TBot, TPlugins>>]: ActionHandlers<TBot>[utils.Cast<K, keyof ActionHandlers<TBot>>];
 };
 export type ServerProps = Omit<CommonHandlerProps<common.BaseBot>, 'workflows'> & {
     req: Request;

package/dist/bot/server/workflows/update-handler.d.ts

@@ -1,3 +1,3 @@
 import { Response } from '../../../serve';
 import * as types from '../types';
-export declare const handleWorkflowUpdateEvent: (props: types.ServerProps, event: types.WorkflowUpdateEvent) => Promise<Response>;
+export declare const handleWorkflowUpdateEvent: (rawProps: types.ServerProps, event: types.WorkflowUpdateEvent) => Promise<Response>;

package/dist/bot/server/workflows/update-type-conv.d.ts

@@ -1,3 +1,2 @@
 import * as types from '../types';
-export declare const bridgeUpdateTypeToSnakeCase: (updateType: types.BridgeWorkflowUpdateType) => types.WorkflowUpdateTypeSnakeCase;
-export declare const camelCaseUpdateTypeToSnakeCase: (updateType: types.WorkflowUpdateTypeCamelCase) => types.WorkflowUpdateTypeSnakeCase;
+export declare const bridgeUpdateTypeToSnakeCase: (updateType: types.BridgeWorkflowUpdateType) => types.WorkflowUpdateType;