xstate 5.0.0-beta.15 → 5.0.0-beta.17

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

@@ -47,7 +47,7 @@ export declare class State<TContext extends MachineContext, TEvent extends Event
      * @param delimiter The character(s) that separate each subpath in the string state node path.
      */
     toStrings(stateValue?: StateValue): string[];
-    toJSON(): Omit<this, "meta" | "toJSON" | "configuration" | "tags" | "machine" | "toStrings" | "matches" | "hasTag" | "can" | "nextEvents"> & {
+    toJSON(): Omit<this, "meta" | "configuration" | "tags" | "machine" | "toStrings" | "toJSON" | "matches" | "hasTag" | "can" | "nextEvents"> & {
         tags: string[];
         meta: Record<string, any>;
     };

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

@@ -1,7 +1,7 @@
 import { State } from "./State.js";
 import { StateNode } from "./StateNode.js";
 import type { AreAllImplementationsAssumedToBeProvided, MarkAllImplementationsAsProvided, ResolveTypegenMeta, TypegenDisabled } from "./typegenTypes.js";
-import type { ActorContext, ActorLogic, ActorMap, EventObject, InternalMachineImplementations, MachineConfig, MachineContext, MachineImplementationsSimplified, MachineTypes, NoInfer, StateConfig, StateMachineDefinition, StateValue, TransitionDefinition, PersistedMachineState, ParameterizedObject, AnyActorContext } from "./types.js";
+import type { ActorContext, ActorLogic, ActorMap, EventObject, InternalMachineImplementations, MachineConfig, MachineContext, MachineImplementationsSimplified, MachineTypes, NoInfer, StateConfig, StateMachineDefinition, StateValue, TransitionDefinition, PersistedMachineState, ParameterizedObject, AnyActorContext, Equals } from "./types.js";
 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 ActorLogic<TEvent, State<TContext, TEvent, TResolvedTypesMeta>, State<TContext, TEvent, TResolvedTypesMeta>, PersistedMachineState<State<TContext, TEvent, TResolvedTypesMeta>>> {
@@ -9,8 +9,6 @@ export declare class StateMachine<TContext extends MachineContext, TEvent extend
      * The raw config used to create the machine.
      */
     config: MachineConfig<TContext, TEvent, any, any, any>;
-    getContext(input?: any): TContext;
-    private getContextAndActions;
     /**
      * The machine's own version.
      */
@@ -46,7 +44,7 @@ export declare class StateMachine<TContext extends MachineContext, TEvent extend
      * @param state The state to resolve
      */
     resolveState(state: State<TContext, TEvent, TResolvedTypesMeta>): typeof state;
-    resolveStateValue(stateValue: StateValue): State<TContext, TEvent, TResolvedTypesMeta>;
+    resolveStateValue(stateValue: StateValue, ...[context]: Equals<TContext, MachineContext> extends true ? [] : [TContext]): State<TContext, TEvent, TResolvedTypesMeta>;
     /**
      * Determines the next state given the current `state` and received `event`.
      * Calculates a full macrostep from all microsteps.

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

@@ -1,6 +1,6 @@
-import type { EventObject, StateNodeDefinition, TransitionDefinition, DelayedTransitionDefinition, StateNodeConfig, StateNodesConfig, InvokeDefinition, Mapper, PropertyMapper, TransitionDefinitionMap, InitialTransitionDefinition, MachineContext, BaseActionObject } from "./types.js";
 import type { State } from "./State.js";
 import type { StateMachine } from "./StateMachine.js";
+import type { Action, DelayedTransitionDefinition, EventObject, InitialTransitionDefinition, InvokeDefinition, MachineContext, Mapper, PropertyMapper, StateNodeConfig, StateNodeDefinition, StateNodesConfig, TransitionDefinition, TransitionDefinitionMap } from "./types.js";
 interface StateNodeOptions<TContext extends MachineContext, TEvent extends EventObject> {
     _key: string;
     _parent?: StateNode<TContext, TEvent>;
@@ -47,11 +47,11 @@ export declare class StateNode<TContext extends MachineContext = MachineContext,
     /**
      * The action(s) to be executed upon entering the state node.
      */
-    entry: BaseActionObject[];
+    entry: Action<any, any, any>[];
     /**
      * The action(s) to be executed upon exiting the state node.
      */
-    exit: BaseActionObject[];
+    exit: Action<any, any, any>[];
     /**
      * The parent state node.
      */
@@ -74,7 +74,7 @@ export declare class StateNode<TContext extends MachineContext = MachineContext,
     order: number;
     description?: string;
     tags: string[];
-    transitions: Array<TransitionDefinition<TContext, TEvent>>;
+    transitions: Map<string, TransitionDefinition<TContext, TEvent>[]>;
     always?: Array<TransitionDefinition<TContext, TEvent>>;
     constructor(
     /**

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

@@ -1,7 +1,16 @@
-import type { EventObject, Assigner, PropertyAssigner, MachineContext, DynamicAssignAction, LowInfer } from "../types.js";
+import type { ActionArgs, AnyActorContext, AnyState, Assigner, EventObject, LowInfer, MachineContext, PropertyAssigner } from "../types.js";
+declare function resolve(actorContext: AnyActorContext, state: AnyState, actionArgs: ActionArgs<any, any>, { assignment }: {
+    assignment: Assigner<any, any> | PropertyAssigner<any, any>;
+}): AnyState[];
 /**
  * Updates the current context of the machine.
  *
  * @param assignment An object that represents the partial context to update.
  */
-export declare function assign<TContext extends MachineContext, TExpressionEvent extends EventObject = EventObject, TEvent extends EventObject = TExpressionEvent>(assignment: Assigner<LowInfer<TContext>, TExpressionEvent, TEvent> | PropertyAssigner<LowInfer<TContext>, TExpressionEvent, TEvent>): DynamicAssignAction<TContext, TExpressionEvent, TEvent>;
+export declare function assign<TContext extends MachineContext, TExpressionEvent extends EventObject = EventObject, TEvent extends EventObject = TExpressionEvent>(assignment: Assigner<LowInfer<TContext>, TExpressionEvent> | PropertyAssigner<LowInfer<TContext>, TExpressionEvent>): {
+    (_: ActionArgs<TContext, TExpressionEvent>): void;
+    type: string;
+    assignment: Assigner<LowInfer<TContext>, TExpressionEvent> | PropertyAssigner<LowInfer<TContext>, TExpressionEvent>;
+    resolve: typeof resolve;
+};
+export {};

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

@@ -1,5 +1,9 @@
-import { EventObject, ExprWithMeta, MachineContext } from "../types.js";
-import { BaseDynamicActionObject, CancelActionObject, DynamicCancelActionObject } from "../index.js";
+import { AnyActorContext, AnyState, EventObject, MachineContext, ActionArgs } from "../types.js";
+type ResolvableSendId<TContext extends MachineContext, TExpressionEvent extends EventObject> = string | ((args: ActionArgs<TContext, TExpressionEvent>) => string);
+declare function resolve(_: AnyActorContext, state: AnyState, actionArgs: ActionArgs<any, any>, { sendId }: {
+    sendId: ResolvableSendId<any, any>;
+}): (string | AnyState)[];
+declare function execute(actorContext: AnyActorContext, resolvedSendId: string): void;
 /**
  * Cancels an in-flight `send(...)` action. A canceled sent action will not
  * be executed, nor will its event be sent, unless it has already been sent
@@ -7,4 +11,11 @@ import { BaseDynamicActionObject, CancelActionObject, DynamicCancelActionObject
  *
  * @param sendId The `id` of the `send(...)` action to cancel.
  */
-export declare function cancel<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject>(sendId: string | ExprWithMeta<TContext, TExpressionEvent, string>): BaseDynamicActionObject<TContext, TExpressionEvent, TEvent, CancelActionObject, DynamicCancelActionObject<TContext, TExpressionEvent>['params']>;
+export declare function cancel<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject>(sendId: ResolvableSendId<TContext, TExpressionEvent>): {
+    (_: ActionArgs<TContext, TExpressionEvent>): void;
+    type: string;
+    sendId: ResolvableSendId<TContext, TExpressionEvent>;
+    resolve: typeof resolve;
+    execute: typeof execute;
+};
+export {};

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

@@ -1,3 +1,11 @@
-import { EventObject, ChooseCondition, MachineContext } from "../types.js";
-import { BaseDynamicActionObject, ChooseAction, ResolvedChooseAction } from "../index.js";
-export declare function choose<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject>(guards: Array<ChooseCondition<TContext, TExpressionEvent>>): BaseDynamicActionObject<TContext, TExpressionEvent, TEvent, ResolvedChooseAction, ChooseAction<TContext, TExpressionEvent>['params']>;
+import { EventObject, ChooseBranch, MachineContext, AnyActorContext, AnyState, ActionArgs } from "../types.js";
+declare function resolve(_: AnyActorContext, state: AnyState, actionArgs: ActionArgs<any, any>, { branches }: {
+    branches: Array<ChooseBranch<MachineContext, EventObject>>;
+}): (AnyState | (string | import("../types.js").ParameterizedObject | import("../types.js").ActionFunction<MachineContext, EventObject, EventObject, import("../types.js").ParameterizedObject>)[] | undefined)[];
+export declare function choose<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject>(branches: Array<ChooseBranch<TContext, TExpressionEvent>>): {
+    (_: ActionArgs<TContext, TExpressionEvent>): void;
+    type: string;
+    branches: ChooseBranch<TContext, TExpressionEvent, TExpressionEvent>[];
+    resolve: typeof resolve;
+};
+export {};

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

@@ -1,5 +1,16 @@
-import { EventObject, LogExpr, MachineContext, LogActionObject } from "../types.js";
-import { BaseDynamicActionObject, DynamicLogAction } from "../index.js";
+import { ActionArgs, AnyActorContext, AnyState, EventObject, LogExpr, MachineContext } from "../types.js";
+type ResolvableLogValue<TContext extends MachineContext, TExpressionEvent extends EventObject> = string | LogExpr<TContext, TExpressionEvent>;
+declare function resolve(_: AnyActorContext, state: AnyState, actionArgs: ActionArgs<any, any>, { value, label }: {
+    value: ResolvableLogValue<any, any>;
+    label: string | undefined;
+}): (AnyState | {
+    value: unknown;
+    label: string | undefined;
+})[];
+declare function execute({ logger }: AnyActorContext, { value, label }: {
+    value: unknown;
+    label: string | undefined;
+}): void;
 /**
  *
  * @param expr The expression function to evaluate which will be logged.
@@ -8,4 +19,12 @@ import { BaseDynamicActionObject, DynamicLogAction } from "../index.js";
  *  - `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, TEvent extends EventObject = TExpressionEvent>(expr?: string | LogExpr<TContext, TExpressionEvent>, label?: string): BaseDynamicActionObject<TContext, TExpressionEvent, TEvent, LogActionObject, DynamicLogAction<TContext, TExpressionEvent, TEvent>['params']>;
+export declare function log<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject = TExpressionEvent>(value?: ResolvableLogValue<TContext, TExpressionEvent>, label?: string): {
+    (_: ActionArgs<TContext, TExpressionEvent>): void;
+    type: string;
+    value: ResolvableLogValue<TContext, TExpressionEvent>;
+    label: string | undefined;
+    resolve: typeof resolve;
+    execute: typeof execute;
+};
+export {};

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

@@ -1,6 +1,20 @@
-import { EventObject, SingleOrArray, MachineContext } from "../types.js";
-import { BaseActionObject, BaseDynamicActionObject, DynamicPureActionObject, PureActionObject } from "../index.js";
+import { Action, ActionArgs, AnyActorContext, AnyState, EventObject, MachineContext, SingleOrArray } from "../types.js";
+declare function resolve(_: AnyActorContext, state: AnyState, args: ActionArgs<any, any>, { get }: {
+    get: ({ context, event }: {
+        context: MachineContext;
+        event: EventObject;
+    }) => SingleOrArray<Action<any, any, any>> | undefined;
+}): (AnyState | (string | import("../types.js").ParameterizedObject | import("../types.js").ActionFunction<any, any, any, import("../types.js").ParameterizedObject>)[] | undefined)[];
 export declare function pure<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject = TExpressionEvent>(getActions: ({ context, event }: {
     context: TContext;
     event: TExpressionEvent;
-}) => SingleOrArray<BaseActionObject | string> | undefined): BaseDynamicActionObject<TContext, TExpressionEvent, TEvent, PureActionObject, DynamicPureActionObject<TContext, TExpressionEvent>['params']>;
+}) => SingleOrArray<Action<TContext, TExpressionEvent> | string> | undefined): {
+    (_: ActionArgs<TContext, TExpressionEvent>): void;
+    type: string;
+    get: ({ context, event }: {
+        context: TContext;
+        event: TExpressionEvent;
+    }) => SingleOrArray<Action<TContext, TExpressionEvent> | string> | undefined;
+    resolve: typeof resolve;
+};
+export {};

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

@@ -1,8 +1,11 @@
-import { EventObject, MachineContext, RaiseActionObject, BaseDynamicActionObject, RaiseActionOptions, SendExpr, RaiseActionParams, NoInfer } from "../types.js";
+import { ActionArgs, EventObject, MachineContext, NoInfer, RaiseActionOptions, SendExpr } from "../types.js";
 /**
  * Raises an event. This places the event in the internal event queue, so that
  * the event is immediately consumed by the machine in the current step.
  *
  * @param eventType The event to raise.
  */
-export declare function raise<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject = TExpressionEvent>(eventOrExpr: NoInfer<TEvent> | SendExpr<TContext, TExpressionEvent, NoInfer<TEvent>>, options?: RaiseActionOptions<TContext, TExpressionEvent>): BaseDynamicActionObject<TContext, TExpressionEvent, TEvent, RaiseActionObject<TContext, TExpressionEvent, TEvent>, RaiseActionParams<TContext, TExpressionEvent, TEvent>>;
+export declare function raise<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject = TExpressionEvent>(eventOrExpr: NoInfer<TEvent> | SendExpr<TContext, TExpressionEvent, NoInfer<TEvent>>, options?: RaiseActionOptions<TContext, TExpressionEvent>): {
+    (args: ActionArgs<TContext, TExpressionEvent>): void;
+    _out_TEvent?: TEvent | undefined;
+};

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

@@ -1,32 +1,73 @@
-import { EventObject, SendActionParams, SendExpr, AnyEventObject, MachineContext } from "../types.js";
-import { AnyActorRef, BaseDynamicActionObject, Cast, EventFrom, ExprWithMeta, InferEvent, SendActionObject, SendActionOptions } from "../index.js";
+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 }: {
+    to: AnyActorRef | string | ((args: UnifiedArg<MachineContext, EventObject>) => AnyActorRef | string);
+    event: EventObject | SendExpr<MachineContext, EventObject, EventObject>;
+    id: string | undefined;
+    delay: string | number | DelayExpr<MachineContext, EventObject> | undefined;
+}): (AnyState | {
+    to: AnyActorRef;
+    event: EventObject;
+    id: string | undefined;
+    delay: number | undefined;
+})[];
+declare function execute(actorContext: AnyActorContext, params: {
+    to: AnyActorRef;
+    event: EventObject;
+    id: string | undefined;
+    delay: number | undefined;
+}): void;
 /**
- * Sends an event. This returns an action that will be read by an interpreter to
- * send the event in the next step, after the current step is finished executing.
- *
- * @deprecated Use the `sendTo(...)` action creator instead.
+ * Sends an event to an actor.
  *
- * @param eventOrExpr The event to send.
- * @param options Options to pass into the send event:
+ * @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 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.
- *  - `to` - The target of this event (by default, the machine the event was sent from).
  */
-export declare function send<TContext extends MachineContext, TEvent extends EventObject, TSentEvent extends EventObject = AnyEventObject>(eventOrExpr: TSentEvent | SendExpr<TContext, TEvent, AnyEventObject>, options?: SendActionOptions<TContext, TEvent>): BaseDynamicActionObject<TContext, TEvent, TEvent, SendActionObject<AnyEventObject>, SendActionParams<TContext, TEvent>>;
+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;
+    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").ActorMap, infer ____> ? TEvent_1 : R extends import("../State.js").State<infer __1 extends MachineContext, infer TEvent_2 extends EventObject, infer ____1> ? TEvent_2 : R extends ActorRef<infer TEvent_3 extends EventObject, infer __2> ? 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").ActorMap, infer ____> ? TEvent_1 : R extends import("../State.js").State<infer __1 extends MachineContext, infer TEvent_2 extends EventObject, infer ____1> ? TEvent_2 : R extends ActorRef<infer TEvent_3 extends EventObject, infer __2> ? TEvent_3 : never : never, EventObject>>>;
+    id: string | undefined;
+    delay: string | number | DelayExpr<TContext, TExpressionEvent> | undefined;
+    resolve: typeof resolve;
+    execute: typeof execute;
+};
 /**
  * Sends an event to this machine's parent.
  *
  * @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, 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>>;
+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;
+    type: string;
+    to: string | AnyActorRef | ((args: UnifiedArg<TContext, TExpressionEvent>) => string | AnyActorRef);
+    event: any;
+    id: string | undefined;
+    delay: string | number | DelayExpr<TContext, TExpressionEvent> | 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>);
 /**
  * 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, TEvent extends EventObject>(target: Required<SendActionParams<TContext, TEvent>>['to'], options?: SendActionOptions<TContext, TEvent>): BaseDynamicActionObject<TContext, TEvent, TEvent, SendActionObject<AnyEventObject>, SendActionParams<TContext, TEvent, EventObject>>;
+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;
+    type: string;
+    to: string | AnyActorRef | ((args: UnifiedArg<TContext, TExpressionEvent>) => string | AnyActorRef);
+    event: any;
+    id: string | undefined;
+    delay: string | number | DelayExpr<TContext, TExpressionEvent> | undefined;
+    resolve: typeof resolve;
+    execute: typeof execute;
+};
 /**
  * Escalates an error by sending it as an event to this machine's parent.
  *
@@ -34,13 +75,14 @@ export declare function forwardTo<TContext extends MachineContext, TEvent extend
  * 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, TEvent extends EventObject, TErrorData = any>(errorData: TErrorData | ExprWithMeta<TContext, TEvent, TErrorData>, options?: SendActionParams<TContext, TEvent>): BaseDynamicActionObject<TContext, TEvent, TEvent, SendActionObject<AnyEventObject>, SendActionParams<TContext, TEvent, EventObject>>;
-/**
- * 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 options Send action options
- * @returns An XState send action object
- */
-export declare function sendTo<TContext extends MachineContext, TEvent extends EventObject, TActor extends AnyActorRef>(actor: TActor | string | ExprWithMeta<TContext, TEvent, TActor | string>, event: EventFrom<TActor> | SendExpr<TContext, TEvent, InferEvent<Cast<EventFrom<TActor>, EventObject>>>, options?: SendActionOptions<TContext, TEvent>): BaseDynamicActionObject<TContext, TEvent, TEvent, SendActionObject<AnyEventObject>, SendActionParams<TContext, TEvent, EventObject>>;
+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;
+    type: string;
+    to: string | AnyActorRef | ((args: UnifiedArg<TContext, TExpressionEvent>) => string | AnyActorRef);
+    event: any;
+    id: string | undefined;
+    delay: string | number | DelayExpr<TContext, TExpressionEvent> | undefined;
+    resolve: typeof resolve;
+    execute: typeof execute;
+};
+export {};

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

