xstate 5.14.0 → 5.15.0

package/dist/declarations/src/StateMachine.d.ts

@@ -1,22 +1,17 @@
 import { MachineSnapshot } from "./State.js";
 import { StateNode } from "./StateNode.js";
 import { AnyActorSystem } from "./system.js";
-import { ResolveTypegenMeta, TypegenDisabled } from "./typegenTypes.js";
-import type { ActorLogic, ActorScope, AnyActorRef, AnyActorScope, DoNotInfer, Equals, EventDescriptor, EventObject, HistoryValue, InternalMachineImplementations, MachineConfig, MachineContext, MachineImplementationsSimplified, MetaObject, ParameterizedObject, ProvidedActor, Snapshot, StateMachineDefinition, StateValue, TransitionDefinition } from "./types.js";
+import type { ActorLogic, ActorScope, AnyActorRef, AnyActorScope, DoNotInfer, Equals, EventDescriptor, EventObject, HistoryValue, InternalMachineImplementations, MachineConfig, MachineContext, MachineImplementationsSimplified, MetaObject, ParameterizedObject, ProvidedActor, Snapshot, StateMachineDefinition, StateValue, TransitionDefinition, ResolvedStateMachineTypes } from "./types.js";
 export declare const STATE_IDENTIFIER = "#";
 export declare const WILDCARD = "*";
 export declare class StateMachine<TContext extends MachineContext, TEvent extends EventObject, TChildren extends Record<string, AnyActorRef | undefined>, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string, TStateValue extends StateValue, TTag extends string, TInput, TOutput, TEmitted extends EventObject = EventObject, // TODO: remove default
