xstate 4.31.0 → 5.0.0-alpha.0

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

@@ -0,0 +1,23 @@
+import type { State } from '../src/State';
+import { TypegenDisabled } from '../src/typegenTypes';
+import { BaseActionObject, EventObject, MachineContext } from '../src/types';
+export interface ResolvedActionObject<TContext extends MachineContext, TEvent extends EventObject, TResolvedTypesMeta = TypegenDisabled> {
+    type: string;
+    params: Record<string, any>;
+    /**
+     * The intermediate context
+     */
+    context: TContext | undefined;
+    execute: (state: State<TContext, TEvent, TResolvedTypesMeta>) => any;
+}
+export declare class ExecutableAction<TContext extends object, TEvent extends EventObject, TResolvedTypesMeta = TypegenDisabled> implements ResolvedActionObject<TContext, TEvent, TResolvedTypesMeta> {
+    actionObject: BaseActionObject;
+    private _exec?;
+    type: string;
+    params: Record<string, any>;
+    context: TContext | undefined;
+    constructor(actionObject: BaseActionObject, _exec?: ((context: TContext, event: TEvent, meta: import("../src/types").ActionMeta<TContext, TEvent, BaseActionObject>) => void) | undefined);
+    execute(state: State<TContext, TEvent, TResolvedTypesMeta>): void | undefined;
+    setContext(context: TContext): void;
+}
+export declare function isExecutableAction(action: BaseActionObject | ResolvedActionObject<any, any, any>): action is ExecutableAction<any, any, any>;

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

@@ -0,0 +1,3 @@
+import type { BaseActionObject, BaseDynamicActionObject, EventObject, MachineContext } from '../src/types';
+export declare function createDynamicAction<TContext extends MachineContext, TEvent extends EventObject, TAction extends BaseActionObject, TDynamicParams extends Record<string, any>>(type: `xstate.${string}`, params: TDynamicParams, resolve: BaseDynamicActionObject<TContext, TEvent, TAction, TDynamicParams>['resolve']): BaseDynamicActionObject<TContext, TEvent, TAction, TDynamicParams>;
+export declare function isDynamicAction(action: any): action is BaseDynamicActionObject<any, any, any, any>;

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

@@ -0,0 +1,4 @@
+import { MachineConfig, EventObject, AnyEventObject, MachineContext, ActorMap, InternalMachineImplementations, BaseActionObject } from './types';
+import { TypegenConstraint, TypegenDisabled, ResolveTypegenMeta } from './typegenTypes';
+import { StateMachine } from './StateMachine';
+export declare function createMachine<TContext extends MachineContext, TEvent extends EventObject = AnyEventObject, TActorMap extends ActorMap = ActorMap, TTypesMeta extends TypegenConstraint = TypegenDisabled>(config: MachineConfig<TContext, TEvent, BaseActionObject, TActorMap, TTypesMeta>, implementations?: InternalMachineImplementations<TContext, TEvent, ResolveTypegenMeta<TTypesMeta, TEvent, BaseActionObject, TActorMap>>): StateMachine<TContext, TEvent, BaseActionObject, TActorMap, ResolveTypegenMeta<TTypesMeta, TEvent, BaseActionObject, TActorMap>>;

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

@@ -0,0 +1,12 @@
+export declare class Mailbox<T> {
+    private _process;
+    private _active;
+    private _current;
+    private _last;
+    constructor(_process: (ev: T) => void);
+    start(): void;
+    clear(): void;
+    prepend(event: T): void;
+    enqueue(event: T): void;
+    private flush;
+}

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

@@ -0,0 +1,25 @@
+import { EventObject, ActorRef, Behavior } from './types';
+import { symbolObservable } from './utils';
+export declare class ObservableActorRef<TEvent extends EventObject, TSnapshot> implements ActorRef<TEvent, TSnapshot> {
+    private behavior;
+    name: string;
+    private current;
+    private context;
+    private mailbox;
+    private _observers;
+    constructor(behavior: Behavior<TEvent, TSnapshot>, name: string);
+    start(): this;
+    stop(): this;
+    subscribe(observer: any): {
+        unsubscribe: () => void;
+    };
+    send(event: any): void;
+    toJSON(): {
+        name: string;
+        current: TSnapshot;
+    };
+    getSnapshot(): TSnapshot;
+    [symbolObservable](): this;
+    private receive;
+    private _process;
+}