@@ -1,7 +1,19 @@
-import { ActorRef, BaseDynamicActionObject, DynamicStopActionObject, EventObject, Expr, MachineContext, StopActionObject } from "../types.js";
+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>;
+}): (AnyState | ActorRef<any, any>)[];
+declare function execute(actorContext: AnyActorContext, actorRef: ActorRef<any, any> | undefined): void;
 /**
  * Stops an actor.
  *
  * @param actorRef The actor to stop.
  */
-export declare function stop<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject>(actorRef: string | ActorRef<any> | Expr<TContext, TExpressionEvent, ActorRef<any> | string>): BaseDynamicActionObject<TContext, TExpressionEvent, TEvent, StopActionObject, DynamicStopActionObject<TContext, TExpressionEvent>['params']>;
+export declare function stop<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject>(actorRef: ResolvableActorRef<TContext, TExpressionEvent>): {
+    (_: ActionArgs<TContext, TExpressionEvent>): void;
+    type: string;
+    actorRef: ResolvableActorRef<TContext, TExpressionEvent>;
+    resolve: typeof resolve;
+    execute: typeof execute;
+};
+export {};

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

@@ -1,6 +1,6 @@
-import { Action, EventObject, SingleOrArray, ActionFunction, ActionFunctionMap, ActionTypes, DoneEvent, ErrorPlatformEvent, DoneEventObject, MachineContext, BaseActionObject } from "./types.js";
-import * as actionTypes from "./actionTypes.js";
-export { send, sendTo, sendParent, forwardTo, escalate } from "./actions/send.js";
+import { DoneEvent, ErrorPlatformEvent, DoneEventObject } from "./types.js";
+import * as constantPrefixes from "./constantPrefixes.js";
+export { sendTo, sendParent, forwardTo, escalate } from "./actions/send.js";
 export { stop } from "./actions/stop.js";
 export { log } from "./actions/log.js";
 export { cancel } from "./actions/cancel.js";