-TMeta extends MetaObject = MetaObject, TResolvedTypesMeta = ResolveTypegenMeta<TypegenDisabled, DoNotInfer<TEvent>, TActor, TAction, TGuard, TDelay, TTag, TEmitted>> implements ActorLogic<MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta>, TEvent, TInput, AnyActorSystem, TEmitted> {
-    /**
-     * The raw config used to create the machine.
-     */
+TMeta extends MetaObject = MetaObject> implements ActorLogic<MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta>, TEvent, TInput, AnyActorSystem, TEmitted> {
+    /** The raw config used to create the machine. */
     config: MachineConfig<TContext, TEvent, any, any, any, any, any, any, TOutput, any, // TEmitted
     any> & {
         schemas?: unknown;
     };
-    /**
-     * The machine's own version.
-     */
+    /** The machine's own version. */
     version?: string;
     schemas: unknown;
     implementations: MachineImplementationsSimplified<TContext, TEvent>;
@@ -25,24 +20,20 @@ TMeta extends MetaObject = MetaObject, TResolvedTypesMeta = ResolveTypegenMeta<T
     states: StateNode<TContext, TEvent>['states'];
     events: Array<EventDescriptor<TEvent>>;
     constructor(
-    /**
-     * The raw config used to create the machine.
-     */
+    /** The raw config used to create the machine. */
     config: MachineConfig<TContext, TEvent, any, any, any, any, any, any, TOutput, any, // TEmitted
     any> & {
         schemas?: unknown;
     }, implementations?: MachineImplementationsSimplified<TContext, TEvent>);
     /**
-     * Clones this state machine with the provided implementations
-     * and merges the `context` (if provided).
-     *
-     * @param implementations Options (`actions`, `guards`, `actors`, `delays`, `context`)
-     *  to recursively merge with the existing options.
+     * Clones this state machine with the provided implementations and merges the
+     * `context` (if provided).
      *
+     * @param implementations Options (`actions`, `guards`, `actors`, `delays`,
+     *   `context`) to recursively merge with the existing options.
      * @returns A new `StateMachine` instance with the provided implementations.
      */
-    provide(implementations: InternalMachineImplementations<TContext, TResolvedTypesMeta, true>): StateMachine<TContext, TEvent, TChildren, TActor, TAction, TGuard, TDelay, TStateValue, TTag, TInput, TOutput, TEmitted, TMeta, // TMeta
-    TResolvedTypesMeta>;
+    provide(implementations: InternalMachineImplementations<ResolvedStateMachineTypes<TContext, DoNotInfer<TEvent>, TActor, TAction, TGuard, TDelay, TTag, TEmitted>>): StateMachine<TContext, TEvent, TChildren, TActor, TAction, TGuard, TDelay, TStateValue, TTag, TInput, TOutput, TEmitted, TMeta>;
     resolveState(config: {
         value: StateValue;
         context?: TContext;
@@ -54,16 +45,16 @@ TMeta extends MetaObject = MetaObject, TResolvedTypesMeta = ResolveTypegenMeta<T
         context: unknown;
     } : {})): MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta>;
     /**
-     * Determines the next snapshot given the current `snapshot` and received `event`.
-     * Calculates a full macrostep from all microsteps.
+     * Determines the next snapshot given the current `snapshot` and received
+     * `event`. Calculates a full macrostep from all microsteps.
      *
      * @param snapshot The current snapshot
      * @param event The received event
      */
     transition(snapshot: MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta>, event: TEvent, actorScope: ActorScope<typeof snapshot, TEvent, AnyActorSystem, TEmitted>): MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta>;
     /**
-     * Determines the next state given the current `state` and `event`.
-     * Calculates a microstep.
+     * Determines the next state given the current `state` and `event`. Calculates
+     * a microstep.
      *
      * @param state The current state
      * @param event The received event
@@ -71,12 +62,13 @@ TMeta extends MetaObject = MetaObject, TResolvedTypesMeta = ResolveTypegenMeta<T
     microstep(snapshot: MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta>, event: TEvent, actorScope: AnyActorScope): Array<MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta>>;
     getTransitionData(snapshot: MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta>, event: TEvent): Array<TransitionDefinition<TContext, TEvent>>;
     /**
-     * The initial state _before_ evaluating any microsteps.
-     * This "pre-initial" state is provided to initial actions executed in the initial state.
+     * The initial state _before_ evaluating any microsteps. This "pre-initial"
+     * state is provided to initial actions executed in the initial state.
      */
     private getPreInitialState;
     /**
-     * Returns the initial `State` instance, with reference to `self` as an `ActorRef`.
+     * Returns the initial `State` instance, with reference to `self` as an
+     * `ActorRef`.
      */
     getInitialSnapshot(actorScope: ActorScope<MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta>, TEvent, AnyActorSystem, TEmitted>, input?: TInput): MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta>;
     start(snapshot: MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta>): void;
@@ -85,8 +77,4 @@ TMeta extends MetaObject = MetaObject, TResolvedTypesMeta = ResolveTypegenMeta<T
     toJSON(): StateMachineDefinition<TContext, TEvent>;
     getPersistedSnapshot(snapshot: MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta>, options?: unknown): Snapshot<unknown>;
     restoreSnapshot(snapshot: Snapshot<unknown>, _actorScope: ActorScope<MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta>, TEvent, AnyActorSystem, TEmitted>): MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta>;
-    /**
-     * @deprecated an internal property that was acting as a "phantom" type, it's not used by anything right now but it's kept around for compatibility reasons
-     **/
-    __TResolvedTypesMeta: TResolvedTypesMeta;
 }

package/dist/declarations/src/StateNode.d.ts