package/{lib → dist/declarations/src}/SimulatedClock.d.ts

@@ -14,4 +14,3 @@ export declare class SimulatedClock implements SimulatedClock {
     clearTimeout(id: number): void;
     private flushTimeouts;
 }
-//# sourceMappingURL=SimulatedClock.d.ts.map

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

@@ -0,0 +1,104 @@
+import type { StateMachine } from './StateMachine';
+import type { StateNode } from './StateNode';
+import { TypegenDisabled, TypegenEnabled } from './typegenTypes';
+import type { ActorRef, BaseActionObject, EventObject, HistoryValue, MachineContext, Prop, SCXML, SimpleEventsOf, StateConfig, StateValue, TransitionDefinition } from './types';
+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.
+ */
+export declare const isState: typeof isStateConfig;
+export declare class State<TContext extends MachineContext, TEvent extends EventObject = EventObject, TResolvedTypesMeta = TypegenDisabled> {
+    value: StateValue;
+    context: TContext;
+    historyValue: HistoryValue<TContext, TEvent>;
+    actions: BaseActionObject[];
+    meta: any;
+    event: TEvent;
+    _internalQueue: Array<SCXML.Event<TEvent>>;
+    _event: SCXML.Event<TEvent>;
+    _sessionid: string | null;
+    _initial: boolean;
+    /**
+     * Indicates whether the state has changed from the previous state. A state is considered "changed" if:
+     *
+     * - Its value is not equal to its previous value, or:
+     * - It has any new actions (side-effects) to execute.
+     *
+     * An initial state (with no history) will return `undefined`.
+     */
+    changed: boolean | undefined;
+    /**
+     * The enabled state nodes representative of the state value.
+     */
+    configuration: Array<StateNode<TContext, TEvent>>;
+    /**
+     * The transition definitions that resulted in this state.
+     */
+    transitions: Array<TransitionDefinition<TContext, TEvent>>;
+    /**
+     * An object mapping actor names to spawned/invoked actors.
+     */
+    children: Record<string, ActorRef<any>>;
+    tags: Set<string>;
+    machine: StateMachine<TContext, TEvent, BaseActionObject, any, TResolvedTypesMeta> | undefined;
+    /**
+     * Creates a new State instance for the given `stateValue` and `context`.
+     * @param stateValue
+     * @param context
+     */
+    static from<TContext extends MachineContext, TEvent extends EventObject = EventObject>(stateValue: State<TContext, TEvent, any> | StateValue, context?: TContext): State<TContext, TEvent, any>;
+    /**
+     * Creates a new State instance for the given `config`.
+     * @param config The state config
+     */
+    static create<TC extends MachineContext, TE extends EventObject = EventObject>(config: StateConfig<TC, TE>): State<TC, TE, any>;
+    /**
+     * Creates a new `State` instance for the given `stateValue` and `context` with no actions (side-effects).
+     * @param stateValue
+     * @param context
+     */
+    static inert<TState extends State<any, any, any>>(state: TState): TState;
+    static inert<TContext extends MachineContext, TEvent extends EventObject = EventObject>(stateValue: StateValue, context: TContext): State<TContext, TEvent>;
+    /**
+     * Creates a new `State` instance that represents the current state of a running machine.
+     *
+     * @param config
+     */
+    constructor(config: StateConfig<TContext, TEvent>);
+    /**
+     * Returns an array of all the string leaf state node paths.
+     * @param stateValue
+     * @param delimiter The character(s) that separate each subpath in the string state node path.
+     */
+    toStrings(stateValue?: StateValue, delimiter?: string): string[];
+    toJSON(): Omit<this, "toJSON" | "configuration" | "transitions" | "tags" | "machine" | "toStrings" | "matches" | "done" | "hasTag" | "can" | "nextEvents"> & {
+        tags: string[];
+    };
+    /**
+     * Whether the current state value is a subset of the given parent state value.
+     * @param parentStateValue
+     */
+    matches<TSV extends TResolvedTypesMeta extends TypegenEnabled ? Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'matchesStates'> : StateValue>(parentStateValue: TSV): boolean;
+    /**
+     * Indicates whether the state is a final state.
+     */
+    get done(): boolean;
+    /**
+     * Whether the current state configuration has a state node with the specified `tag`.
+     * @param tag
+     */
+    hasTag(tag: TResolvedTypesMeta extends TypegenEnabled ? Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'tags'> : string): boolean;
+    /**
+     * Determines whether sending the `event` will cause a non-forbidden transition
+     * to be selected, even if the transitions have no actions nor
+     * change the state value.
+     *
+     * @param event The event to test
+     * @returns Whether the event will cause a transition
+     */
+    can(event: TEvent | SimpleEventsOf<TEvent>['type']): boolean;
+    /**
+     * The next events that will cause a transition from the current state.
+     */
+    get nextEvents(): Array<TEvent['type']>;
+}

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