@@ -8,13 +8,7 @@ export { assign } from "./actions/assign.js";
 export { raise } from "./actions/raise.js";
 export { choose } from "./actions/choose.js";
 export { pure } from "./actions/pure.js";
-export { actionTypes };
-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[];
+export { constantPrefixes };
 /**
  * Returns an event type that represents an implicit event that
  * is sent after the specified `delay`.
@@ -43,6 +37,6 @@ export declare function done(id: string, output?: any): DoneEventObject;
 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): {
-    readonly type: ActionTypes.Init;
+    readonly type: "xstate.init";
     readonly input: any;
 };

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

@@ -0,0 +1,6 @@
+import { ConstantPrefix } from "./types.js";
+export declare const after = ConstantPrefix.After;
+export declare const doneState = ConstantPrefix.DoneState;
+export declare const errorExecution = ConstantPrefix.ErrorExecution;
+export declare const errorPlatform = ConstantPrefix.ErrorPlatform;
+export declare const error = ConstantPrefix.ErrorCustom;

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, RaiseActionObject, SnapshotFrom } from "./types.js";
-import { ActorRef, EventObject, InteropSubscribable, InterpreterOptions, Observer, SendActionObject, Subscription } from "./types.js";
+import type { ActorSystem, AnyActorLogic, AnyStateMachine, EventFromLogic, InterpreterFrom, PersistedStateFrom, SnapshotFrom, AnyActorRef } from "./types.js";
+import { ActorRef, EventObject, InteropSubscribable, InterpreterOptions, 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;
@@ -80,7 +80,12 @@ export declare class Interpreter<TLogic extends AnyActorLogic, TEvent extends Ev
      * @param event The event to send
      */
     send(event: TEvent): void;