@@ -6,9 +6,7 @@ interface StateNodeOptions<TContext extends MachineContext, TEvent extends Event
     _machine: AnyStateMachine;
 }
 export declare class StateNode<TContext extends MachineContext = MachineContext, TEvent extends EventObject = EventObject> {
-    /**
-     * The raw config used to create the machine.
-     */
+    /** The raw config used to create the machine. */
     config: StateNodeConfig<TContext, TEvent, TODO, // actors
     TODO, // actions
     TODO, // guards
@@ -18,74 +16,64 @@ export declare class StateNode<TContext extends MachineContext = MachineContext,
     TODO, // emitted
     TODO>;
     /**
-     * The relative key of the state node, which represents its location in the overall state value.
+     * The relative key of the state node, which represents its location in the
+     * overall state value.
      */
     key: string;
-    /**
-     * The unique ID of the state node.
-     */
+    /** The unique ID of the state node. */
     id: string;
     /**
      * The type of this state node:
      *
-     *  - `'atomic'` - no child state nodes
-     *  - `'compound'` - nested child state nodes (XOR)
-     *  - `'parallel'` - orthogonal nested child state nodes (AND)
-     *  - `'history'` - history state node
-     *  - `'final'` - final state node
+     * - `'atomic'` - no child state nodes
+     * - `'compound'` - nested child state nodes (XOR)
+     * - `'parallel'` - orthogonal nested child state nodes (AND)
+     * - `'history'` - history state node
+     * - `'final'` - final state node
      */
     type: 'atomic' | 'compound' | 'parallel' | 'final' | 'history';
-    /**
-     * The string path from the root machine node to this node.
-     */
+    /** The string path from the root machine node to this node. */
     path: string[];
-    /**
-     * The child state nodes.
-     */
+    /** The child state nodes. */
     states: StateNodesConfig<TContext, TEvent>;
     /**
      * The type of history on this state node. Can be:
      *
-     *  - `'shallow'` - recalls only top-level historical state value
-     *  - `'deep'` - recalls historical state value at all levels
+     * - `'shallow'` - recalls only top-level historical state value
+     * - `'deep'` - recalls historical state value at all levels
      */
     history: false | 'shallow' | 'deep';
-    /**
-     * The action(s) to be executed upon entering the state node.
-     */
+    /** The action(s) to be executed upon entering the state node. */
     entry: UnknownAction[];
-    /**
-     * The action(s) to be executed upon exiting the state node.
-     */
+    /** The action(s) to be executed upon exiting the state node. */
     exit: UnknownAction[];
-    /**
-     * The parent state node.
-     */
+    /** The parent state node. */
     parent?: StateNode<TContext, TEvent>;
-    /**
-     * The root machine node.
-     */
+    /** The root machine node. */
     machine: StateMachine<TContext, TEvent, any, // children
     any, // actor
     any, // action
     any, // guard
     any, // delay
+    any, // state value
     any, // tag
     any, // input
     any, // output
     any, // emitted
-    any, // TMeta
     any>;
     /**
-     * The meta data associated with this state node, which will be returned in State instances.
+     * The meta data associated with this state node, which will be returned in
+     * State instances.
      */
     meta?: any;
     /**
-     * The output data sent with the "xstate.done.state._id_" event if this is a final state node.
+     * The output data sent with the "xstate.done.state._id_" event if this is a
+     * final state node.
      */
     output?: Mapper<MachineContext, EventObject, unknown, EventObject> | NonReducibleUnknown;
     /**
-     * The order this state node appears. Corresponds to the implicit document order.
+     * The order this state node appears. Corresponds to the implicit document
+     * order.
      */
     order: number;
     description?: string;
@@ -93,9 +81,7 @@ export declare class StateNode<TContext extends MachineContext = MachineContext,
     transitions: Map<string, TransitionDefinition<TContext, TEvent>[]>;
     always?: Array<TransitionDefinition<TContext, TEvent>>;
     constructor(
-    /**
-     * The raw config used to create the machine.
-     */
+    /** The raw config used to create the machine. */
     config: StateNodeConfig<TContext, TEvent, TODO, // actors
     TODO, // actions
     TODO, // guards
@@ -104,24 +90,16 @@ export declare class StateNode<TContext extends MachineContext = MachineContext,
     TODO, // output
     TODO, // emitted
     TODO>, options: StateNodeOptions<TContext, TEvent>);
-    /**
-     * The well-structured state node definition.
-     */
+    /** The well-structured state node definition. */
     get definition(): StateNodeDefinition<TContext, TEvent>;
-    /**
-     * The logic invoked as actors by this state node.
-     */
+    /** The logic invoked as actors by this state node. */
     get invoke(): Array<InvokeDefinition<TContext, TEvent, ProvidedActor, ParameterizedObject, ParameterizedObject, string, TODO, // TEmitted
     TODO>>;
-    /**
-     * The mapping of events to transitions.
-     */
+    /** The mapping of events to transitions. */
     get on(): TransitionDefinitionMap<TContext, TEvent>;
     get after(): Array<DelayedTransitionDefinition<TContext, TEvent>>;
     get initial(): InitialTransitionDefinition<TContext, TEvent>;
-    /**
-     * All the event types accepted by this state node and its descendants.
-     */
+    /** All the event types accepted by this state node and its descendants. */
     get events(): Array<EventDescriptor<TEvent>>;
     /**
      * All the events that have transitions directly from this state node.

package/dist/declarations/src/actions/assign.d.ts

@@ -10,34 +10,36 @@ export interface AssignAction<TContext extends MachineContext, TExpressionEvent
 /**
  * Updates the current context of the machine.
  *
- * @param assignment An object that represents the partial context to update, or a
- * function that returns an object that represents the partial context to update.
- *
  * @example
-  ```ts
-  import { createMachine, assign } from 'xstate';
-
-  const countMachine = createMachine({
-    context: {
-      count: 0,
-      message: ''
-    },
-    on: {
-      inc: {
-        actions: assign({
-          count: ({ context }) => context.count + 1
-        })
-      },
-      updateMessage: {
-        actions: assign(({ context, event }) => {
-          return {
-            message: event.message.trim()
-          }
-        })
-      }
-    }
-  });
-  ```
+ *
+ * ```ts
+ * import { createMachine, assign } from 'xstate';
+ *
+ * const countMachine = createMachine({
+ *   context: {
+ *     count: 0,
+ *     message: ''
+ *   },
+ *   on: {
+ *     inc: {
+ *       actions: assign({
+ *         count: ({ context }) => context.count + 1
+ *       })
+ *     },
+ *     updateMessage: {
+ *       actions: assign(({ context, event }) => {
+ *         return {
+ *           message: event.message.trim()
+ *         };
+ *       })
+ *     }
+ *   }
+ * });
+ * ```
+ *
+ * @param assignment An object that represents the partial context to update, or
+ *   a function that returns an object that represents the partial context to
+ *   update.
  */
 export declare function assign<TContext extends MachineContext, TExpressionEvent extends AnyEventObject, // TODO: consider using a stricter `EventObject` here
 TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject, TActor extends ProvidedActor>(assignment: Assigner<LowInfer<TContext>, TExpressionEvent, TParams, TEvent, TActor> | PropertyAssigner<LowInfer<TContext>, TExpressionEvent, TParams, TEvent, TActor>): ActionFunction<TContext, TExpressionEvent, TEvent, TParams, TActor, never, never, never, never>;

package/dist/declarations/src/actions/cancel.d.ts

@@ -4,30 +4,36 @@ export interface CancelAction<TContext extends MachineContext, TExpressionEvent
     (args: ActionArgs<TContext, TExpressionEvent, TEvent>, params: TParams): void;
 }
 /**
- * Cancels a delayed `sendTo(...)` action that is waiting to be executed. The canceled `sendTo(...)` action
- * will not send its event or execute, unless the `delay` has already elapsed before `cancel(...)` is called.
- *
- * @param sendId The `id` of the `sendTo(...)` action to cancel.
+ * Cancels a delayed `sendTo(...)` action that is waiting to be executed. The
+ * canceled `sendTo(...)` action will not send its event or execute, unless the
+ * `delay` has already elapsed before `cancel(...)` is called.
  *
  * @example
-  ```ts
-  import { createMachine, sendTo, cancel } from 'xstate';
-
-  const machine = createMachine({
-    // ...
-    on: {
-      sendEvent: {
-        actions: sendTo('some-actor', { type: 'someEvent' }, {
-          id: 'some-id',
-          delay: 1000
-        })
-      },
-      cancelEvent: {
-        actions: cancel('some-id')
-      }
-    }
-  });
-  ```
+ *
+ * ```ts
+ * import { createMachine, sendTo, cancel } from 'xstate';
+ *
+ * const machine = createMachine({
+ *   // ...
+ *   on: {
+ *     sendEvent: {
+ *       actions: sendTo(
+ *         'some-actor',
+ *         { type: 'someEvent' },
+ *         {
+ *           id: 'some-id',
+ *           delay: 1000
+ *         }
+ *       )
+ *     },
+ *     cancelEvent: {
+ *       actions: cancel('some-id')
+ *     }
+ *   }
+ * });
+ * ```
+ *
+ * @param sendId The `id` of the `sendTo(...)` action to cancel.
  */
 export declare function cancel<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject>(sendId: ResolvableSendId<TContext, TExpressionEvent, TParams, TEvent>): CancelAction<TContext, TExpressionEvent, TParams, TEvent>;
 export {};

