xstate 5.0.0-alpha.0 → 5.0.0-alpha.2

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

@@ -1,3 +1,5 @@
-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>;
+import type { BaseActionObject, BaseDynamicActionObject, BuiltInActionObject, EventObject, MachineContext } from '../src/types';
+export declare function createDynamicAction<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject, TAction extends BaseActionObject, TDynamicParams extends Record<string, any>>(action: BuiltInActionObject & {
+    params: TDynamicParams;
+}, resolve: BaseDynamicActionObject<TContext, TExpressionEvent, TEvent, TAction, TDynamicParams>['resolve']): BaseDynamicActionObject<TContext, TExpressionEvent, TEvent, TAction, TDynamicParams>;
+export declare function isDynamicAction(action: any): action is BaseDynamicActionObject<any, any, any, any, any>;

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

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

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

@@ -1,12 +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;
-}
+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/SimulatedClock.d.ts

@@ -1,16 +1,16 @@
-import { Clock } from './interpreter';
-export interface SimulatedClock extends Clock {
-    start(speed: number): void;
-    increment(ms: number): void;
-    set(ms: number): void;
-}
-export declare class SimulatedClock implements SimulatedClock {
-    private timeouts;
-    private _now;
-    private _id;
-    now(): number;
-    private getId;
-    setTimeout(fn: (...args: any[]) => void, timeout: number): number;
-    clearTimeout(id: number): void;
-    private flushTimeouts;
-}
+import { Clock } from './interpreter.js';
+export interface SimulatedClock extends Clock {
+    start(speed: number): void;
+    increment(ms: number): void;
+    set(ms: number): void;
+}
+export declare class SimulatedClock implements SimulatedClock {
+    private timeouts;
+    private _now;
+    private _id;
+    now(): number;
+    private getId;
+    setTimeout(fn: (...args: any[]) => void, timeout: number): number;
+    clearTimeout(id: number): void;
+    private flushTimeouts;
+}

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

@@ -1,104 +1,97 @@
-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']>;
-}
+import type { StateNode } from './StateNode.js';
+import { TypegenDisabled, TypegenEnabled } from './typegenTypes.js';
+import type { ActorRef, AnyState, AnyStateMachine, BaseActionObject, EventObject, HistoryValue, MachineContext, PersistedMachineState, Prop, SCXML, StateConfig, StateValue, TransitionDefinition } from './types.js';
+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> {
+    machine: AnyStateMachine;
+    tags: Set<string>;
+    value: StateValue;
+    /**
+     * Indicates whether the state is a final state.
+     */
+    done: boolean;
+    /**
+     * The done data of the top-level finite state.
+     */
+    output: any;
+    context: TContext;
+    historyValue: Readonly<HistoryValue<TContext, TEvent>>;
+    actions: BaseActionObject[];
+    event: TEvent;
+    _internalQueue: Array<SCXML.Event<TEvent>>;
+    _event: SCXML.Event<TEvent>;
+    _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>>;
+    /**
+     * 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 | undefined, machine: AnyStateMachine): State<TContext, TEvent, any>;
+    /**
+     * Creates a new `State` instance that represents the current state of a running machine.
+     *
+     * @param config
+     */
+    constructor(config: StateConfig<TContext, TEvent>, machine: AnyStateMachine);
+    /**
+     * 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, "meta" | "toJSON" | "configuration" | "transitions" | "tags" | "machine" | "toStrings" | "matches" | "hasTag" | "can" | "nextEvents"> & {
+        tags: string[];
+        meta: Record<string, any>;
+    };
+    /**
+     * 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;
+    /**
+     * 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): boolean;
+    /**
+     * The next events that will cause a transition from the current state.
+     */
+    get nextEvents(): Array<TEvent['type']>;
+    get meta(): Record<string, any>;
+}
+export declare function cloneState<TState extends AnyState>(state: TState, config?: Partial<StateConfig<any, any>>): TState;
+export declare function getPersistedState<TState extends AnyState>(state: TState): PersistedMachineState<TState>;

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

@@ -1,112 +1,110 @@
-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;
-}
+import { State } from './State.js';
+import { StateNode } from './StateNode.js';
+import type { AreAllImplementationsAssumedToBeProvided, MarkAllImplementationsAsProvided, ResolveTypegenMeta, TypegenDisabled } from './typegenTypes.js';
+import type { ActorContext, ActorMap, ActorBehavior, EventObject, InternalMachineImplementations, MachineConfig, MachineContext, MachineImplementationsSimplified, MachineSchema, NoInfer, SCXML, StateConfig, StateMachineDefinition, StateValue, TransitionDefinition, AnyActorContext, PersistedMachineState, ParameterizedObject } from './types.js';
+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>>> {
+    /**
+     * 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.
+     */
+    version?: string;
+    /**
+     * 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>;
+    id: 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>): StateMachine<TContext, TEvent, TAction, TActorMap, AreAllImplementationsAssumedToBeProvided<TResolvedTypesMeta> extends false ? MarkAllImplementationsAsProvided<TResolvedTypesMeta> : TResolvedTypesMeta>;
+    /**
+     * 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;
+    resolveStateValue(stateValue: StateValue): State<TContext, TEvent, TResolvedTypesMeta>;
+    /**
+     * 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: TEvent | SCXML.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.
+     *
+     * @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>>;
+    /**
+     * The initial state _before_ evaluating any microsteps.
+     * This "pre-initial" state is provided to initial actions executed in the initial state.
+     */
+    private getPreInitialState;
+    /**
+     * 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(actorCtx?: ActorContext<TEvent, State<TContext, TEvent, TResolvedTypesMeta>>, input?: any): State<TContext, TEvent, TResolvedTypesMeta>;
+    start(state: State<TContext, TEvent, TResolvedTypesMeta>, actorCtx: ActorContext<TEvent, State<TContext, TEvent, TResolvedTypesMeta>>): void;
+    getStateNodeById(stateId: string): StateNode<TContext, TEvent>;
+    get definition(): StateMachineDefinition<TContext, TEvent>;
+    toJSON(): StateMachineDefinition<TContext, TEvent>;
+    getPersistedState(state: State<TContext, TEvent, TResolvedTypesMeta>): PersistedMachineState<State<TContext, TEvent, TResolvedTypesMeta>>;
+    createState(stateConfig: State<TContext, TEvent, TResolvedTypesMeta> | StateConfig<TContext, TEvent>): State<TContext, TEvent, TResolvedTypesMeta>;
+    getStatus(state: State<TContext, TEvent, TResolvedTypesMeta>): {
+        status: string;
+        data: any;
+    } | {
+        status: string;
+        data?: undefined;
+    };
+    restoreState(state: PersistedMachineState<State<TContext, TEvent, TResolvedTypesMeta>>, _actorCtx: ActorContext<TEvent, State<TContext, TEvent, TResolvedTypesMeta>>): 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;
+}