@@ -0,0 +1,112 @@
+import { StateFrom } from '.';
+import { State } from './State';
+import { StateNode } from './StateNode';
+import type { AreAllImplementationsAssumedToBeProvided, MarkAllImplementationsAsProvided, ResolveTypegenMeta, TypegenDisabled } from './typegenTypes';
+import type { ActorMap, BaseActionObject, Event, EventObject, InternalMachineImplementations, MachineConfig, MachineContext, MachineImplementationsSimplified, MachineSchema, MaybeLazy, NoInfer, SCXML, StateConfig, StateNodeDefinition, StateValue, Transitions } from './types';
+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 BaseActionObject = BaseActionObject, TActorMap extends ActorMap = ActorMap, TResolvedTypesMeta = ResolveTypegenMeta<TypegenDisabled, NoInfer<TEvent>, TAction, TActorMap>> {
+    /**
+     * The raw config used to create the machine.
+     */
+    config: MachineConfig<TContext, TEvent, any, any, any>;
+    private _contextFactory;
+    get context(): TContext;
+    private getContextAndActions;
+    /**
+     * The machine's own version.
+     */
+    version?: string;
+    strict: boolean;
+    /**
+     * The string delimiter for serializing the path to a string. The default is "."
+     */
+    delimiter: string;
+    options: MachineImplementationsSimplified<TContext, TEvent>;
+    schema: MachineSchema<TContext, TEvent>;
+    __xstatenode: true;
+    idMap: Map<string, StateNode<TContext, TEvent>>;
+    root: StateNode<TContext, TEvent>;
+    key: string;
+    states: StateNode<TContext, TEvent>['states'];
+    events: Array<TEvent['type']>;
+    constructor(
+    /**
+     * The raw config used to create the machine.
+     */
+    config: MachineConfig<TContext, TEvent, any, any, any>, options?: MachineImplementationsSimplified<TContext, TEvent>);
+    /**
+     * Clones this state machine with the provided implementations
+     * and merges the `context` (if provided).
+     *
+     * @param implementations Options (`actions`, `guards`, `actors`, `delays`, `context`)
+     *  to recursively merge with the existing options.
+     *
+     * @returns A new `StateMachine` instance with the provided implementations.
+     */
+    provide(implementations: InternalMachineImplementations<TContext, TEvent, TResolvedTypesMeta, true> & {
+        context?: MaybeLazy<Partial<TContext>>;
+    }): StateMachine<TContext, TEvent, TAction, TActorMap, AreAllImplementationsAssumedToBeProvided<TResolvedTypesMeta> extends false ? MarkAllImplementationsAsProvided<TResolvedTypesMeta> : TResolvedTypesMeta>;
+    /**
+     * Clones this state machine with custom `context`.
+     *
+     * The `context` provided can be partial `context`, which will be combined with the original `context`.
+     *
+     * @param context Custom context (will override predefined context, not recursive)
+     */
+    withContext(context: Partial<TContext>): this;
+    /**
+     * Resolves the given `state` to a new `State` instance relative to this machine.
+     *
+     * This ensures that `.nextEvents` represent the correct values.
+     *
+     * @param state The state to resolve
+     */
+    resolveState(state: State<TContext, TEvent, TResolvedTypesMeta>): typeof state;
+    /**
+     * Determines the next state given the current `state` and received `event`.
+     * Calculates a full macrostep from all microsteps.
+     *
+     * @param state The current State instance or state value
+     * @param event The received event
+     */
+    transition(state: StateValue | State<TContext, TEvent, TResolvedTypesMeta> | undefined, event: Event<TEvent> | SCXML.Event<TEvent>): State<TContext, TEvent, TResolvedTypesMeta>;
+    /**
+     * Determines the next state given the current `state` and `event`.
+     * Calculates a microstep.
+     *
+     * @param state The current state
+     * @param event The received event
+     */
+    microstep(state: StateValue | State<TContext, TEvent, TResolvedTypesMeta> | undefined, event: Event<TEvent> | SCXML.Event<TEvent>): State<TContext, TEvent, TResolvedTypesMeta>;
+    getTransitionData(state: State<TContext, TEvent, TResolvedTypesMeta>, _event: SCXML.Event<TEvent>): Transitions<TContext, TEvent>;
+    /**
+     * The initial state _before_ evaluating any microsteps.
+     * This "pre-initial" state is provided to initial actions executed in the initial state.
+     */
+    private get preInitialState();
+    /**
+     * The initial State instance, which includes all actions to be executed from
+     * entering the initial state.
+     */
+    get initialState(): State<TContext, TEvent, TResolvedTypesMeta>;
+    /**
+     * Returns the initial `State` instance, with reference to `self` as an `ActorRef`.
+     */
+    getInitialState(): StateFrom<typeof this>;
+    getStateNodeById(stateId: string): StateNode<TContext, TEvent>;
+    get definition(): StateNodeDefinition<TContext, TEvent>;
+    toJSON(): StateNodeDefinition<TContext, TEvent>;
+    createState(stateConfig: State<TContext, TEvent, TResolvedTypesMeta> | StateConfig<TContext, TEvent>): State<TContext, TEvent, TResolvedTypesMeta>;
+    /**@deprecated an internal property acting as a "phantom" type, not meant to be used at runtime */
+    __TContext: TContext;
+    /** @deprecated an internal property acting as a "phantom" type, not meant to be used at runtime */
+    __TEvent: TEvent;
+    /** @deprecated an internal property acting as a "phantom" type, not meant to be used at runtime */
+    __TAction: TAction;
+    /** @deprecated an internal property acting as a "phantom" type, not meant to be used at runtime */
+    __TActorMap: TActorMap;
+    /** @deprecated an internal property acting as a "phantom" type, not meant to be used at runtime */
+    __TResolvedTypesMeta: TResolvedTypesMeta;
+}

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