package/dist/declarations/src/actions/emit.d.ts

@@ -4,41 +4,41 @@ export interface EmitAction<TContext extends MachineContext, TExpressionEvent ex
     _out_TEmitted?: TEmitted;
 }
 /**
- * Emits an event to event handlers registered on the actor via `actor.on(event, handler)`.
+ * Emits an event to event handlers registered on the actor via `actor.on(event,
+ * handler)`.
  *
  * @example
-  ```ts
-  import { emit } from 'xstate';
-
-  const machine = createMachine({
-    // ...
-    on: {
-      something: {
-        actions: emit({
-          type: 'emitted',
-          some: 'data'
-        })
-      }
-    }
-    // ...
-  });
-
-  const actor = createActor(machine).start();
-
-  actor.on('emitted', (event) => {
-    console.log(event);
-  });
-
-  actor.send({ type: 'something' });
-  // logs:
-  // {
-  //   type: 'emitted',
-  //   some: 'data'
-  // }
-  ```
+ *
+ * ```ts
+ * import { emit } from 'xstate';
+ *
+ * const machine = createMachine({
+ *   // ...
+ *   on: {
+ *     something: {
+ *       actions: emit({
+ *         type: 'emitted',
+ *         some: 'data'
+ *       })
+ *     }
+ *   }
+ *   // ...
+ * });
+ *
+ * const actor = createActor(machine).start();
+ *
+ * actor.on('emitted', (event) => {
+ *   console.log(event);
+ * });
+ *
+ * actor.send({ type: 'something' });
+ * // logs:
+ * // {
+ * //   type: 'emitted',
+ * //   some: 'data'
+ * // }
+ * ```
  */
 export declare function emit<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject, TEmitted extends EventObject>(
-/**
- * The event to emit, or an expression that returns an event to emit.
- */
+/** The event to emit, or an expression that returns an event to emit. */
 eventOrExpr: TEmitted | SendExpr<TContext, TExpressionEvent, TParams, TEmitted, TEvent>): ActionFunction<TContext, TExpressionEvent, TEvent, TParams, never, never, never, never, TEmitted>;

