xstate 5.0.0-beta.21 → 5.0.0-beta.23

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

@@ -1,9 +1,9 @@
-import { ActionArgs, ActorRef, AnyActorContext, AnyActorRef, AnyEventObject, AnyState, Cast, DelayExpr, EventFrom, EventObject, InferEvent, MachineContext, SendExpr, SendToActionOptions, SendToActionParams, UnifiedArg } from "../types.js";
-declare function resolve(actorContext: AnyActorContext, state: AnyState, args: ActionArgs<any, any>, { to, event: eventOrExpr, id, delay }: {
+import { ActionArgs, ActorRef, AnyActorContext, AnyActorRef, AnyEventObject, AnyState, Cast, DelayExpr, EventFrom, EventObject, InferEvent, MachineContext, SendExpr, SendToActionOptions, SendToActionParams, UnifiedArg, ParameterizedObject } from "../types.js";
+declare function resolve(actorContext: AnyActorContext, state: AnyState, args: ActionArgs<any, any, any>, { to, event: eventOrExpr, id, delay }: {
     to: AnyActorRef | string | ((args: UnifiedArg<MachineContext, EventObject>) => AnyActorRef | string);
-    event: EventObject | SendExpr<MachineContext, EventObject, EventObject>;
+    event: EventObject | SendExpr<MachineContext, EventObject, ParameterizedObject | undefined, EventObject>;
     id: string | undefined;
-    delay: string | number | DelayExpr<MachineContext, EventObject> | undefined;
+    delay: string | number | DelayExpr<MachineContext, EventObject, ParameterizedObject | undefined> | undefined;
 }): (AnyState | {
     to: AnyActorRef;
     event: EventObject;
@@ -25,13 +25,13 @@ declare function execute(actorContext: AnyActorContext, params: {
  *  - `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, TEvent extends EventObject, TActor extends AnyActorRef>(to: TActor | string | ((args: UnifiedArg<TContext, TExpressionEvent>) => TActor | string), eventOrExpr: EventFrom<TActor> | SendExpr<TContext, TExpressionEvent, InferEvent<Cast<EventFrom<TActor>, EventObject>>>, options?: SendToActionOptions<TContext, TExpressionEvent>): {
-    (_: ActionArgs<TContext, TExpressionEvent>): void;
+export declare function sendTo<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionAction extends ParameterizedObject | undefined, TActor extends AnyActorRef>(to: TActor | string | ((args: ActionArgs<TContext, TExpressionEvent, TExpressionAction>) => TActor | string), eventOrExpr: EventFrom<TActor> | SendExpr<TContext, TExpressionEvent, TExpressionAction, InferEvent<Cast<EventFrom<TActor>, EventObject>>>, options?: SendToActionOptions<TContext, TExpressionEvent, TExpressionAction>): {
+    (_: ActionArgs<TContext, TExpressionEvent, TExpressionAction>): void;
     type: string;
-    to: string | TActor | ((args: UnifiedArg<TContext, TExpressionEvent>) => TActor | string);
-    event: ((TActor extends import("../types.js").AnyFunction ? ReturnType<TActor> : TActor) extends infer R ? R extends import("../StateMachine.js").StateMachine<infer _ extends MachineContext, infer TEvent_1 extends EventObject, infer __ extends import("../types.js").ParameterizedObject, infer ___ extends import("../types.js").ProvidedActor, infer ____, infer _____> ? TEvent_1 : R extends import("../State.js").State<infer _TContext extends MachineContext, infer TEvent_2 extends EventObject, infer _TAction extends import("../types.js").ProvidedActor, infer _TActor> ? TEvent_2 : R extends ActorRef<infer TEvent_3 extends EventObject, infer __1> ? TEvent_3 : never : never) | SendExpr<TContext, TExpressionEvent, InferEvent<Cast<(TActor extends import("../types.js").AnyFunction ? ReturnType<TActor> : TActor) extends infer R ? R extends import("../StateMachine.js").StateMachine<infer _ extends MachineContext, infer TEvent_1 extends EventObject, infer __ extends import("../types.js").ParameterizedObject, infer ___ extends import("../types.js").ProvidedActor, infer ____, infer _____> ? TEvent_1 : R extends import("../State.js").State<infer _TContext extends MachineContext, infer TEvent_2 extends EventObject, infer _TAction extends import("../types.js").ProvidedActor, infer _TActor> ? TEvent_2 : R extends ActorRef<infer TEvent_3 extends EventObject, infer __1> ? TEvent_3 : never : never, EventObject>>>;
+    to: string | TActor | ((args: ActionArgs<TContext, TExpressionEvent, TExpressionAction>) => TActor | string);
+    event: ((TActor extends import("../types.js").AnyFunction ? ReturnType<TActor> : TActor) extends infer R ? R extends import("../StateMachine.js").StateMachine<infer _TContext extends MachineContext, infer TEvent extends EventObject, infer _TAction extends ParameterizedObject, infer _TActor extends import("../types.js").ProvidedActor, infer _TInput, infer _TOutput, infer _TResolvedTypesMeta> ? TEvent : R extends import("../State.js").State<infer _TContext_1 extends MachineContext, infer TEvent_1 extends EventObject, infer _TActor_1 extends import("../types.js").ProvidedActor, infer _TOutput_1, infer _TResolvedTypesMeta_1> ? TEvent_1 : R extends ActorRef<infer TEvent_2 extends EventObject, infer _> ? TEvent_2 : never : never) | SendExpr<TContext, TExpressionEvent, TExpressionAction, InferEvent<Cast<(TActor extends import("../types.js").AnyFunction ? ReturnType<TActor> : TActor) extends infer R ? R extends import("../StateMachine.js").StateMachine<infer _TContext extends MachineContext, infer TEvent extends EventObject, infer _TAction extends ParameterizedObject, infer _TActor extends import("../types.js").ProvidedActor, infer _TInput, infer _TOutput, infer _TResolvedTypesMeta> ? TEvent : R extends import("../State.js").State<infer _TContext_1 extends MachineContext, infer TEvent_1 extends EventObject, infer _TActor_1 extends import("../types.js").ProvidedActor, infer _TOutput_1, infer _TResolvedTypesMeta_1> ? TEvent_1 : R extends ActorRef<infer TEvent_2 extends EventObject, infer _> ? TEvent_2 : never : never, EventObject>>>;
     id: string | undefined;
-    delay: string | number | DelayExpr<TContext, TExpressionEvent> | undefined;
+    delay: string | number | DelayExpr<TContext, TExpressionEvent, TExpressionAction> | undefined;
     resolve: typeof resolve;
     execute: typeof execute;
 };
@@ -41,30 +41,30 @@ export declare function sendTo<TContext extends MachineContext, TExpressionEvent
  * @param event The event to send to the parent machine.
  * @param options Options to pass into the send event.
  */
-export declare function sendParent<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject, TSentEvent extends EventObject = AnyEventObject>(event: TSentEvent | SendExpr<TContext, TExpressionEvent, TSentEvent>, options?: SendToActionOptions<TContext, TExpressionEvent>): {
-    (_: ActionArgs<TContext, TExpressionEvent, import("../types.js").ParameterizedObject>): void;
+export declare function sendParent<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionAction extends ParameterizedObject | undefined, TSentEvent extends EventObject = AnyEventObject>(event: TSentEvent | SendExpr<TContext, TExpressionEvent, TExpressionAction, TSentEvent>, options?: SendToActionOptions<TContext, TExpressionEvent, TExpressionAction>): {
+    (_: ActionArgs<TContext, TExpressionEvent, TSentEvent>): void;
     type: string;
-    to: string | AnyActorRef | ((args: UnifiedArg<TContext, TExpressionEvent>) => string | AnyActorRef);
+    to: string | AnyActorRef | ((args: ActionArgs<TContext, TExpressionEvent, TSentEvent>) => string | AnyActorRef);
     event: any;
     id: string | undefined;
-    delay: string | number | DelayExpr<TContext, TExpressionEvent> | undefined;
+    delay: string | number | DelayExpr<TContext, TExpressionEvent, TSentEvent> | undefined;
     resolve: typeof resolve;
     execute: typeof execute;
 };
-type Target<TContext extends MachineContext, TEvent extends EventObject> = string | ActorRef<any, any> | ((args: UnifiedArg<TContext, TEvent>) => string | ActorRef<any, any>);
+type Target<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionAction extends ParameterizedObject | undefined> = string | ActorRef<any, any> | ((args: ActionArgs<TContext, TExpressionEvent, TExpressionAction>) => string | ActorRef<any, any>);
 /**
  * Forwards (sends) an event to a specified service.
  *
  * @param target The target service to forward the event to.
  * @param options Options to pass into the send action creator.
  */
-export declare function forwardTo<TContext extends MachineContext, TExpressionEvent extends EventObject>(target: Target<TContext, TExpressionEvent>, options?: SendToActionOptions<TContext, TExpressionEvent>): {
-    (_: ActionArgs<TContext, TExpressionEvent, import("../types.js").ParameterizedObject>): void;
+export declare function forwardTo<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionAction extends ParameterizedObject | undefined>(target: Target<TContext, TExpressionEvent, TExpressionAction>, options?: SendToActionOptions<TContext, TExpressionEvent, TExpressionAction>): {
+    (_: ActionArgs<TContext, TExpressionEvent, TExpressionAction>): void;
     type: string;
-    to: string | AnyActorRef | ((args: UnifiedArg<TContext, TExpressionEvent>) => string | AnyActorRef);
+    to: string | AnyActorRef | ((args: ActionArgs<TContext, TExpressionEvent, TExpressionAction>) => string | AnyActorRef);
     event: any;
     id: string | undefined;
-    delay: string | number | DelayExpr<TContext, TExpressionEvent> | undefined;
+    delay: string | number | DelayExpr<TContext, TExpressionEvent, TExpressionAction> | undefined;
     resolve: typeof resolve;
     execute: typeof execute;
 };
@@ -75,13 +75,13 @@ export declare function forwardTo<TContext extends MachineContext, TExpressionEv
  * takes in the `context`, `event`, and `meta`, and returns the error data to send.
  * @param options Options to pass into the send action creator.
  */
-export declare function escalate<TContext extends MachineContext, TExpressionEvent extends EventObject, TErrorData = any>(errorData: TErrorData | ((args: UnifiedArg<TContext, TExpressionEvent>) => TErrorData), options?: SendToActionParams<TContext, TExpressionEvent>): {
-    (_: ActionArgs<TContext, TExpressionEvent, import("../types.js").ParameterizedObject>): void;
+export declare function escalate<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionAction extends ParameterizedObject | undefined, TErrorData = any>(errorData: TErrorData | ((args: UnifiedArg<TContext, TExpressionEvent>) => TErrorData), options?: SendToActionParams<TContext, TExpressionEvent, TExpressionAction, EventObject>): {
+    (_: ActionArgs<TContext, TExpressionEvent, EventObject>): void;
     type: string;
-    to: string | AnyActorRef | ((args: UnifiedArg<TContext, TExpressionEvent>) => string | AnyActorRef);
+    to: string | AnyActorRef | ((args: ActionArgs<TContext, TExpressionEvent, EventObject>) => string | AnyActorRef);
     event: any;
     id: string | undefined;
-    delay: string | number | DelayExpr<TContext, TExpressionEvent> | undefined;
+    delay: string | number | DelayExpr<TContext, TExpressionEvent, EventObject> | undefined;
     resolve: typeof resolve;
     execute: typeof execute;
 };

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

@@ -1,7 +1,7 @@
-import { ActionArgs, ActorRef, AnyActorContext, AnyState, EventObject, MachineContext, UnifiedArg } from "../types.js";
-type ResolvableActorRef<TContext extends MachineContext, TExpressionEvent extends EventObject> = string | ActorRef<any> | ((args: UnifiedArg<TContext, TExpressionEvent>) => ActorRef<any> | string);
-declare function resolve(_: AnyActorContext, state: AnyState, args: ActionArgs<any, any>, { actorRef }: {
-    actorRef: ResolvableActorRef<any, any>;
+import { ActionArgs, ActorRef, AnyActorContext, AnyState, EventObject, MachineContext, ParameterizedObject } from "../types.js";
+type ResolvableActorRef<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionAction extends ParameterizedObject | undefined> = string | ActorRef<any> | ((args: ActionArgs<TContext, TExpressionEvent, TExpressionAction>) => ActorRef<any> | string);
+declare function resolve(_: AnyActorContext, state: AnyState, args: ActionArgs<any, any, any>, { actorRef }: {
+    actorRef: ResolvableActorRef<any, any, any>;
 }): (AnyState | ActorRef<any, any>)[];
 declare function execute(actorContext: AnyActorContext, actorRef: ActorRef<any, any> | undefined): void;
 /**
@@ -9,10 +9,10 @@ declare function execute(actorContext: AnyActorContext, actorRef: ActorRef<any,
  *
  * @param actorRef The actor to stop.
  */
-export declare function stop<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject>(actorRef: ResolvableActorRef<TContext, TExpressionEvent>): {
-    (_: ActionArgs<TContext, TExpressionEvent>): void;
+export declare function stop<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionAction extends ParameterizedObject | undefined>(actorRef: ResolvableActorRef<TContext, TExpressionEvent, TExpressionAction>): {
+    (_: ActionArgs<TContext, TExpressionEvent, TExpressionAction>): void;
     type: string;
-    actorRef: ResolvableActorRef<TContext, TExpressionEvent>;
+    actorRef: ResolvableActorRef<TContext, TExpressionEvent, TExpressionAction>;
     resolve: typeof resolve;
     execute: typeof execute;
 };

package/dist/declarations/src/dev/index.d.ts

@@ -1,14 +1,14 @@
-import { AnyInterpreter, DevToolsAdapter } from "../types.js";
-type ServiceListener = (service: AnyInterpreter) => void;
+import { AnyActor, DevToolsAdapter } from "../types.js";
+type ServiceListener = (service: AnyActor) => void;
 export interface XStateDevInterface {
-    register: (service: AnyInterpreter) => void;
-    unregister: (service: AnyInterpreter) => void;
+    register: (service: AnyActor) => void;
+    unregister: (service: AnyActor) => void;
     onRegister: (listener: ServiceListener) => {
         unsubscribe: () => void;
     };
-    services: Set<AnyInterpreter>;
+    services: Set<AnyActor>;
 }
 export declare function getGlobal(): typeof globalThis | undefined;
-export declare function registerService(service: AnyInterpreter): void;
+export declare function registerService(service: AnyActor): void;
 export declare const devToolsAdapter: DevToolsAdapter;
 export {};

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

@@ -6,7 +6,7 @@ export { log } from "./actions/log.js";
 export { pure } from "./actions/pure.js";
 export { raise } from "./actions/raise.js";
 export { stop } from "./actions/stop.js";
-import { interpret, Interpreter, ActorStatus } from "./interpreter.js";
+import { createActor, interpret, Actor, ActorStatus, InterpreterStatus, Interpreter } from "./interpreter.js";
 import { createMachine } from "./Machine.js";
 import { mapState } from "./mapState.js";
 import { State } from "./State.js";
@@ -18,7 +18,8 @@ export { waitFor } from "./waitFor.js";
 export * from "./typegenTypes.js";
 export * from "./types.js";
 export { matchesState, pathToStateValue, toObserver } from "./utils.js";
-export { StateNode, State, mapState, sendTo, sendParent, forwardTo, interpret, Interpreter, ActorStatus as InterpreterStatus, doneInvoke, createMachine };
+export { StateNode, State, mapState, sendTo, sendParent, forwardTo, createActor, interpret, // deprecated
+Actor, type Interpreter, ActorStatus, InterpreterStatus, doneInvoke, createMachine };
 export { fromPromise, fromObservable, fromCallback, fromEventObservable, fromTransition } from "./actors/index.js";
 export { stateIn, not, and, or } from "./guards.js";
 declare global {

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

@@ -1,7 +1,7 @@
 import { symbolObservable } from "./symbolObservable.js";
 import { AreAllImplementationsAssumedToBeProvided, MissingImplementationsError } from "./typegenTypes.js";
-import type { ActorSystem, AnyActorLogic, AnyStateMachine, EventFromLogic, InterpreterFrom, PersistedStateFrom, SnapshotFrom, AnyActorRef } from "./types.js";
-import { ActorRef, EventObject, InteropSubscribable, InterpreterOptions, Observer, Subscription } from "./types.js";
+import type { ActorSystem, AnyActorLogic, AnyStateMachine, EventFromLogic, PersistedStateFrom, SnapshotFrom, AnyActorRef } from "./types.js";
+import { ActorRef, EventObject, InteropSubscribable, ActorOptions, Observer, Subscription } from "./types.js";
 export type SnapshotListener<TLogic extends AnyActorLogic> = (state: SnapshotFrom<TLogic>) => void;
 export type EventListener<TEvent extends EventObject = EventObject> = (event: TEvent) => void;
 export type Listener = () => void;
@@ -15,17 +15,21 @@ export declare enum ActorStatus {
     Running = 1,
     Stopped = 2
 }
-export declare class Interpreter<TLogic extends AnyActorLogic, TEvent extends EventObject = EventFromLogic<TLogic>> implements ActorRef<TEvent, SnapshotFrom<TLogic>> {
+/**
+ * @deprecated Use `ActorStatus` instead.
+ */
+export declare const InterpreterStatus: typeof ActorStatus;
+export declare class Actor<TLogic extends AnyActorLogic, TEvent extends EventObject = EventFromLogic<TLogic>> implements ActorRef<TEvent, SnapshotFrom<TLogic>> {
     logic: TLogic;
     /**
-     * The current state of the interpreted logic.
+     * The current internal state of the actor.
      */
     private _state;
     /**
      * The clock that is responsible for setting and clearing timeouts, such as delayed events and transitions.
      */
     clock: Clock;
-    options: Readonly<InterpreterOptions<TLogic>>;
+    options: Readonly<ActorOptions<TLogic>>;
     /**
      * The unique identifier for this actor relative to its parent.
      */
@@ -50,32 +54,32 @@ export declare class Interpreter<TLogic extends AnyActorLogic, TEvent extends Ev
     private _doneEvent?;
     src?: string;
     /**
-     * Creates a new Interpreter instance (i.e., service) for the given logic with the provided options, if any.
+     * Creates a new actor instance for the given logic with the provided options, if any.
      *
-     * @param logic The logic to be interpreted
-     * @param options Interpreter options
+     * @param logic The logic to create an actor from
+     * @param options Actor options
      */
-    constructor(logic: TLogic, options?: InterpreterOptions<TLogic>);
+    constructor(logic: TLogic, options?: ActorOptions<TLogic>);
     private _initState;
     private _deferred;
     private update;
     subscribe(observer: Observer<SnapshotFrom<TLogic>>): Subscription;
     subscribe(nextListener?: (state: SnapshotFrom<TLogic>) => void, errorListener?: (error: any) => void, completeListener?: () => void): Subscription;
     /**
-     * Starts the interpreter from the initial state
+     * Starts the Actor from the initial state
      */
     start(): this;
     private _process;
     private _stop;
     /**
-     * Stops the interpreter and unsubscribe all listeners.
+     * Stops the Actor and unsubscribe all listeners.
      */
     stop(): this;
     private _complete;
     private _error;
     private _stopProcedure;
     /**
-     * Sends an event to the running interpreter to trigger a transition.
+     * Sends an event to the running Actor to trigger a transition.
      *
      * @param event The event to send
      */
@@ -92,14 +96,24 @@ export declare class Interpreter<TLogic extends AnyActorLogic, TEvent extends Ev
         id: string;
     };
     getPersistedState(): PersistedStateFrom<TLogic> | undefined;
-    [Symbol.observable](): InteropSubscribable<SnapshotFrom<TLogic>>;
+    [symbolObservable](): InteropSubscribable<SnapshotFrom<TLogic>>;
     getSnapshot(): SnapshotFrom<TLogic>;
 }
+/**
+ * Creates a new `ActorRef` instance for the given machine with the provided options, if any.
+ *
+ * @param machine The machine to create an actor from
+ * @param options `ActorRef` options
+ */
+export declare function createActor<TMachine extends AnyStateMachine>(machine: AreAllImplementationsAssumedToBeProvided<TMachine['__TResolvedTypesMeta']> extends true ? TMachine : MissingImplementationsError<TMachine['__TResolvedTypesMeta']>, options?: ActorOptions<TMachine>): Actor<TMachine>;
+export declare function createActor<TLogic extends AnyActorLogic>(logic: TLogic, options?: ActorOptions<TLogic>): Actor<TLogic>;
 /**
  * Creates a new Interpreter instance for the given machine with the provided options, if any.
  *
- * @param machine The machine to interpret
- * @param options Interpreter options
+ * @deprecated Use `createActor` instead
+ */
+export declare const interpret: typeof createActor;
+/**
+ * @deprecated Use `Actor` instead.
  */
-export declare function interpret<TMachine extends AnyStateMachine>(machine: AreAllImplementationsAssumedToBeProvided<TMachine['__TResolvedTypesMeta']> extends true ? TMachine : MissingImplementationsError<TMachine['__TResolvedTypesMeta']>, options?: InterpreterOptions<TMachine>): InterpreterFrom<TMachine>;
-export declare function interpret<TLogic extends AnyActorLogic>(logic: TLogic, options?: InterpreterOptions<TLogic>): Interpreter<TLogic>;
+export type Interpreter = typeof Actor;

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

@@ -1,6 +1,6 @@
 import { State } from "./State.js";
 import type { StateNode } from "./StateNode.js";
-import { Action, AnyActorContext, AnyHistoryValue, AnyState, AnyStateNode, AnyTransitionDefinition, DelayedTransitionDefinition, EventObject, InitialTransitionConfig, InitialTransitionDefinition, MachineContext, SingleOrArray, StateValue, StateValueMap, TransitionConfig, TransitionDefinition, TODO } from "./types.js";
+import { AnyActorContext, AnyHistoryValue, AnyState, AnyStateNode, AnyTransitionDefinition, DelayedTransitionDefinition, EventObject, InitialTransitionConfig, InitialTransitionDefinition, MachineContext, SingleOrArray, StateValue, StateValueMap, TransitionConfig, TransitionDefinition, TODO, UnknownAction } from "./types.js";
 type Configuration<TContext extends MachineContext, TE extends EventObject> = Iterable<StateNode<TContext, TE>>;
 type AnyConfiguration = Configuration<any, any>;
 type AdjList = Map<AnyStateNode, Array<AnyStateNode>>;
@@ -14,11 +14,11 @@ export declare function getCandidates<TEvent extends EventObject>(stateNode: Sta
 /**
  * All delayed transitions from the config.
  */
-export declare function getDelayedTransitions<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode): Array<DelayedTransitionDefinition<TContext, TEvent>>;
-export declare function formatTransition<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, descriptor: string, transitionConfig: TransitionConfig<TContext, TEvent>): AnyTransitionDefinition;
+export declare function getDelayedTransitions(stateNode: AnyStateNode): Array<DelayedTransitionDefinition<MachineContext, EventObject>>;
+export declare function formatTransition<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, descriptor: string, transitionConfig: TransitionConfig<TContext, TEvent, TEvent, any>): AnyTransitionDefinition;
 export declare function formatTransitions<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode): Map<string, TransitionDefinition<TContext, TEvent>[]>;
-export declare function formatInitialTransition<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, _target: SingleOrArray<string> | InitialTransitionConfig<TContext, TEvent>): InitialTransitionDefinition<TContext, TEvent>;
-export declare function resolveTarget(stateNode: AnyStateNode, targets: Array<string | AnyStateNode> | undefined): Array<AnyStateNode> | undefined;
+export declare function formatInitialTransition<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, _target: SingleOrArray<string> | InitialTransitionConfig<TContext, TEvent, TODO>): InitialTransitionDefinition<TContext, TEvent>;
+export declare function resolveTarget(stateNode: AnyStateNode, targets: ReadonlyArray<string | AnyStateNode> | undefined): ReadonlyArray<AnyStateNode> | undefined;
 export declare function getInitialStateNodes(stateNode: AnyStateNode): Array<AnyStateNode>;
 /**
  * Returns the child state node from its relative `stateKey`, or throws.
@@ -35,11 +35,11 @@ export declare function getStateNodeByPath(stateNode: AnyStateNode, statePath: s
  *
  * @param state The state value or State instance
  */
-export declare function getStateNodes<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, state: StateValue | State<TContext, TEvent, TODO>): Array<AnyStateNode>;
-export declare function transitionAtomicNode<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, stateValue: string, state: State<TContext, TEvent, TODO>, event: TEvent): Array<TransitionDefinition<TContext, TEvent>> | undefined;
-export declare function transitionCompoundNode<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, stateValue: StateValueMap, state: State<TContext, TEvent, TODO>, event: TEvent): Array<TransitionDefinition<TContext, TEvent>> | undefined;
-export declare function transitionParallelNode<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, stateValue: StateValueMap, state: State<TContext, TEvent, TODO>, event: TEvent): Array<TransitionDefinition<TContext, TEvent>> | undefined;
-export declare function transitionNode<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, stateValue: StateValue, state: State<TContext, TEvent, TODO, any>, event: TEvent): Array<TransitionDefinition<TContext, TEvent>> | undefined;
+export declare function getStateNodes<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, state: StateValue | State<TContext, TEvent, TODO, TODO>): Array<AnyStateNode>;
+export declare function transitionAtomicNode<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, stateValue: string, state: State<TContext, TEvent, TODO, TODO>, event: TEvent): Array<TransitionDefinition<TContext, TEvent>> | undefined;
+export declare function transitionCompoundNode<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, stateValue: StateValueMap, state: State<TContext, TEvent, TODO, TODO>, event: TEvent): Array<TransitionDefinition<TContext, TEvent>> | undefined;
+export declare function transitionParallelNode<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, stateValue: StateValueMap, state: State<TContext, TEvent, TODO, TODO>, event: TEvent): Array<TransitionDefinition<TContext, TEvent>> | undefined;
+export declare function transitionNode<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, stateValue: StateValue, state: State<TContext, TEvent, TODO, TODO, TODO>, event: TEvent): Array<TransitionDefinition<TContext, TEvent>> | undefined;
 export declare function removeConflictingTransitions(enabledTransitions: Array<AnyTransitionDefinition>, configuration: Set<AnyStateNode>, historyValue: AnyHistoryValue): Array<AnyTransitionDefinition>;
 /**
  * https://www.w3.org/TR/scxml/#microstepProcedure
@@ -49,8 +49,8 @@ export declare function removeConflictingTransitions(enabledTransitions: Array<A
  * @param currentState
  * @param mutConfiguration
  */
-export declare function microstep<TContext extends MachineContext, TEvent extends EventObject>(transitions: Array<TransitionDefinition<TContext, TEvent>>, currentState: State<TContext, TEvent, TODO, any>, actorCtx: AnyActorContext, event: TEvent, isInitial: boolean): State<TContext, TEvent, TODO, any>;
-export declare function resolveActionsAndContext<TContext extends MachineContext, TEvent extends EventObject>(actions: Action<any, any, any>[], event: TEvent, currentState: State<TContext, TEvent, TODO, any>, actorCtx: AnyActorContext): AnyState;
+export declare function microstep<TContext extends MachineContext, TEvent extends EventObject>(transitions: Array<TransitionDefinition<TContext, TEvent>>, currentState: AnyState, actorCtx: AnyActorContext, event: TEvent, isInitial: boolean): AnyState;
+export declare function resolveActionsAndContext<TContext extends MachineContext, TEvent extends EventObject>(actions: UnknownAction[], event: TEvent, currentState: AnyState, actorCtx: AnyActorContext): AnyState;
 export declare function macrostep(state: AnyState, event: EventObject, actorCtx: AnyActorContext): {
     state: typeof state;
     microstates: Array<typeof state>;

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

@@ -119,7 +119,7 @@ export interface ResolveTypegenMeta<TTypesMeta extends TypegenConstraint, TEvent
     '@@xstate/typegen': TTypesMeta['@@xstate/typegen'];
     resolved: {
         enabled: TTypesMeta & {
-            indexedActions: IndexByType<TAction>;
+            indexedActions: string extends TAction['type'] ? IsNever<Prop<TTypesMeta, 'eventsCausingActions'>> extends true ? never : Record<keyof Prop<TTypesMeta, 'eventsCausingActions'>, ParameterizedObject> : IndexByType<TAction>;
             indexedActors: string extends TActor['src'] ? Record<keyof Prop<TTypesMeta, 'eventsCausingActors'>, {
                 logic: AnyActorLogic;
             }> : IndexByProp<TActor, 'src'>;