@@ -0,0 +1,127 @@
+import type { Event, EventObject, StateNodeDefinition, TransitionDefinition, DelayedTransitionDefinition, StateNodeConfig, StateNodesConfig, InvokeDefinition, Mapper, PropertyMapper, SCXML, TransitionDefinitionMap, InitialTransitionDefinition, MachineContext, BaseActionObject } from './types';
+import type { State } from './State';
+import type { StateMachine } from './StateMachine';
+interface StateNodeOptions<TContext extends MachineContext, TEvent extends EventObject> {
+    _key: string;
+    _parent?: StateNode<TContext, TEvent>;
+    _machine: StateMachine<TContext, TEvent, any, any, any>;
+}
+export declare class StateNode<TContext extends MachineContext = MachineContext, TEvent extends EventObject = EventObject> {
+    /**
+     * The raw config used to create the machine.
+     */
+    config: StateNodeConfig<TContext, TEvent>;
+    /**
+     * The relative key of the state node, which represents its location in the overall state value.
+     */
+    key: string;
+    /**
+     * The unique ID of the state node.
+     */
+    id: string;
+    /**
+     * The type of this state node:
+     *
+     *  - `'atomic'` - no child state nodes
+     *  - `'compound'` - nested child state nodes (XOR)
+     *  - `'parallel'` - orthogonal nested child state nodes (AND)
+     *  - `'history'` - history state node
+     *  - `'final'` - final state node
+     */
+    type: 'atomic' | 'compound' | 'parallel' | 'final' | 'history';
+    /**
+     * The string path from the root machine node to this node.
+     */
+    path: string[];
+    /**
+     * The child state nodes.
+     */
+    states: StateNodesConfig<TContext, TEvent>;
+    /**
+     * The type of history on this state node. Can be:
+     *
+     *  - `'shallow'` - recalls only top-level historical state value
+     *  - `'deep'` - recalls historical state value at all levels
+     */
+    history: false | 'shallow' | 'deep';
+    /**
+     * The action(s) to be executed upon entering the state node.
+     */
+    entry: BaseActionObject[];
+    /**
+     * The action(s) to be executed upon exiting the state node.
+     */
+    exit: BaseActionObject[];
+    /**
+     * The parent state node.
+     */
+    parent?: StateNode<TContext, TEvent>;
+    /**
+     * The root machine node.
+     */
+    machine: StateMachine<TContext, TEvent, any, any>;
+    /**
+     * The meta data associated with this state node, which will be returned in State instances.
+     */
+    meta?: any;
+    /**
+     * The data sent with the "done.state._id_" event if this is a final state node.
+     */
+    doneData?: Mapper<TContext, TEvent, any> | PropertyMapper<TContext, TEvent, any>;
+    /**
+     * The order this state node appears. Corresponds to the implicit SCXML document order.
+     */
+    order: number;
+    description?: string;
+    tags: string[];
+    transitions: Array<TransitionDefinition<TContext, TEvent>>;
+    always?: Array<TransitionDefinition<TContext, TEvent>>;
+    constructor(
+    /**
+     * The raw config used to create the machine.
+     */
+    config: StateNodeConfig<TContext, TEvent>, options: StateNodeOptions<TContext, TEvent>);
+    _initialize(): void;
+    /**
+     * The well-structured state node definition.
+     */
+    get definition(): StateNodeDefinition<TContext, TEvent>;
+    toJSON(): StateNodeDefinition<TContext, TEvent>;
+    /**
+     * The behaviors invoked as actors by this state node.
+     */
+    get invoke(): Array<InvokeDefinition<TContext, TEvent>>;
+    /**
+     * The mapping of events to transitions.
+     */
+    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: Event<TEvent>): boolean;
+    next(state: State<TContext, TEvent>, _event: SCXML.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.
+     */
+    get target(): string | undefined;
+    /**
+     * All the state node IDs of this state node and its descendant state nodes.
+     */
+    get stateIds(): string[];
+    /**
+     * All the event types accepted by this state node and its descendants.
+     */
+    get events(): Array<TEvent['type']>;
+    /**
+     * All the events that have transitions directly from this state node.
+     *
+     * Excludes any inert events.
+     */
+    get ownEvents(): Array<TEvent['type']>;
+}
+export {};