-    delaySend(sendAction: SendActionObject | RaiseActionObject<any, any, any>): void;
+    delaySend({ event, id, delay, to }: {
+        event: EventObject;
+        id: string | undefined;
+        delay: number;
+        to?: AnyActorRef;
+    }): void;
     cancel(sendId: string | number): void;
     private attachDevTools;
     toJSON(): {

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

@@ -1,8 +1,6 @@
-import { BaseActionObject, EventObject, StateValue, TransitionConfig, TransitionDefinition, SingleOrArray, StateValueMap, InitialTransitionConfig, MachineContext } from "./types.js";
 import { State } from "./State.js";
-import { NULL_EVENT } from "./constants.js";
 import type { StateNode } from "./StateNode.js";
-import { AnyActorContext, AnyHistoryValue, AnyState, AnyStateNode, AnyTransitionDefinition, DelayedTransitionDefinition, InitialTransitionDefinition } from "./index.js";
+import { Action, AnyActorContext, AnyHistoryValue, AnyState, AnyStateNode, AnyTransitionDefinition, DelayedTransitionDefinition, EventObject, InitialTransitionConfig, InitialTransitionDefinition, MachineContext, SingleOrArray, StateValue, StateValueMap, TransitionConfig, TransitionDefinition } 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>>;
@@ -17,10 +15,8 @@ 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, transitionConfig: TransitionConfig<TContext, TEvent> & {
-    event: TEvent['type'] | typeof NULL_EVENT | '*';
-}): AnyTransitionDefinition;
-export declare function formatTransitions<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode): Array<AnyTransitionDefinition>;
+export declare function formatTransition<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, descriptor: string, transitionConfig: TransitionConfig<TContext, TEvent>): 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 getInitialStateNodes(stateNode: AnyStateNode): Array<AnyStateNode>;
@@ -54,7 +50,7 @@ export declare function removeConflictingTransitions(enabledTransitions: Array<A
  * @param mutConfiguration
  */
 export declare function microstep<TContext extends MachineContext, TEvent extends EventObject>(transitions: Array<TransitionDefinition<TContext, TEvent>>, currentState: State<TContext, TEvent, any>, actorCtx: AnyActorContext, event: TEvent, isInitial: boolean): 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): AnyState;
+export declare function resolveActionsAndContext<TContext extends MachineContext, TEvent extends EventObject>(actions: Action<any, any, any>[], event: TEvent, currentState: State<TContext, TEvent, any>, actorCtx: AnyActorContext): AnyState;
 export declare function macrostep(state: AnyState, event: EventObject, actorCtx: AnyActorContext): {
     state: typeof state;
     microstates: Array<typeof state>;