xstate 5.0.0-alpha.5 → 5.0.0-beta.10

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

@@ -1,6 +1,6 @@
 import type { StateNode } from './StateNode.ts';
 import { TypegenDisabled, TypegenEnabled } from './typegenTypes.ts';
-import type { ActorRef, AnyState, AnyStateMachine, BaseActionObject, EventObject, HistoryValue, MachineContext, PersistedMachineState, Prop, SCXML, StateConfig, StateValue, TransitionDefinition } from './types.ts';
+import type { ActorRef, AnyState, AnyStateMachine, BaseActionObject, EventObject, HistoryValue, MachineContext, PersistedMachineState, Prop, StateConfig, StateValue, TransitionDefinition } from './types.ts';
 export declare function isStateConfig<TContext extends MachineContext, TEvent extends EventObject>(state: any): state is StateConfig<TContext, TEvent>;
 /**
  * @deprecated Use `isStateConfig(object)` or `state instanceof State` instead.
@@ -22,8 +22,7 @@ export declare class State<TContext extends MachineContext, TEvent extends Event
     historyValue: Readonly<HistoryValue<TContext, TEvent>>;
     actions: BaseActionObject[];
     event: TEvent;
-    _internalQueue: Array<SCXML.Event<TEvent>>;
-    _event: SCXML.Event<TEvent>;
+    _internalQueue: Array<TEvent>;
     _initial: boolean;
     /**
      * Indicates whether the state has changed from the previous state. A state is considered "changed" if:

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

@@ -1,11 +1,11 @@
 import { State } from './State.ts';
 import { StateNode } from './StateNode.ts';
 import type { AreAllImplementationsAssumedToBeProvided, MarkAllImplementationsAsProvided, ResolveTypegenMeta, TypegenDisabled } from './typegenTypes.ts';
-import type { ActorContext, ActorMap, ActorBehavior, EventObject, InternalMachineImplementations, MachineConfig, MachineContext, MachineImplementationsSimplified, MachineSchema, NoInfer, SCXML, StateConfig, StateMachineDefinition, StateValue, TransitionDefinition, PersistedMachineState, ParameterizedObject, AnyActorContext } from './types.ts';
+import type { ActorContext, ActorMap, ActorBehavior, EventObject, InternalMachineImplementations, MachineConfig, MachineContext, MachineImplementationsSimplified, MachineTypes, NoInfer, StateConfig, StateMachineDefinition, StateValue, TransitionDefinition, PersistedMachineState, ParameterizedObject, AnyActorContext } from './types.ts';
 export declare const NULL_EVENT = "";
 export declare const STATE_IDENTIFIER = "#";
 export declare const WILDCARD = "*";
-export declare class StateMachine<TContext extends MachineContext, TEvent extends EventObject = EventObject, TAction extends ParameterizedObject = ParameterizedObject, TActorMap extends ActorMap = ActorMap, TResolvedTypesMeta = ResolveTypegenMeta<TypegenDisabled, NoInfer<TEvent>, TAction, TActorMap>> implements ActorBehavior<TEvent | SCXML.Event<TEvent>, State<TContext, TEvent, TResolvedTypesMeta>, State<TContext, TEvent, TResolvedTypesMeta>, PersistedMachineState<State<TContext, TEvent, TResolvedTypesMeta>>> {
+export declare class StateMachine<TContext extends MachineContext, TEvent extends EventObject = EventObject, TAction extends ParameterizedObject = ParameterizedObject, TActorMap extends ActorMap = ActorMap, TResolvedTypesMeta = ResolveTypegenMeta<TypegenDisabled, NoInfer<TEvent>, TAction, TActorMap>> implements ActorBehavior<TEvent, State<TContext, TEvent, TResolvedTypesMeta>, State<TContext, TEvent, TResolvedTypesMeta>, PersistedMachineState<State<TContext, TEvent, TResolvedTypesMeta>>> {
     /**
      * The raw config used to create the machine.
      */
@@ -21,7 +21,7 @@ export declare class StateMachine<TContext extends MachineContext, TEvent extend
      */
     delimiter: string;
     options: MachineImplementationsSimplified<TContext, TEvent>;