package/dist/declarations/src/actions/enqueueActions.d.ts

@@ -31,24 +31,26 @@ interface CollectActionsArg<TContext extends MachineContext, TExpressionEvent ex
 }
 type CollectActions<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string, TEmitted extends EventObject> = ({ context, event, check, enqueue, self }: CollectActionsArg<TContext, TExpressionEvent, TEvent, TActor, TAction, TGuard, TDelay, TEmitted>, params: TParams) => void;
 /**
- * Creates an action object that will execute actions that are queued by the `enqueue(action)` function.
+ * Creates an action object that will execute actions that are queued by the
+ * `enqueue(action)` function.
  *
  * @example
-  ```ts
-  import { createMachine, enqueueActions } from 'xstate';
-
-  const machine = createMachine({
-    entry: enqueueActions(({ enqueue, check }) => {
-      enqueue.assign({ count: 0 });
-
-      if (check('someGuard')) {
-        enqueue.assign({ count: 1 });
-      }
-
-      enqueue('someAction');
-    })
-  })
-  ```
+ *
+ * ```ts
+ * import { createMachine, enqueueActions } from 'xstate';
+ *
+ * const machine = createMachine({
+ *   entry: enqueueActions(({ enqueue, check }) => {
+ *     enqueue.assign({ count: 0 });
+ *
+ *     if (check('someGuard')) {
+ *       enqueue.assign({ count: 1 });
+ *     }
+ *
+ *     enqueue('someAction');
+ *   })
+ * });
+ * ```
  */
 export declare function enqueueActions<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject = TExpressionEvent, TActor extends ProvidedActor = ProvidedActor, TAction extends ParameterizedObject = ParameterizedObject, TGuard extends ParameterizedObject = ParameterizedObject, TDelay extends string = never, TEmitted extends EventObject = EventObject>(collect: CollectActions<TContext, TExpressionEvent, TParams, TEvent, TActor, TAction, TGuard, TDelay, TEmitted>): ActionFunction<TContext, TExpressionEvent, TEvent, TParams, TActor, TAction, TGuard, TDelay, TEmitted>;
 export {};