package/{es → dist/declarations/src}/actionTypes.d.ts

@@ -1,10 +1,8 @@
 import { ActionTypes } from './types';
-export declare const start = ActionTypes.Start;
 export declare const stop = ActionTypes.Stop;
 export declare const raise = ActionTypes.Raise;
 export declare const send = ActionTypes.Send;
 export declare const cancel = ActionTypes.Cancel;
-export declare const nullEvent = ActionTypes.NullEvent;
 export declare const assign = ActionTypes.Assign;
 export declare const after = ActionTypes.After;
 export declare const doneState = ActionTypes.DoneState;
@@ -17,4 +15,3 @@ export declare const error = ActionTypes.ErrorCustom;
 export declare const update = ActionTypes.Update;
 export declare const choose = ActionTypes.Choose;
 export declare const pure = ActionTypes.Pure;
-//# sourceMappingURL=actionTypes.d.ts.map

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

@@ -0,0 +1,7 @@
+import type { EventObject, Assigner, PropertyAssigner, MachineContext, DynamicAssignAction } from '../types';
+/**
+ * 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, TEvent extends EventObject = EventObject, TAssignment extends Assigner<TContext, TEvent> | PropertyAssigner<TContext, TEvent> = Assigner<TContext, TEvent> | PropertyAssigner<TContext, TEvent>>(assignment: TAssignment): DynamicAssignAction<TContext, TEvent>;

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

@@ -0,0 +1,10 @@
+import { EventObject, ExprWithMeta, MachineContext } from '../types';
+import { BaseDynamicActionObject, CancelActionObject, DynamicCancelActionObject } from '..';
+/**
+ * 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
+ * (e.g., if `cancel(...)` is called after the `send(...)` action's `delay`).
+ *
+ * @param sendId The `id` of the `send(...)` action to cancel.
+ */
+export declare function cancel<TContext extends MachineContext, TEvent extends EventObject>(sendId: string | ExprWithMeta<TContext, TEvent, string>): BaseDynamicActionObject<TContext, TEvent, CancelActionObject, DynamicCancelActionObject<TContext, TEvent>['params']>;

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

