@botpress/sdk 3.3.2 → 3.5.0

package/.turbo/turbo-build.log

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

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

@@ -17,6 +17,7 @@ export declare class BotSpecificClient<TBot extends common.BaseBot> implements t
     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>;
@@ -48,6 +49,11 @@ export declare class BotSpecificClient<TBot extends common.BaseBot> implements t
     deleteTableRows: types.DeleteTableRows<TBot>;
     updateTableRows: types.UpdateTableRows<TBot>;
     upsertTableRows: types.UpsertTableRows<TBot>;
+    createWorkflow: types.CreateWorkflow<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.
      */

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

@@ -34,6 +34,10 @@ export type ListParticipants<_TBot extends common.BaseBot> = client.Client['list
 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']>, {
@@ -86,6 +90,22 @@ 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 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'];
@@ -178,6 +198,7 @@ export type ClientOperations<TBot extends common.BaseBot> = {
     getParticipant: GetParticipant<TBot>;
     removeParticipant: RemoveParticipant<TBot>;
     getEvent: GetEvent<TBot>;
+    createEvent: CreateEvent<TBot>;
     listEvents: ListEvents<TBot>;
     createMessage: CreateMessage<TBot>;
     getOrCreateMessage: GetOrCreateMessage<TBot>;

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

@@ -8,12 +8,20 @@ export type BaseAction = {
 export type BaseTable = {
     [k: string]: any;
 };
+export type BaseWorkflow = {
+    input: any;
+    output: any;
+    tags?: {
+        [k: string]: string;
+    };
+};
 export type BaseBot = {
     integrations: Record<string, BaseIntegration>;
     events: Record<string, any>;
     states: Record<string, any>;
     actions: Record<string, BaseAction>;
     tables: Record<string, BaseTable>;
+    workflows: Record<string, BaseWorkflow>;
 };
 export type InputBaseBot = utils.DeepPartial<BaseBot>;
 export type DefaultBot<B extends InputBaseBot> = {
@@ -24,4 +32,5 @@ export type DefaultBot<B extends InputBaseBot> = {
         [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/definition.d.ts

@@ -9,6 +9,7 @@ type BaseStates = Record<string, ZuiObjectSchema>;
 type BaseEvents = Record<string, ZuiObjectSchema>;
 type BaseActions = Record<string, ZuiObjectSchema>;
 type BaseTables = Record<string, ZuiObjectSchema>;
+type BaseWorkflows = Record<string, ZuiObjectSchema>;
 export type TagDefinition = {
     title?: string;
     description?: string;
@@ -44,6 +45,13 @@ export type ActionDefinition<TAction extends BaseActions[string] = BaseActions[s
     input: SchemaDefinition<TAction>;
     output: SchemaDefinition<ZuiObjectSchema>;
 };
+export type WorkflowDefinition<TWorkflow extends BaseWorkflows[string] = BaseWorkflows[string]> = {
+    title?: string;
+    description?: string;
+    input: SchemaDefinition<TWorkflow>;
+    output: SchemaDefinition<ZuiObjectSchema>;
+    tags?: Record<string, TagDefinition>;
+};
 export type TableDefinition<TTable extends BaseTables[string] = BaseTables[string]> = Merge<Omit<Table, 'id' | 'createdAt' | 'updatedAt' | 'name'>, {
     schema: TTable;
 }>;
@@ -59,6 +67,7 @@ export type IntegrationConfigInstance<I extends IntegrationPackage = Integration
     };
 }>);
 export type PluginConfigInstance<P extends PluginPackage = PluginPackage> = {
+    alias?: string;
     configuration: z.infer<NonNullable<P['definition']['configuration']>['schema']>;
     interfaces: {
         [I in keyof NonNullable<P['definition']['interfaces']>]: PluginInterfaceExtension;
@@ -66,7 +75,7 @@ export type PluginConfigInstance<P extends PluginPackage = PluginPackage> = {
 };
 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, TTables extends BaseTables = BaseTables> = {
+export type BotDefinitionProps<TStates extends BaseStates = BaseStates, TEvents extends BaseEvents = BaseEvents, TActions extends BaseActions = BaseActions, TTables extends BaseTables = BaseTables, TWorkflows extends BaseWorkflows = BaseWorkflows> = {
     integrations?: {
         [K: string]: IntegrationInstance;
     };
@@ -90,9 +99,16 @@ export type BotDefinitionProps<TStates extends BaseStates = BaseStates, TEvents
     tables?: {
         [K in keyof TTables]: TableDefinition<TTables[K]>;
     };
+    /**
+     * # EXPERIMENTAL
+     * This API is experimental and may change in the future.
+     */
+    workflows?: {
+        [K in keyof TWorkflows]: WorkflowDefinition<TWorkflows[K]>;
+    };
 };
-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>;
+export declare class BotDefinition<TStates extends BaseStates = BaseStates, TEvents extends BaseEvents = BaseEvents, TActions extends BaseActions = BaseActions, TTables extends BaseTables = BaseTables, TWorkflows extends BaseWorkflows = BaseWorkflows> {
+    readonly props: BotDefinitionProps<TStates, TEvents, TActions, TTables, TWorkflows>;
     readonly integrations: this['props']['integrations'];
     readonly plugins: this['props']['plugins'];
     readonly user: this['props']['user'];
@@ -104,7 +120,8 @@ export declare class BotDefinition<TStates extends BaseStates = BaseStates, TEve
     readonly recurringEvents: this['props']['recurringEvents'];
     readonly actions: this['props']['actions'];
     readonly tables: this['props']['tables'];
-    constructor(props: BotDefinitionProps<TStates, TEvents, TActions, TTables>);
+    readonly workflows: this['props']['workflows'];
+    constructor(props: BotDefinitionProps<TStates, TEvents, TActions, TTables, TWorkflows>);
     addIntegration<I extends IntegrationPackage>(integrationPkg: I, config: IntegrationConfigInstance<I>): this;
     addPlugin<P extends PluginPackage>(pluginPkg: P, config: PluginConfigInstance<P>): this;
     private _mergeUser;
@@ -115,5 +132,7 @@ export declare class BotDefinition<TStates extends BaseStates = BaseStates, TEve
     private _mergeRecurringEvents;
     private _mergeActions;
     private _mergeTables;
+    private _mergeWorkflows;
+    private _prefixKeys;
 }
 export {};

package/dist/bot/implementation.d.ts

@@ -1,7 +1,7 @@
 import type { Server } from 'node:http';
 import { BasePlugin, PluginImplementation } from '../plugin';
 import { BaseBot } from './common';
-import { MessageHandlersMap, MessageHandlers, EventHandlersMap, EventHandlers, StateExpiredHandlersMap, StateExpiredHandlers, HookHandlersMap, HookData, HookHandlers, ActionHandlers, BotHandlers, UnimplementedActionHandlers } from './server';
+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';
 export type BotImplementationProps<TBot extends BaseBot = BaseBot, TPlugins extends Record<string, BasePlugin> = {}> = {
     actions: UnimplementedActionHandlers<TBot, TPlugins>;
     plugins: {
@@ -15,6 +15,7 @@ export declare class BotImplementation<TBot extends BaseBot = BaseBot, TPlugins
     private _eventHandlers;
     private _stateExpiredHandlers;
     private _hookHandlers;
+    private _workflowHandlers;
     private _plugins;
     constructor(props: BotImplementationProps<TBot, TPlugins>);
     get actionHandlers(): ActionHandlers<TBot>;
@@ -22,8 +23,14 @@ export declare class BotImplementation<TBot extends BaseBot = BaseBot, TPlugins
     get eventHandlers(): EventHandlersMap<TBot>;
     get stateExpiredHandlers(): StateExpiredHandlersMap<TBot>;
     get hookHandlers(): HookHandlersMap<TBot>;
+    get workflowHandlers(): WorkflowHandlersMap<TBot>;
     readonly on: {
         message: <T extends keyof MessageHandlersMap<TBot>>(type: T, handler: MessageHandlers<TBot>[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;

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

@@ -0,0 +1,3 @@
+export declare const SUCCESS_RESPONSE: {
+    readonly status: 200;
+};

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

@@ -1,9 +1,11 @@
 import * as client from '@botpress/client';
 import * as plugin from '../../plugin';
+import type { Request } from '../../serve';
 import * as utils from '../../utils/type-utils';
 import { type BotLogger } from '../bot-logger';
 import { BotSpecificClient } from '../client';
 import * as common from '../common';
+import type * as workflowProxy from '../workflow-proxy/types';
 export type BotOperation = 'event_received' | 'register' | 'unregister' | 'ping' | 'action_triggered';
 export type BotContext = {
     botId: string;
@@ -88,6 +90,11 @@ export type CommonHandlerProps<TBot extends common.BaseBot> = {
     ctx: BotContext;
     logger: BotLogger;
     client: BotClient<TBot>;
+    /**
+     * # EXPERIMENTAL
+     * This API is experimental and may change in the future.
+     */
+    workflows: workflowProxy.WorkflowProxy<TBot>;
 };
 export type MessagePayloads<TBot extends common.BaseBot> = {
     [K in keyof IncomingMessages<TBot>]: CommonHandlerProps<TBot> & {
@@ -131,6 +138,18 @@ export type ActionHandlerPayloads<TBot extends common.BaseBot> = {
 export type ActionHandlers<TBot extends common.BaseBot> = {
     [K in keyof TBot['actions']]: (props: ActionHandlerPayloads<TBot>[K]) => Promise<TBot['actions'][K]['output']>;
 };
+export type BridgeWorkflowUpdateType = 'child_workflow_deleted' | 'child_workflow_finished' | 'workflow_timedout' | 'workflow_started' | 'workflow_continued';
+export type WorkflowUpdateEventPayload = {
+    type: BridgeWorkflowUpdateType;
+    childWorkflow?: client.Workflow;
+    workflow: client.Workflow;
+    conversation?: client.Conversation;
+    user?: client.User;
+};
+export type WorkflowUpdateEvent = utils.Merge<client.Event, {
+    type: 'workflow_update';
+    payload: WorkflowUpdateEventPayload;
+}>;
 type BaseHookDefinition = {
     stoppable?: boolean;
     data: any;
@@ -235,6 +254,32 @@ export type HookHandlersMap<TBot extends common.BaseBot> = {
         [T in keyof HookData<TBot>[H]]?: HookHandlers<TBot>[H][T][];
     };
 };
+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 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 WorkflowHandlersFnMap<TBot extends common.BaseBot, TExtraTools extends object = {}> = {
+    [WorkflowName in utils.StringKeys<TBot['workflows']>]: {
+        [UType in WorkflowUpdateTypeCamelCase]: (handler: WorkflowHandlers<TBot, TExtraTools>[WorkflowName]) => void;
+    };
+};
 /**
  * TODO:
  * the consumer of this type shouldnt be able to access "*" directly;
@@ -246,9 +291,13 @@ export type BotHandlers<TBot extends common.BaseBot> = {
     eventHandlers: EventHandlersMap<TBot>;
     stateExpiredHandlers: StateExpiredHandlersMap<TBot>;
     hookHandlers: HookHandlersMap<TBot>;
+    workflowHandlers: WorkflowHandlersMap<TBot>;
 };
+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<{
-    [K in keyof TPlugins]: TPlugins[K]['actions'];
+    [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];
+    };
 }>>;
 type UnimplementedActions<TBot extends common.BaseBot, TPlugins extends Record<string, plugin.BasePlugin>> = Omit<TBot['actions'], keyof ImplementedActions<TBot, TPlugins>>;
 export type ImplementedActionHandlers<TBot extends common.BaseBot, TPlugins extends Record<string, plugin.BasePlugin>> = {
@@ -257,4 +306,8 @@ export type ImplementedActionHandlers<TBot extends common.BaseBot, TPlugins exte
 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>>];
 };
+export type ServerProps = Omit<CommonHandlerProps<common.BaseBot>, 'workflows'> & {
+    req: Request;
+    self: BotHandlers<common.BaseBot>;
+};
 export {};

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

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

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

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

package/dist/bot/workflow-proxy/index.d.ts

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

package/dist/bot/workflow-proxy/proxy.d.ts

@@ -0,0 +1,10 @@
+import type * as client from '@botpress/client';
+import type { BotSpecificClient } from '../../bot';
+import type * as typeUtils from '../../utils/type-utils';
+import type { BaseBot } from '../common';
+import type { WorkflowProxy, WorkflowWithUtilities } from './types';
+export declare const proxyWorkflows: <TBot extends BaseBot>(client: BotSpecificClient<TBot> | client.Client) => WorkflowProxy<TBot>;
+export declare const wrapWorkflowInstance: <TBot extends BaseBot, TWorkflowName extends typeUtils.StringKeys<TBot["workflows"]>>(props: {
+    client: BotSpecificClient<TBot> | client.Client;
+    workflow: client.Workflow;
+}) => WorkflowWithUtilities<TBot, TWorkflowName>;

package/dist/bot/workflow-proxy/types.d.ts

@@ -0,0 +1,64 @@
+import type * as client from '@botpress/client';
+import type * as typeUtils from '../../utils/type-utils';
+import type * as commonTypes from '../common';
+export type WorkflowProxy<TBot extends commonTypes.BaseBot = commonTypes.BaseBot> = Readonly<{
+    [TWorkflowName in typeUtils.StringKeys<TBot['workflows']>]: Readonly<{
+        startNewInstance: (x: Pick<client.ClientInputs['createWorkflow'], 'conversationId' | 'userId' | 'timeoutAt'> & {
+            tags?: typeUtils.AtLeastOneProperty<TBot['workflows'][TWorkflowName]['tags']>;
+            input: TBot['workflows'][TWorkflowName]['input'];
+        }) => Promise<Readonly<Omit<client.ClientOutputs['createWorkflow'], 'workflow'> & {
+            workflow: WorkflowWithUtilities<TBot, TWorkflowName>;
+        }>>;
+        listInstances: Readonly<{
+            all: _ListInstances<TBot, TWorkflowName>;
+            running: _ListInstances<TBot, TWorkflowName>;
+            scheduled: _ListInstances<TBot, TWorkflowName>;
+            allFinished: _ListInstances<TBot, TWorkflowName>;
+            succeeded: _ListInstances<TBot, TWorkflowName>;
+            cancelled: _ListInstances<TBot, TWorkflowName>;
+            timedOut: _ListInstances<TBot, TWorkflowName>;
+            failed: _ListInstances<TBot, TWorkflowName>;
+        }>;
+    }>;
+}>;
+type _ListInstances<TBot extends commonTypes.BaseBot, TWorkflowName extends typeUtils.StringKeys<TBot['workflows']>> = (x?: Pick<client.ClientInputs['listWorkflows'], 'nextToken' | 'conversationId' | 'userId'> & {
+    tags?: typeUtils.AtLeastOneProperty<TBot['workflows'][TWorkflowName]['tags']>;
+}) => Promise<Readonly<Omit<client.ClientOutputs['listWorkflows'], 'workflows'> & {
+    workflows: WorkflowWithUtilities<TBot, TWorkflowName>[];
+}>>;
+export type WorkflowWithUtilities<TBot extends commonTypes.BaseBot, TWorkflowName extends typeUtils.StringKeys<TBot['workflows']>> = Readonly<client.Workflow & {
+    name: TWorkflowName;
+    input: typeUtils.Cast<TBot['workflows'][TWorkflowName], commonTypes.IntegrationInstanceActionDefinition>['input'];
+    output: Partial<typeUtils.Cast<TBot['workflows'][TWorkflowName], commonTypes.IntegrationInstanceActionDefinition>['output']>;
+    tags: Partial<TBot['workflows'][TWorkflowName]['tags']>;
+    /**
+     * Updates the current workflow instance
+     */
+    update(x: typeUtils.AtLeastOneProperty<Pick<client.ClientInputs['updateWorkflow'], 'userId' | 'timeoutAt'> & {
+        tags?: typeUtils.AtLeastOneProperty<TBot['workflows'][TWorkflowName]['tags']>;
+        output?: typeUtils.Cast<TBot['workflows'][TWorkflowName], commonTypes.IntegrationInstanceActionDefinition>['output'];
+    }>): Promise<{
+        workflow: WorkflowWithUtilities<TBot, TWorkflowName>;
+    }>;
+    /**
+     * Marks the current workflow instance as failed and stops execution
+     */
+    setFailed(x: Required<Pick<client.ClientInputs['updateWorkflow'], 'failureReason'>>): Promise<{
+        workflow: WorkflowWithUtilities<TBot, TWorkflowName>;
+    }>;
+    /**
+     * Marks the current workflow instance as completed and stops execution
+     */
+    setCompleted(x?: {
+        output?: typeUtils.Cast<TBot['workflows'][TWorkflowName], commonTypes.IntegrationInstanceActionDefinition>['output'];
+    }): Promise<{
+        workflow: WorkflowWithUtilities<TBot, TWorkflowName>;
+    }>;
+    /**
+     * Discards all output data and cancels the current workflow instance
+     */
+    cancel(): Promise<{
+        workflow: WorkflowWithUtilities<TBot, TWorkflowName>;
+    }>;
+}>;
+export {};

package/dist/bot/workflow-proxy/types.test.d.ts

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

package/dist/fixtures.d.ts

@@ -173,6 +173,21 @@ export type FooBarBazBot = DefaultBot<{
             age: number;
         };
     };
+    workflows: {
+        fooWorkflow: {
+            tags: {
+                foo: string;
+            };
+            input: {
+                string: string;
+                optionalNumber?: number;
+            };
+            output: {
+                optionalString?: string;
+                number: number;
+            };
+        };
+    };
 }>;
 export type FooBarBazPlugin = DefaultPlugin<{
     integrations: {
@@ -191,6 +206,21 @@ export type FooBarBazPlugin = DefaultPlugin<{
             };
         };
     };
+    workflows: {
+        fooWorkflow: {
+            tags: {
+                foo: string;
+            };
+            input: {
+                string: string;
+                optionalNumber?: number;
+            };
+            output: {
+                optionalString?: string;
+                number: number;
+            };
+        };
+    };
 }>;
 export type EmptyBot = DefaultBot<{
     integrations: {};