package/dist/declarations/src/actions/log.d.ts

@@ -4,11 +4,12 @@ export interface LogAction<TContext extends MachineContext, TExpressionEvent ext
     (args: ActionArgs<TContext, TExpressionEvent, TEvent>, params: TParams): void;
 }
 /**
+ * @param expr The expression function to evaluate which will be logged. Takes
+ *   in 2 arguments:
+ *
+ *   - `ctx` - the current state context
+ *   - `event` - the event that caused this action to be executed.
  *
- * @param expr The expression function to evaluate which will be logged.
- *  Takes in 2 arguments:
- *  - `ctx` - the current state context
- *  - `event` - the event that caused this action to be executed.
  * @param label The label to give to the logged expression.
  */
 export declare function log<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject>(value?: ResolvableLogValue<TContext, TExpressionEvent, TParams, TEvent>, label?: string): LogAction<TContext, TExpressionEvent, TParams, TEvent>;

package/dist/declarations/src/actions/send.d.ts

@@ -7,10 +7,12 @@ export interface SendToAction<TContext extends MachineContext, TExpressionEvent
  * Sends an event to an actor.
  *
  * @param actor The `ActorRef` to send the event to.
- * @param event The event to send, or an expression that evaluates to the event to send
+ * @param event The event to send, or an expression that evaluates to the event
+ *   to send
  * @param options Send action options
- *  - `id` - The unique send event identifier (used with `cancel()`).
- *  - `delay` - The number of milliseconds to delay the sending of the event.
+ *
+ *   - `id` - The unique send event identifier (used with `cancel()`).
+ *   - `delay` - The number of milliseconds to delay the sending of the event.
  */
 export declare function sendTo<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TTargetActor extends AnyActorRef, TEvent extends EventObject, TDelay extends string = never, TUsedDelay extends TDelay = never>(to: TTargetActor | string | ((args: ActionArgs<TContext, TExpressionEvent, TEvent>, params: TParams) => TTargetActor | string), eventOrExpr: EventFrom<TTargetActor> | SendExpr<TContext, TExpressionEvent, TParams, InferEvent<Cast<EventFrom<TTargetActor>, EventObject>>, TEvent>, options?: SendToActionOptions<TContext, TExpressionEvent, TParams, DoNotInfer<TEvent>, TUsedDelay>): ActionFunction<TContext, TExpressionEvent, TEvent, TParams, never, never, never, TDelay, never>;
 /**