@@ -0,0 +1,3 @@
+import { EventObject, ChooseCondition, MachineContext } from '../types';
+import { BaseDynamicActionObject, ChooseAction, ResolvedChooseAction } from '..';
+export declare function choose<TContext extends MachineContext, TEvent extends EventObject>(guards: Array<ChooseCondition<TContext, TEvent>>): BaseDynamicActionObject<TContext, TEvent, ResolvedChooseAction, ChooseAction<TContext, TEvent>['params']>;

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

@@ -0,0 +1,3 @@
+import { EventObject, InvokeDefinition, MachineContext } from '../types';
+import { BaseDynamicActionObject, DynamicInvokeActionObject, InvokeActionObject } from '..';
+export declare function invoke<TContext extends MachineContext, TEvent extends EventObject>(invokeDef: InvokeDefinition<TContext, TEvent>): BaseDynamicActionObject<TContext, TEvent, InvokeActionObject, DynamicInvokeActionObject<TContext, TEvent>['params']>;

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

@@ -0,0 +1,11 @@
+import { EventObject, LogExpr, MachineContext, LogActionObject } from '../types';
+import { BaseDynamicActionObject, DynamicLogAction } from '..';
+/**
+ *
+ * @param expr The expression function to evaluate which will be logged.
+ *  Takes in 2 arguments:
+ *  - `ctx` - the current state context
+ *  - `event` - the event that caused this action to be executed.
+ * @param label The label to give to the logged expression.
+ */
+export declare function log<TContext extends MachineContext, TEvent extends EventObject>(expr?: string | LogExpr<TContext, TEvent>, label?: string): BaseDynamicActionObject<TContext, TEvent, LogActionObject, DynamicLogAction<TContext, TEvent>['params']>;

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

@@ -0,0 +1,3 @@
+import { EventObject, SingleOrArray, MachineContext } from '../types';
+import { BaseActionObject, BaseDynamicActionObject, DynamicPureActionObject, PureActionObject } from '..';
+export declare function pure<TContext extends MachineContext, TEvent extends EventObject>(getActions: (context: TContext, event: TEvent) => SingleOrArray<BaseActionObject> | undefined): BaseDynamicActionObject<TContext, TEvent, PureActionObject, DynamicPureActionObject<TContext, TEvent>['params']>;

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