-    schema: MachineSchema<TContext, TEvent>;
+    types: MachineTypes<TContext, TEvent>;
     __xstatenode: true;
     idMap: Map<string, StateNode<TContext, TEvent>>;
     root: StateNode<TContext, TEvent>;
@@ -59,7 +59,7 @@ export declare class StateMachine<TContext extends MachineContext, TEvent extend
      * @param state The current State instance or state value
      * @param event The received event
      */
-    transition(state: StateValue | State<TContext, TEvent, TResolvedTypesMeta> | undefined, event: TEvent | SCXML.Event<TEvent>, actorCtx?: ActorContext<TEvent, State<TContext, TEvent, any>>): State<TContext, TEvent, TResolvedTypesMeta>;
+    transition(state: StateValue | State<TContext, TEvent, TResolvedTypesMeta> | undefined, event: TEvent, actorCtx?: ActorContext<TEvent, State<TContext, TEvent, any>>): State<TContext, TEvent, TResolvedTypesMeta>;
     /**
      * Determines the next state given the current `state` and `event`.
      * Calculates a microstep.
@@ -67,8 +67,8 @@ export declare class StateMachine<TContext extends MachineContext, TEvent extend
      * @param state The current state
      * @param event The received event
      */
-    microstep(state: State<TContext, TEvent, TResolvedTypesMeta> | undefined, event: TEvent | SCXML.Event<TEvent>, actorCtx?: AnyActorContext | undefined): Array<State<TContext, TEvent, TResolvedTypesMeta>>;
-    getTransitionData(state: State<TContext, TEvent, TResolvedTypesMeta>, _event: SCXML.Event<TEvent>): Array<TransitionDefinition<TContext, TEvent>>;
+    microstep(state: State<TContext, TEvent, TResolvedTypesMeta> | undefined, event: TEvent, actorCtx?: AnyActorContext | undefined): Array<State<TContext, TEvent, TResolvedTypesMeta>>;
+    getTransitionData(state: State<TContext, TEvent, TResolvedTypesMeta>, 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.

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

@@ -1,4 +1,4 @@
-import type { EventObject, StateNodeDefinition, TransitionDefinition, DelayedTransitionDefinition, StateNodeConfig, StateNodesConfig, InvokeDefinition, Mapper, PropertyMapper, SCXML, TransitionDefinitionMap, InitialTransitionDefinition, MachineContext, BaseActionObject } from './types.ts';
+import type { EventObject, StateNodeDefinition, TransitionDefinition, DelayedTransitionDefinition, StateNodeConfig, StateNodesConfig, InvokeDefinition, Mapper, PropertyMapper, TransitionDefinitionMap, InitialTransitionDefinition, MachineContext, BaseActionObject } from './types.ts';
 import type { State } from './State.ts';
 import type { StateMachine } from './StateMachine.ts';
 interface StateNodeOptions<TContext extends MachineContext, TEvent extends EventObject> {
@@ -65,11 +65,11 @@ export declare class StateNode<TContext extends MachineContext = MachineContext,
      */
     meta?: any;
     /**
-     * The data sent with the "done.state._id_" event if this is a final state node.
+     * The output data sent with the "done.state._id_" event if this is a final state node.
      */
-    doneData?: Mapper<TContext, TEvent, any> | PropertyMapper<TContext, TEvent, any>;
+    output?: Mapper<TContext, TEvent, any> | PropertyMapper<TContext, TEvent, any>;
     /**
-     * The order this state node appears. Corresponds to the implicit SCXML document order.
+     * The order this state node appears. Corresponds to the implicit document order.
      */
     order: number;
     description?: string;
@@ -97,13 +97,7 @@ export declare class StateNode<TContext extends MachineContext = MachineContext,
     get on(): TransitionDefinitionMap<TContext, TEvent>;
     get after(): Array<DelayedTransitionDefinition<TContext, TEvent>>;
     get initial(): InitialTransitionDefinition<TContext, TEvent>;
-    /**
-     * Returns `true` if this state node explicitly handles the given event.
-     *
-     * @param event The event in question
-     */
-    handles(event: TEvent): boolean;
-    next(state: State<TContext, TEvent>, _event: SCXML.Event<TEvent>): TransitionDefinition<TContext, TEvent>[] | undefined;
+    next(state: State<TContext, TEvent>, event: TEvent): TransitionDefinition<TContext, TEvent>[] | undefined;
     /**
      * The target state value of the history state node, if it exists. This represents the
      * default state value to transition to if no history value exists yet.

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

@@ -20,13 +20,6 @@ export declare function send<TContext extends MachineContext, TEvent extends Eve
  * @param options Options to pass into the send event.
  */
 export declare function sendParent<TContext extends MachineContext, TEvent extends EventObject, TSentEvent extends EventObject = AnyEventObject>(event: TSentEvent | SendExpr<TContext, TEvent, TSentEvent>, options?: SendActionOptions<TContext, TEvent>): BaseDynamicActionObject<TContext, TEvent, TEvent, SendActionObject<AnyEventObject>, SendActionParams<TContext, TEvent, EventObject>>;
-/**
- * Sends an event back to the sender of the original event.
- *
- * @param event The event to send back to the sender
- * @param options Options to pass into the send event
- */
-export declare function respond<TContext extends MachineContext, TEvent extends EventObject, TSentEvent extends EventObject = AnyEventObject>(event: TEvent | SendExpr<TContext, TEvent, TSentEvent>, options?: SendActionOptions<TContext, TEvent>): BaseDynamicActionObject<TContext, TEvent, TEvent, SendActionObject<AnyEventObject>, SendActionParams<TContext, TEvent, EventObject>>;
 /**
  * Forwards (sends) an event to a specified service.
  *

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

@@ -1,16 +1,17 @@
-import { Action, EventObject, SingleOrArray, ActionFunction, ActionFunctionMap, ActionTypes, DoneEvent, ErrorPlatformEvent, DoneEventObject, MachineContext, BaseActionObject, SCXML } from './types.ts';
+import { Action, EventObject, SingleOrArray, ActionFunction, ActionFunctionMap, ActionTypes, DoneEvent, ErrorPlatformEvent, DoneEventObject, MachineContext, BaseActionObject } from './types.ts';
 import * as actionTypes from './actionTypes.ts';
-export { send, sendTo, sendParent, respond, forwardTo, escalate } from './actions/send.ts';
+export { send, sendTo, sendParent, forwardTo, escalate } from './actions/send.ts';
 export { stop } from './actions/stop.ts';
 export { log } from './actions/log.ts';
 export { cancel } from './actions/cancel.ts';
 export { assign } from './actions/assign.ts';
 export { raise } from './actions/raise.ts';
 export { choose } from './actions/choose.ts';
+export { pure } from './actions/pure.ts';
 export { actionTypes };
-export declare const initEvent: SCXML.Event<{
+export declare const initEvent: {
     type: ActionTypes;
-}>;
+};
 export declare function resolveActionObject(actionObject: BaseActionObject, actionFunctionMap: ActionFunctionMap<any, any>): BaseActionObject;
 export declare function toActionObject<TContext extends MachineContext, TEvent extends EventObject>(action: BaseActionObject | ActionFunction<TContext, TEvent> | string): BaseActionObject;
 export declare const toActionObjects: <TContext extends MachineContext, TEvent extends EventObject>(action?: SingleOrArray<Action<TContext, TEvent>> | undefined) => BaseActionObject[];
@@ -27,9 +28,9 @@ export declare function after(delayRef: number | string, id?: string): string;
  * has been reached in the parent state node.
  *
  * @param id The final state node's parent state node `id`
- * @param data The data to pass into the event
+ * @param output The data to pass into the event
  */
-export declare function done(id: string, data?: any): DoneEventObject;
+export declare function done(id: string, output?: any): DoneEventObject;
 /**
  * Returns an event that represents that an invoked service has terminated.
  *
@@ -37,11 +38,11 @@ export declare function done(id: string, data?: any): DoneEventObject;
  * but not when it is canceled.
  *
  * @param invokeId The invoked service ID
- * @param data The data to pass into the event
+ * @param output The data to pass into the event
  */
-export declare function doneInvoke(invokeId: string, data?: any): DoneEvent;
+export declare function doneInvoke(invokeId: string, output?: any): DoneEvent;
 export declare function error(id: string, data?: any): ErrorPlatformEvent & string;
-export declare function createInitEvent(input: any): SCXML.Event<{
-    type: ActionTypes.Init;
-    input: any;
-}>;
+export declare function createInitEvent(input: any): {
+    readonly type: ActionTypes.Init;
+    readonly input: any;
+};

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

@@ -1,4 +1,4 @@
-import type { EventObject, ActorRef, BaseActorRef } from '../types.ts';
+import type { EventObject, ActorRef, BaseActorRef, AnyEventObject } from '../types.ts';
 export { fromTransition } from './transition.ts';
 export { fromPromise } from './promise.ts';
 export { fromObservable, fromEventObservable } from './observable.ts';
@@ -25,3 +25,4 @@ export type LifecycleSignalType = typeof startSignalType | typeof stopSignalType
 export declare function isSignal(eventType: string): eventType is LifecycleSignalType;
 export declare function isActorRef(item: any): item is ActorRef<any>;
 export declare function toActorRef<TEvent extends EventObject, TSnapshot = any, TActorRefLike extends BaseActorRef<TEvent> = BaseActorRef<TEvent>>(actorRefLike: TActorRefLike): ActorRef<TEvent, TSnapshot> & Omit<TActorRefLike, keyof ActorRef<any, any>>;
+export declare function createEmptyActor(): ActorRef<AnyEventObject, undefined>;

package/dist/declarations/src/actors/observable.d.ts

@@ -1,8 +1,7 @@
 import { Subscribable, ActorBehavior, EventObject, Subscription } from '../types';
 export interface ObservableInternalState<T> {
     subscription: Subscription | undefined;
-    canceled: boolean;
-    status: 'active' | 'done' | 'error';
+    status: 'active' | 'done' | 'error' | 'canceled';
     data: T | undefined;
     input?: any;
 }

package/dist/declarations/src/actors/promise.d.ts

@@ -1,7 +1,6 @@
 import { ActorBehavior } from '../types';
 export interface PromiseInternalState<T> {
-    status: 'active' | 'error' | 'done';
-    canceled: boolean;
+    status: 'active' | 'error' | 'done' | 'canceled';
     data: T | undefined;
     input?: any;
 }

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

@@ -1,8 +1,8 @@
-import type { EventObject, StateValue, BooleanGuardDefinition, GuardConfig, GuardDefinition, SCXML, GuardPredicate, MachineContext } from './types.ts';
+import type { EventObject, StateValue, BooleanGuardDefinition, GuardConfig, GuardDefinition, GuardPredicate, MachineContext } from './types.ts';
 import type { State } from './State.ts';
 export declare function stateIn<TContext extends MachineContext, TEvent extends EventObject>(stateValue: StateValue): GuardDefinition<TContext, TEvent>;
 export declare function not<TContext extends MachineContext, TEvent extends EventObject>(guard: GuardConfig<TContext, TEvent>): BooleanGuardDefinition<TContext, TEvent>;
 export declare function and<TContext extends MachineContext, TEvent extends EventObject>(guards: Array<GuardConfig<TContext, TEvent>>): BooleanGuardDefinition<TContext, TEvent>;
 export declare function or<TContext extends MachineContext, TEvent extends EventObject>(guards: Array<GuardConfig<TContext, TEvent>>): BooleanGuardDefinition<TContext, TEvent>;
-export declare function evaluateGuard<TContext extends MachineContext, TEvent extends EventObject>(guard: GuardDefinition<TContext, TEvent>, context: TContext, _event: SCXML.Event<TEvent>, state: State<TContext, TEvent>): boolean;
+export declare function evaluateGuard<TContext extends MachineContext, TEvent extends EventObject>(guard: GuardDefinition<TContext, TEvent>, context: TContext, event: TEvent, state: State<TContext, TEvent>): boolean;
 export declare function toGuardDefinition<TContext extends MachineContext, TEvent extends EventObject>(guardConfig: GuardConfig<TContext, TEvent>, getPredicate?: (guardType: string) => GuardPredicate<TContext, TEvent>): GuardDefinition<TContext, TEvent>;

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

@@ -1,42 +1,26 @@
-import { after, done, doneInvoke, escalate, forwardTo, respond, sendParent, sendTo } from './actions.ts';
-import { assign } from './actions/assign.ts';
-import { cancel } from './actions/cancel.ts';
-import { choose } from './actions/choose.ts';
-import { log } from './actions/log.ts';
-import { pure } from './actions/pure.ts';
-import { raise } from './actions/raise.ts';
-import { send } from './actions/send.ts';
-import { stop } from './actions/stop.ts';
+import { doneInvoke, forwardTo, sendParent, sendTo } from './actions.ts';
+export { assign } from './actions/assign.ts';
+export { cancel } from './actions/cancel.ts';
+export { choose } from './actions/choose.ts';
+export { log } from './actions/log.ts';
+export { pure } from './actions/pure.ts';
+export { raise } from './actions/raise.ts';
+export { stop } from './actions/stop.ts';
 import { interpret, Interpreter, ActorStatus } from './interpreter.ts';
 import { createMachine } from './Machine.ts';
 import { mapState } from './mapState.ts';
 import { State } from './State.ts';
 import { StateNode } from './StateNode.ts';
-export { createSchema, t } from './schema.ts';
 export { SimulatedClock } from './SimulatedClock.ts';
 export { StateMachine } from './StateMachine.ts';
 export { getStateNodes } from './stateUtils.ts';
+export { waitFor } from './waitFor.ts';
 export * from './typegenTypes.ts';
 export * from './types.ts';
-export { matchesState, pathToStateValue, toObserver, toSCXMLEvent } from './utils.ts';
-export { StateNode, State, mapState, actions, assign, send, sendTo, sendParent, forwardTo, interpret, Interpreter, ActorStatus as InterpreterStatus, doneInvoke, createMachine };
-declare const actions: {
-    raise: typeof raise;
-    send: typeof send;
-    sendParent: typeof sendParent;
-    sendTo: typeof sendTo;
-    log: typeof log;
-    cancel: typeof cancel;
-    stop: typeof stop;
-    assign: typeof assign;
-    after: typeof after;
-    done: typeof done;
-    respond: typeof respond;
-    forwardTo: typeof forwardTo;
-    escalate: typeof escalate;
-    choose: typeof choose;
-    pure: typeof pure;
-};
+export { matchesState, pathToStateValue, toObserver } from './utils.ts';
+export { StateNode, State, mapState, sendTo, sendParent, forwardTo, interpret, Interpreter, ActorStatus as InterpreterStatus, doneInvoke, createMachine };
+export { fromPromise, fromObservable, fromCallback, fromEventObservable, fromTransition } from './actors/index.ts';
+export { stateIn, not, and, or } from './guards.ts';
 declare global {
     interface SymbolConstructor {
         readonly observable: symbol;

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

@@ -1,7 +1,7 @@
 import { symbolObservable } from './symbolObservable.ts';
-import { AreAllImplementationsAssumedToBeProvided } from './typegenTypes.ts';
+import { AreAllImplementationsAssumedToBeProvided, MissingImplementationsError } from './typegenTypes.ts';
 import type { ActorSystem, AnyActorBehavior, AnyStateMachine, EventFromBehavior, InterpreterFrom, PersistedStateFrom, RaiseActionObject, SnapshotFrom } from './types.ts';
-import { ActorRef, DoneEvent, EventObject, InteropSubscribable, InterpreterOptions, Observer, SCXML, SendActionObject, Subscription } from './types.ts';
+import { ActorRef, DoneEvent, EventObject, InteropSubscribable, InterpreterOptions, Observer, SendActionObject, Subscription } from './types.ts';
 export type SnapshotListener<TBehavior extends AnyActorBehavior> = (state: SnapshotFrom<TBehavior>) => void;
 export type EventListener<TEvent extends EventObject = EventObject> = (event: TEvent) => void;
 export type Listener = () => void;
@@ -77,13 +77,14 @@ export declare class Interpreter<TBehavior extends AnyActorBehavior, TEvent exte
      */
     stop(): this;
     private _complete;
+    private _error;
     private _stopProcedure;
     /**
      * Sends an event to the running interpreter to trigger a transition.
      *
      * @param event The event to send
      */
-    send(event: TEvent | SCXML.Event<TEvent>): void;
+    send(event: TEvent): void;
     delaySend(sendAction: SendActionObject | RaiseActionObject<any, any, any>): void;
     cancel(sendId: string | number): void;
     private attachDevTools;
@@ -100,5 +101,5 @@ export declare class Interpreter<TBehavior extends AnyActorBehavior, TEvent exte
  * @param machine The machine to interpret
  * @param options Interpreter options
  */
-export declare function interpret<TMachine extends AnyStateMachine>(machine: AreAllImplementationsAssumedToBeProvided<TMachine['__TResolvedTypesMeta']> extends true ? TMachine : 'Some implementations missing', options?: InterpreterOptions<TMachine>): InterpreterFrom<TMachine>;
+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<TBehavior extends AnyActorBehavior>(behavior: TBehavior, options?: InterpreterOptions<TBehavior>): Interpreter<TBehavior>;

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

@@ -1,2 +1,2 @@
-import { InvokeActionObject, AnyStateMachine, Spawner, ActorRef, MachineContext, EventObject, SCXML } from './index.ts';
-export declare function createSpawner<TContext extends MachineContext, TEvent extends EventObject>(self: ActorRef<any, any> | undefined, machine: AnyStateMachine, context: TContext, _event: SCXML.Event<TEvent>, mutCapturedActions: InvokeActionObject[]): Spawner;
+import { InvokeActionObject, AnyStateMachine, Spawner, ActorRef, MachineContext, EventObject } from './index.ts';
+export declare function createSpawner<TContext extends MachineContext, TEvent extends EventObject>(self: ActorRef<any, any> | undefined, machine: AnyStateMachine, context: TContext, event: TEvent, mutCapturedActions: InvokeActionObject[]): Spawner;

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

@@ -1,4 +1,4 @@
-import { BaseActionObject, EventObject, StateValue, TransitionConfig, TransitionDefinition, SingleOrArray, SCXML, StateValueMap, InitialTransitionConfig, MachineContext } from './types.ts';
+import { BaseActionObject, EventObject, StateValue, TransitionConfig, TransitionDefinition, SingleOrArray, StateValueMap, InitialTransitionConfig, MachineContext } from './types.ts';
 import { State } from './State.ts';
 import { NULL_EVENT } from './constants.ts';
 import type { StateNode } from './StateNode.ts';
@@ -11,12 +11,7 @@ export declare function getAdjList<TContext extends MachineContext, TE extends E
 export declare function getStateValue(rootNode: AnyStateNode, configuration: AnyConfiguration): StateValue;
 export declare function isInFinalState(configuration: Array<AnyStateNode>, stateNode?: AnyStateNode): boolean;
 export declare const isStateId: (str: string) => boolean;
-export declare function getCandidates<TEvent extends EventObject>(stateNode: StateNode<any, TEvent>, receivedEventType: TEvent['type'], 
-/**
- * If `true`, will use SCXML event partial token matching semantics
- * without the need for the ".*" suffix
- */
-partialMatch?: boolean): Array<TransitionDefinition<any, TEvent>>;
+export declare function getCandidates<TEvent extends EventObject>(stateNode: StateNode<any, TEvent>, receivedEventType: TEvent['type']): Array<TransitionDefinition<any, TEvent>>;
 /**
  * All delayed transitions from the config.
  */
@@ -32,16 +27,22 @@ export declare function getInitialStateNodes(stateNode: AnyStateNode): Array<Any
  * Returns the child state node from its relative `stateKey`, or throws.
  */
 export declare function getStateNode(stateNode: AnyStateNode, stateKey: string): AnyStateNode;
+/**
+ * Returns the relative state node from the given `statePath`, or throws.
+ *
+ * @param statePath The string or string array relative path to the state node.
+ */
+export declare function getStateNodeByPath(stateNode: AnyStateNode, statePath: string | string[]): AnyStateNode;
 /**
  * Returns the state nodes represented by the current state value.
  *
  * @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>): Array<AnyStateNode>;
-export declare function transitionAtomicNode<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, stateValue: string, state: State<TContext, TEvent>, _event: SCXML.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>, _event: SCXML.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>, _event: SCXML.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, any>, _event: SCXML.Event<TEvent>): Array<TransitionDefinition<TContext, TEvent>> | undefined;
+export declare function transitionAtomicNode<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, stateValue: string, state: State<TContext, TEvent>, 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>, 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>, 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, any>, 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
@@ -51,11 +52,11 @@ 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, any>, actorCtx: AnyActorContext | undefined, scxmlEvent: SCXML.Event<TEvent>): State<TContext, TEvent, any>;
-export declare function resolveActionsAndContext<TContext extends MachineContext, TEvent extends EventObject>(actions: BaseActionObject[], scxmlEvent: SCXML.Event<TEvent>, currentState: State<TContext, TEvent, any>, actorCtx: AnyActorContext | undefined): {
+export declare function microstep<TContext extends MachineContext, TEvent extends EventObject>(transitions: Array<TransitionDefinition<TContext, TEvent>>, currentState: State<TContext, TEvent, any>, actorCtx: AnyActorContext | undefined, event: TEvent): State<TContext, TEvent, any>;
+export declare function resolveActionsAndContext<TContext extends MachineContext, TEvent extends EventObject>(actions: BaseActionObject[], event: TEvent, currentState: State<TContext, TEvent, any>, actorCtx: AnyActorContext | undefined): {
     nextState: AnyState;
 };
-export declare function macrostep<TMachine extends AnyStateMachine>(state: StateFromMachine<TMachine>, scxmlEvent: SCXML.Event<TMachine['__TEvent']>, actorCtx: AnyActorContext | undefined): {
+export declare function macrostep<TMachine extends AnyStateMachine>(state: StateFromMachine<TMachine>, event: TMachine['__TEvent'], actorCtx: AnyActorContext | undefined): {
     state: typeof state;
     microstates: Array<typeof state>;
 };

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

@@ -1,4 +1,4 @@
-import { EventObject, IndexByType, IsNever, Prop, Values, IsAny, ActorMap, Cast, ParameterizedObject } from './types.ts';
+import { Compute, EventObject, IndexByType, IsNever, Prop, Values, IsAny, ActorMap, Cast, ParameterizedObject } from './types.ts';
 export interface TypegenDisabled {
     '@@xstate/typegen': false;
 }
@@ -86,6 +86,12 @@ export type TypegenConstraint = TypegenEnabled | TypegenDisabled;
 export type AreAllImplementationsAssumedToBeProvided<TResolvedTypesMeta, TMissingImplementations = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'missingImplementations'>> = IsAny<TResolvedTypesMeta> extends true ? true : TResolvedTypesMeta extends TypegenEnabled ? IsNever<Values<{
     [K in keyof TMissingImplementations]: TMissingImplementations[K];
 }>> extends true ? true : false : true;
+export type MissingImplementationsError<TResolvedTypesMeta, TMissingImplementations = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'missingImplementations'>> = Compute<[
+    'Some implementations missing',
+    Values<{
+        [K in keyof TMissingImplementations]: TMissingImplementations[K];
+    }>
+]>;
 interface AllImplementationsProvided {
     missingImplementations: {
         actions: never;
@@ -121,11 +127,11 @@ export interface ResolveTypegenMeta<TTypesMeta extends TypegenConstraint, TEvent
         disabled: TypegenDisabled & AllImplementationsProvided & AllowAllEvents & {
             indexedActions: IndexByType<TAction>;
             indexedEvents: Record<string, TEvent> & {
-                __XSTATE_ALLOW_ANY_INVOKE_DATA_HACK__: {
-                    data: any;
+                __XSTATE_ALLOW_ANY_INVOKE_OUTPUT_HACK__: {
+                    output: any;
                 };
             };
-            invokeSrcNameMap: Record<string, '__XSTATE_ALLOW_ANY_INVOKE_DATA_HACK__'>;
+            invokeSrcNameMap: Record<string, '__XSTATE_ALLOW_ANY_INVOKE_OUTPUT_HACK__'>;
         };
     }[IsNever<TTypesMeta> extends true ? 'disabled' : TTypesMeta extends TypegenEnabled ? 'enabled' : 'disabled'];
 }