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

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

@@ -1,44 +1,47 @@
-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;
+import { Action, EventObject, SingleOrArray, ActionFunction, ActionFunctionMap, ActionTypes, DoneEvent, ErrorPlatformEvent, DoneEventObject, MachineContext, BaseActionObject, SCXML } from './types.js';
+import * as actionTypes from './actionTypes.js';
+export { send, sendTo, sendParent, respond, forwardTo, escalate } from './actions/send.js';
+export { stop } from './actions/stop.js';
+export { log } from './actions/log.js';
+export { cancel } from './actions/cancel.js';
+export { assign } from './actions/assign.js';
+export { raise } from './actions/raise.js';
+export { choose } from './actions/choose.js';
+export { actionTypes };
+export declare const initEvent: SCXML.Event<{
+    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, TEvent>> | 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;
+export declare function createInitEvent(input: any): SCXML.Event<{
+    type: ActionTypes.Init;
+    input: any;
+}>;

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

@@ -0,0 +1,8 @@
+import { InvokeCallback, ActorBehavior, EventObject } from '../types';
+export interface CallbackInternalState {
+    canceled: boolean;
+    receivers: Set<(e: EventObject) => void>;
+    dispose: void | (() => void) | Promise<any>;
+    input?: any;
+}
+export declare function fromCallback<TEvent extends EventObject>(invokeCallback: InvokeCallback): ActorBehavior<TEvent, undefined>;

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

@@ -0,0 +1,27 @@
+import type { EventObject, ActorRef, BaseActorRef } from '../types.js';
+export { fromTransition } from './transition.js';
+export { fromPromise } from './promise.js';
+export { fromObservable, fromEventObservable } from './observable.js';
+export { fromCallback } from './callback.js';
+export declare const startSignalType = "xstate.init";
+export declare const stopSignalType = "xstate.stop";
+export declare const startSignal: StartSignal;
+export declare const stopSignal: StopSignal;
+export interface StartSignal {
+    type: 'xstate.init';
+}
+export interface StopSignal {
+    type: 'xstate.stop';
+}
+export type LifecycleSignal = StartSignal | StopSignal;
+export type LifecycleSignalType = typeof startSignalType | typeof stopSignalType;
+/**
+ * An object that expresses the behavior of an actor in reaction to received events,
+ * as well as an optionally emitted stream of values.
+ *
+ * @template TReceived The received event
+ * @template TSnapshot The emitted value
+ */
+export declare function isSignal(eventType: string): eventType is LifecycleSignalType;
+export declare function isActorRef(item: any): item is ActorRef<any>;
+export declare function toActorRef<TEvent extends EventObject, TSnapshot = any, TActorRefLike extends BaseActorRef<TEvent> = BaseActorRef<TEvent>>(actorRefLike: TActorRefLike): ActorRef<TEvent, TSnapshot> & Omit<TActorRefLike, keyof ActorRef<any, any>>;

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

@@ -0,0 +1,23 @@
+import { Subscribable, ActorBehavior, EventObject, Subscription } from '../types';
+export interface ObservableInternalState<T> {
+    subscription: Subscription | undefined;
+    canceled: boolean;
+    status: 'active' | 'done' | 'error';
+    data: T | undefined;
+    input?: any;
+}
+export type ObservablePersistedState<T> = Omit<ObservableInternalState<T>, 'subscription'>;
+export declare function fromObservable<T, TEvent extends EventObject>(observableCreator: ({ input }: {
+    input: any;
+}) => Subscribable<T>): ActorBehavior<TEvent, T | undefined, ObservableInternalState<T>, ObservablePersistedState<T>>;
+/**
+ * Creates an event observable behavior that listens to an observable
+ * that delivers event objects.
+ *
+ *
+ * @param lazyObservable A function that creates an observable
+ * @returns An event observable behavior
+ */
+export declare function fromEventObservable<T extends EventObject>(lazyObservable: ({ input }: {
+    input: any;
+}) => Subscribable<T>): ActorBehavior<EventObject, T | undefined>;

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

@@ -0,0 +1,12 @@
+import { ActorBehavior } from '../types';
+export interface PromiseInternalState<T> {
+    status: 'active' | 'error' | 'done';
+    canceled: boolean;
+    data: T | undefined;
+    input?: any;
+}
+export declare function fromPromise<T>(promiseCreator: ({ input }: {
+    input: any;
+}) => PromiseLike<T>): ActorBehavior<{
+    type: string;
+}, T | undefined, PromiseInternalState<T>>;

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

@@ -0,0 +1,13 @@
+import { ActorBehavior, ActorContext, ActorSystem, EventObject } from '../types';
+/**
+ * Returns an actor behavior from a transition function and its initial state.
+ *
+ * A transition function is a function that takes the current state and an event and returns the next state.
+ *
+ * @param transition The transition function that returns the next state given the current state and event.
+ * @param initialState The initial state of the transition function.
+ * @returns An actor behavior
+ */
+export declare function fromTransition<TState, TEvent extends EventObject, TSystem extends ActorSystem<any>>(transition: (state: TState, event: TEvent, actorContext: ActorContext<TEvent, TState, TSystem>) => TState, initialState: TState | (({ input }: {
+    input: any;
+}) => TState)): ActorBehavior<TEvent, TState, TState>;

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

@@ -1,5 +1,5 @@
-export declare const STATE_DELIMITER = ".";
-export declare const TARGETLESS_KEY = "";
-export declare const NULL_EVENT = "";
-export declare const STATE_IDENTIFIER = "#";
-export declare const WILDCARD = "*";
+export declare const STATE_DELIMITER = ".";
+export declare const TARGETLESS_KEY = "";
+export declare const NULL_EVENT = "";
+export declare const STATE_IDENTIFIER = "#";
+export declare const WILDCARD = "*";

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

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

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

@@ -1 +1 @@
-export declare const IS_PRODUCTION: boolean;
+export declare const IS_PRODUCTION: boolean;

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

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

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

@@ -1,47 +1,44 @@
-import { after, done, doneInvoke, escalate, forwardTo, respond, sendParent, sendTo, sendUpdate } from './actions';
-import { assign } from './actions/assign';
-import { cancel } from './actions/cancel';
-import { choose } from './actions/choose';
-import { log } from './actions/log';
-import { pure } from './actions/pure';
-import { raise } from './actions/raise';
-import { send } from './actions/send';
-import { stop } from './actions/stop';
-import { interpret, Interpreter, InterpreterStatus } from './interpreter';
-import { createMachine } from './Machine';
-import { mapState } from './mapState';
-import { matchState } from './match';
-import { State } from './State';
-import { StateNode } from './StateNode';
-export { createSchema, t } from './schema';
-export { SimulatedClock } from './SimulatedClock';
-export { StateMachine } from './StateMachine';
-export { getStateNodes } from './stateUtils';
-export { ObservableActorRef } from './ObservableActorRef';
-export * from './typegenTypes';
-export * from './types';
-export { matchesState, pathToStateValue, toEventObject, toObserver, toSCXMLEvent } from './utils';
-export { StateNode, State, mapState, actions, assign, send, sendParent, sendUpdate, forwardTo, interpret, Interpreter, InterpreterStatus, matchState, doneInvoke, createMachine };
-declare const actions: {
-    raise: typeof raise;
-    send: typeof send;
-    sendParent: typeof sendParent;
-    sendTo: typeof sendTo;
-    sendUpdate: typeof sendUpdate;
-    log: typeof log;
-    cancel: typeof cancel;
-    stop: typeof stop;
-    assign: typeof assign;
-    after: typeof after;
-    done: typeof done;
-    respond: typeof respond;
-    forwardTo: typeof forwardTo;
-    escalate: typeof escalate;
-    choose: typeof choose;
-    pure: typeof pure;
-};
-declare global {
-    interface SymbolConstructor {
-        readonly observable: symbol;
-    }
-}
+import { after, done, doneInvoke, escalate, forwardTo, respond, sendParent, sendTo } from './actions.js';
+import { assign } from './actions/assign.js';
+import { cancel } from './actions/cancel.js';
+import { choose } from './actions/choose.js';
+import { log } from './actions/log.js';
+import { pure } from './actions/pure.js';
+import { raise } from './actions/raise.js';
+import { send } from './actions/send.js';
+import { stop } from './actions/stop.js';
+import { interpret, Interpreter, ActorStatus } from './interpreter.js';
+import { createMachine } from './Machine.js';
+import { mapState } from './mapState.js';
+import { State } from './State.js';
+import { StateNode } from './StateNode.js';
+export { createSchema, t } from './schema.js';
+export { SimulatedClock } from './SimulatedClock.js';
+export { StateMachine } from './StateMachine.js';
+export { getStateNodes } from './stateUtils.js';
+export * from './typegenTypes.js';
+export * from './types.js';
+export { matchesState, pathToStateValue, toObserver, toSCXMLEvent } from './utils.js';
+export { StateNode, State, mapState, actions, assign, send, sendTo, sendParent, forwardTo, interpret, Interpreter, ActorStatus as InterpreterStatus, doneInvoke, createMachine };
+declare const actions: {
+    raise: typeof raise;
+    send: typeof send;
+    sendParent: typeof sendParent;
+    sendTo: typeof sendTo;
+    log: typeof log;
+    cancel: typeof cancel;
+    stop: typeof stop;
+    assign: typeof assign;
+    after: typeof after;
+    done: typeof done;
+    respond: typeof respond;
+    forwardTo: typeof forwardTo;
+    escalate: typeof escalate;
+    choose: typeof choose;
+    pure: typeof pure;
+};
+declare global {
+    interface SymbolConstructor {
+        readonly observable: symbol;
+    }
+}

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

@@ -1,147 +1,104 @@
-import { AnyStateMachine, InterpreterFrom } from '.';
-import { State } from './State';
-import type { StateMachine } from './StateMachine';
-import { TypegenDisabled, AreAllImplementationsAssumedToBeProvided } from './typegenTypes';
-import type { MachineContext, PayloadSender } from './types';
-import { ActorRef, DoneEvent, Event, EventObject, InteropSubscribable, InterpreterOptions, Observer, SCXML, StateValue, Subscription } from './types';
-import { symbolObservable } from './utils';
-export declare type StateListener<TContext extends MachineContext, TEvent extends EventObject, TResolvedTypesMeta = TypegenDisabled> = (state: State<TContext, TEvent, TResolvedTypesMeta>, event: TEvent) => void;
-export declare type EventListener<TEvent extends EventObject = EventObject> = (event: TEvent) => void;
-export declare type Listener = () => void;
-export declare type ErrorListener = (error: any) => void;
-export interface Clock {
-    setTimeout(fn: (...args: any[]) => void, timeout: number): any;
-    clearTimeout(id: any): void;
-}
-export declare enum InterpreterStatus {
-    NotStarted = 0,
-    Running = 1,
-    Stopped = 2
-}
-export declare class Interpreter<TContext extends MachineContext, TEvent extends EventObject = EventObject, TResolvedTypesMeta = TypegenDisabled> implements ActorRef<TEvent, State<TContext, TEvent, TResolvedTypesMeta>> {
-    machine: StateMachine<TContext, TEvent, any, any, TResolvedTypesMeta>;
-    /**
-     * The current state of the interpreted machine.
-     */
-    private _state?;
-    private _initialState?;
-    /**
-     * The clock that is responsible for setting and clearing timeouts, such as delayed events and transitions.
-     */
-    clock: Clock;
-    options: Readonly<InterpreterOptions>;
-    id: string;
-    private mailbox;
-    private delayedEventsMap;
-    private listeners;
-    private stopListeners;
-    private errorListeners;
-    private doneListeners;
-    private logger;
-    /**
-     * Whether the service is started.
-     */
-    status: InterpreterStatus;
-    _parent?: ActorRef<any>;
-    name: string;
-    ref: ActorRef<TEvent>;
-    /**
-     * The globally unique process ID for this invocation.
-     */
-    sessionId: string;
-    private forwardTo;
-    /**
-     * Creates a new Interpreter instance (i.e., service) for the given machine with the provided options, if any.
-     *
-     * @param machine The machine to be interpreted
-     * @param options Interpreter options
-     */
-    constructor(machine: StateMachine<TContext, TEvent, any, any, TResolvedTypesMeta>, options?: InterpreterOptions);
-    get initialized(): boolean;
-    get initialState(): State<TContext, TEvent, TResolvedTypesMeta>;
-    get state(): State<TContext, TEvent, TResolvedTypesMeta>;
-    /**
-     * Executes the actions of the given state, with that state's `context` and `event`.
-     *
-     * @param state The state whose actions will be executed
-     */
-    execute(state: State<TContext, TEvent, TResolvedTypesMeta>): void;
-    private update;
-    onTransition(listener: StateListener<TContext, TEvent, TResolvedTypesMeta>): this;
-    subscribe(observer: Observer<State<TContext, TEvent, TResolvedTypesMeta>>): Subscription;
-    subscribe(nextListener?: (state: State<TContext, TEvent, TResolvedTypesMeta>) => void, errorListener?: (error: any) => void, completeListener?: () => void): Subscription;
-    /**
-  
-     * Adds a listener that is notified when the machine is stopped.
-     *
-     * @param listener The listener
-     */
-    onStop(listener: Listener): this;
-    /**
-     * Adds an error listener that is notified with an `Error` whenever an
-     * error occurs during execution.
-     *
-     * @param listener The error listener
-     */
-    onError(listener: ErrorListener): this;
-    /**
-     * Adds a state listener that is notified when the statechart has reached its final state.
-     * @param listener The state listener
-     */
-    onDone(listener: EventListener<DoneEvent>): this;
-    /**
-     * Removes a listener.
-     * @param listener The listener to remove
-     */
-    off(listener: (...args: any[]) => void): this;
-    /**
-     * Starts the interpreter from the given state, or the initial state.
-     * @param initialState The state to start the statechart from
-     */
-    start(initialState?: State<TContext, TEvent, TResolvedTypesMeta> | StateValue): this;
-    private _process;
-    /**
-     * Stops the interpreter and unsubscribe all listeners.
-     *
-     * This will also notify the `onStop` listeners.
-     */
-    stop(): this;
-    /**
-     * Sends an event to the running interpreter to trigger a transition.
-     *
-     * An array of events (batched) can be sent as well, which will send all
-     * batched events to the running interpreter. The listeners will be
-     * notified only **once** when all events are processed.
-     *
-     * @param event The event(s) to send
-     */
-    send: PayloadSender<TEvent>;
-    private sendTo;
-    /**
-     * Returns the next state given the interpreter's current state and the event.
-     *
-     * This is a pure method that does _not_ update the interpreter's state.
-     *
-     * @param event The event to determine the next state
-     */
-    nextState(event: Event<TEvent> | SCXML.Event<TEvent>): State<TContext, TEvent, TResolvedTypesMeta>;
-    private forward;
-    private defer;
-    private cancel;
-    private getActionFunction;
-    private exec;
-    private stopChild;
-    private attachDevTools;
-    toJSON(): {
-        id: string;
-    };
-    [Symbol.observable](): InteropSubscribable<State<TContext, TEvent, TResolvedTypesMeta>>;
-    getSnapshot(): State<TContext, TEvent, TResolvedTypesMeta>;
-}
-/**
- * Creates a new Interpreter instance for the given machine with the provided options, if any.
- *
- * @param machine The machine to interpret
- * @param options Interpreter options
- */
-export declare function interpret<TMachine extends AnyStateMachine>(machine: AreAllImplementationsAssumedToBeProvided<TMachine['__TResolvedTypesMeta']> extends true ? TMachine : 'Some implementations missing', options?: InterpreterOptions): InterpreterFrom<TMachine>;
+import type { AnyStateMachine, EventFromBehavior, InterpreterFrom, PersistedStateFrom, SnapshotFrom, ActorSystem, AnyActorBehavior, RaiseActionObject } from './types.js';
+import { AreAllImplementationsAssumedToBeProvided } from './typegenTypes.js';
+import { ActorRef, DoneEvent, EventObject, InteropSubscribable, InterpreterOptions, Observer, SCXML, SendActionObject, Subscription } from './types.js';
+import { symbolObservable } from './symbolObservable.js';
+export type SnapshotListener<TBehavior extends AnyActorBehavior> = (state: SnapshotFrom<TBehavior>) => void;
+export type EventListener<TEvent extends EventObject = EventObject> = (event: TEvent) => void;
+export type Listener = () => void;
+export type ErrorListener = (error: any) => void;
+export interface Clock {
+    setTimeout(fn: (...args: any[]) => void, timeout: number): any;
+    clearTimeout(id: any): void;
+}
+export declare enum ActorStatus {
+    NotStarted = 0,
+    Running = 1,
+    Stopped = 2
+}
+export declare class Interpreter<TBehavior extends AnyActorBehavior, TEvent extends EventObject = EventFromBehavior<TBehavior>> implements ActorRef<TEvent, SnapshotFrom<TBehavior>> {
+    behavior: TBehavior;
+    /**
+     * The current state of the interpreted behavior.
+     */
+    private _state;
+    /**
+     * The clock that is responsible for setting and clearing timeouts, such as delayed events and transitions.
+     */
+    clock: Clock;
+    options: Readonly<InterpreterOptions<TBehavior>>;
+    /**
+     * The unique identifier for this actor relative to its parent.
+     */
+    id: string;
+    private mailbox;
+    private delayedEventsMap;
+    private observers;
+    private logger;
+    /**
+     * Whether the service is started.
+     */
+    status: ActorStatus;
+    _parent?: ActorRef<any>;
+    ref: ActorRef<TEvent>;
+    private _actorContext;
+    private _systemId;
+    /**
+     * The globally unique process ID for this invocation.
+     */
+    sessionId: string;
+    system: ActorSystem<any>;
+    private _doneEvent?;
+    src?: string;
+    /**
+     * Creates a new Interpreter instance (i.e., service) for the given behavior with the provided options, if any.
+     *
+     * @param behavior The behavior to be interpreted
+     * @param options Interpreter options
+     */
+    constructor(behavior: TBehavior, options?: InterpreterOptions<TBehavior>);
+    private _initState;
+    private _deferred;
+    private update;
+    subscribe(observer: Observer<SnapshotFrom<TBehavior>>): Subscription;
+    subscribe(nextListener?: (state: SnapshotFrom<TBehavior>) => void, errorListener?: (error: any) => void, completeListener?: () => void): Subscription;
+    /**
+     * Adds a state listener that is notified when the statechart has reached its final state.
+     * @param listener The state listener
+     */
+    onDone(listener: EventListener<DoneEvent>): this;
+    /**
+     * Starts the interpreter from the initial state
+     */
+    start(): this;
+    private _process;
+    private _stop;
+    /**
+     * Stops the interpreter and unsubscribe all listeners.
+     */
+    stop(): this;
+    private _complete;
+    private _stopProcedure;
+    /**
+     * Sends an event to the running interpreter to trigger a transition.
+     *
+     * @param event The event to send
+     */
+    send(event: TEvent | SCXML.Event<TEvent>): void;
+    delaySend(sendAction: SendActionObject | RaiseActionObject<any, any, any>): void;
+    cancel(sendId: string | number): void;
+    private attachDevTools;
+    toJSON(): {
+        id: string;
+    };
+    getPersistedState(): PersistedStateFrom<TBehavior> | undefined;
+    [Symbol.observable](): InteropSubscribable<SnapshotFrom<TBehavior>>;
+    getSnapshot(): SnapshotFrom<TBehavior>;
+}
+/**
+ * Creates a new Interpreter instance for the given machine with the provided options, if any.
+ *
+ * @param machine The machine to interpret
+ * @param options Interpreter options
+ */
+export declare function interpret<TMachine extends AnyStateMachine>(machine: AreAllImplementationsAssumedToBeProvided<TMachine['__TResolvedTypesMeta']> extends true ? TMachine : 'Some implementations missing', options?: InterpreterOptions<TMachine>): InterpreterFrom<TMachine>;
+export declare function interpret<TBehavior extends AnyActorBehavior>(behavior: TBehavior, options?: InterpreterOptions<TBehavior>): Interpreter<TBehavior>;

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

@@ -1,3 +1,3 @@
-export declare function mapState(stateMap: {
-    [stateId: string]: any;
-}, stateId: string): any;
+export declare function mapState(stateMap: {
+    [stateId: string]: any;
+}, stateId: string): any;

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

@@ -1 +1,2 @@
-export declare function memo<T>(object: any, key: string, fn: () => T): T;
+export declare function memo<T>(object: any, key: string, fn: () => T): T;
+export declare function evict(object: any, key?: string): void;

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

@@ -1,2 +1,2 @@
-export declare function createSchema<T>(schema?: any): T;
-export declare const t: typeof createSchema;
+export declare function createSchema<T>(schema?: any): T;
+export declare const t: typeof createSchema;