@@ -0,0 +1,9 @@
+import { Event, EventObject, RaiseActionObject } from '../types';
+import { BaseDynamicActionObject } from '..';
+/**
+ * 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<TEvent extends EventObject>(event: Event<TEvent>): BaseDynamicActionObject<any, TEvent, RaiseActionObject<TEvent>, RaiseActionObject<TEvent>['params']>;

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

@@ -0,0 +1,55 @@
+import { Event, EventObject, SendActionParams, SendExpr, AnyEventObject, MachineContext } from '../types';
+import { AnyActorRef, BaseDynamicActionObject, Cast, EventFrom, ExprWithMeta, InferEvent, SendActionObject, SendActionOptions } from '..';
+/**
+ * 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.
+ *
+ * @param event The event to send.
+ * @param options Options to pass into the send event:
+ *  - `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>(event: Event<TSentEvent> | SendExpr<TContext, TEvent, TSentEvent>, options?: SendActionOptions<TContext, TEvent>): BaseDynamicActionObject<TContext, TEvent, SendActionObject<AnyEventObject>, SendActionParams<TContext, TEvent>>;
+/**
+ * Sends an update event to this machine's parent.
+ */
+export declare function sendUpdate<TContext extends MachineContext, TEvent extends EventObject>(): BaseDynamicActionObject<TContext, TEvent, SendActionObject<AnyEventObject>, SendActionParams<TContext, TEvent, EventObject>>;
+/**
+ * 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: Event<TSentEvent> | SendExpr<TContext, TEvent, TSentEvent>, options?: SendActionOptions<TContext, TEvent>): BaseDynamicActionObject<TContext, 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: Event<TEvent> | SendExpr<TContext, TEvent, TSentEvent>, options?: SendActionOptions<TContext, TEvent>): BaseDynamicActionObject<TContext, TEvent, SendActionObject<AnyEventObject>, SendActionParams<TContext, TEvent, EventObject>>;
+/**
+ * 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, SendActionObject<AnyEventObject>, SendActionParams<TContext, TEvent, EventObject>>;
+/**
+ * Escalates an error by sending it as an event to this machine's parent.
+ *
+ * @param errorData The error data to send, or the expression function that
+ * 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, 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: (ctx: TContext) => TActor, event: EventFrom<TActor> | SendExpr<TContext, TEvent, InferEvent<Cast<EventFrom<TActor>, EventObject>>>, options?: SendActionOptions<TContext, TEvent>): BaseDynamicActionObject<TContext, TEvent, SendActionObject<AnyEventObject>, SendActionParams<TContext, TEvent, EventObject>>;

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

@@ -0,0 +1,8 @@
+import { EventObject, ActorRef, Expr, MachineContext } from '../types';
+import { BaseDynamicActionObject, DynamicStopActionObject, StopActionObject } from '..';
+/**
+ * Stops an actor.
+ *
+ * @param actorRef The actor to stop.
+ */
+export declare function stop<TContext extends MachineContext, TEvent extends EventObject>(actorRef: string | Expr<TContext, TEvent, ActorRef<any>>): BaseDynamicActionObject<TContext, TEvent, StopActionObject, DynamicStopActionObject<TContext, TEvent>['params']>;

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

@@ -0,0 +1,44 @@
+import { Action, EventObject, SingleOrArray, ActionType, ActionFunction, ActionFunctionMap, ActionTypes, DoneEvent, ErrorPlatformEvent, DoneEventObject, MachineContext, BaseActionObject } from './types';
+import * as actionTypes from './actionTypes';
+export { send, sendTo, sendUpdate, sendParent, respond, forwardTo, escalate } from './actions/send';
+export { stop } from './actions/stop';
+export { log } from './actions/log';
+export { cancel } from './actions/cancel';
+export { assign } from './actions/assign';
+export { raise } from './actions/raise';
+export { choose } from './actions/choose';
+export { actionTypes };
+export declare const initEvent: import("./types").SCXML.Event<{
+    type: ActionTypes;
+}>;
+export declare function getActionFunction<TContext extends MachineContext, TEvent extends EventObject>(actionType: ActionType, actionFunctionMap?: ActionFunctionMap<TContext, TEvent>): BaseActionObject | ActionFunction<TContext, TEvent> | undefined;
+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, actionFunctionMap?: ActionFunctionMap<TContext, TEvent>): BaseActionObject;
+export declare const toActionObjects: <TContext extends MachineContext, TEvent extends EventObject>(action?: SingleOrArray<Action<TContext, TEvent>> | undefined, actionFunctionMap?: ActionFunctionMap<TContext, TEvent, BaseActionObject> | undefined) => BaseActionObject[];
+/**
+ * Returns an event type that represents an implicit event that
+ * is sent after the specified `delay`.
+ *
+ * @param delayRef The delay in milliseconds
+ * @param id The state node ID where this event is handled
+ */
+export declare function after(delayRef: number | string, id?: string): string;
+/**
+ * Returns an event that represents that a final state node
+ * 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
+ */
+export declare function done(id: string, data?: any): DoneEventObject;
+/**
+ * Returns an event that represents that an invoked service has terminated.
+ *
+ * An invoked service is terminated when it has reached a top-level final state node,
+ * but not when it is canceled.
+ *
+ * @param invokeId The invoked service ID
+ * @param data The data to pass into the event
+ */
+export declare function doneInvoke(invokeId: string, data?: any): DoneEvent;
+export declare function error(id: string, data?: any): ErrorPlatformEvent & string;