xstate 5.0.0-alpha.0 → 5.0.0-alpha.1

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

@@ -1,38 +1,37 @@
-import type { InvokeCallback, Subscribable, InterpreterOptions, Lazy, Behavior, ActorContext, EventObject, ActorRef, AnyStateMachine, BaseActorRef, EventFrom, StateFrom } from './types';
-import { AreAllImplementationsAssumedToBeProvided } from './typegenTypes';
-/**
- * Returns an actor behavior from a reducer and its initial state.
- *
- * @param transition The pure reducer that returns the next state given the current state and event.
- * @param initialState The initial state of the reducer.
- * @returns An actor behavior
- */
-export declare function fromReducer<TState, TEvent extends EventObject>(transition: (state: TState, event: TEvent, actorContext: ActorContext<TEvent, TState>) => TState, initialState: TState): Behavior<TEvent, TState>;
-export declare const startSignalType: unique symbol;
-export declare const stopSignalType: unique symbol;
-export declare const startSignal: StartSignal;
-export declare const stopSignal: StopSignal;
-export interface StartSignal {
-    type: typeof startSignalType;
-}
-export interface StopSignal {
-    type: typeof stopSignalType;
-}
-export declare type LifecycleSignal = StartSignal | StopSignal;
-export declare function fromCallback<TEvent extends EventObject>(invokeCallback: InvokeCallback): Behavior<TEvent, undefined>;
-export declare function fromPromise<T>(lazyPromise: Lazy<PromiseLike<T>>): Behavior<{
-    type: string;
-}, T | undefined>;
-export declare function fromObservable<T, TEvent extends EventObject>(lazyObservable: Lazy<Subscribable<T>>): Behavior<TEvent, T | undefined>;
-/**
- * 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: Lazy<Subscribable<T>>): Behavior<EventObject, T | undefined>;
-export declare function fromMachine<TMachine extends AnyStateMachine>(machine: AreAllImplementationsAssumedToBeProvided<TMachine['__TResolvedTypesMeta']> extends true ? TMachine : 'Some implementations missing', options?: Partial<InterpreterOptions>): Behavior<EventFrom<TMachine>, StateFrom<TMachine>>;
-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>>;
+import type { InvokeCallback, Subscribable, Lazy, Behavior, ActorContext, EventObject, ActorRef, BaseActorRef } from './types';
+/**
+ * Returns an actor behavior from a reducer and its initial state.
+ *
+ * @param transition The pure reducer that returns the next state given the current state and event.
+ * @param initialState The initial state of the reducer.
+ * @returns An actor behavior
+ */
+export declare function fromReducer<TState, TEvent extends EventObject>(transition: (state: TState, event: TEvent, actorContext: ActorContext<TEvent, TState>) => TState, initialState: TState): Behavior<TEvent, TState>;
+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 declare type LifecycleSignal = StartSignal | StopSignal;
+export declare type LifecycleSignalType = typeof startSignalType | typeof stopSignalType;
+export declare function fromCallback<TEvent extends EventObject>(invokeCallback: InvokeCallback): Behavior<TEvent, undefined>;
+export declare function fromPromise<T>(lazyPromise: Lazy<PromiseLike<T>>): Behavior<{
+    type: string;
+}, T | undefined>;
+export declare function fromObservable<T, TEvent extends EventObject>(lazyObservable: Lazy<Subscribable<T>>): Behavior<TEvent, T | undefined>;
+/**
+ * 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: Lazy<Subscribable<T>>): Behavior<EventObject, T | undefined>;
+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/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';
+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 {};

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';
+import type { State } from './State';
+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';
+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, ActorStatus } from './interpreter';
+import { createMachine } from './Machine';
+import { mapState } from './mapState';
+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 * from './typegenTypes';
+export * from './types';
+export { matchesState, pathToStateValue, toObserver, toSCXMLEvent } from './utils';
+export { StateNode, State, mapState, actions, assign, send, 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,108 @@
-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 { AnyActorRef, AnyStateMachine, Behavior, EventFromBehavior, InterpreterFrom, SnapshotFrom } from './types';
+import { AreAllImplementationsAssumedToBeProvided } from './typegenTypes';
+import { ActorRef, DoneEvent, EventObject, InteropSubscribable, InterpreterOptions, Observer, SCXML, SendActionObject, StateValue, Subscription } from './types';
+import { symbolObservable } from './symbolObservable';
+export declare type SnapshotListener<TBehavior extends Behavior<any, any>> = (state: SnapshotFrom<TBehavior>) => 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 ActorStatus {
+    NotStarted = 0,
+    Running = 1,
+    Stopped = 2
+}
+declare type InternalStateFrom<TBehavior extends Behavior<any, any, any>> = TBehavior extends Behavior<infer _, infer __, infer TInternalState> ? TInternalState : never;
+export declare class Interpreter<TBehavior extends Behavior<any, any>, 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>;
+    /**
+     * 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;
+    /**
+     * The globally unique process ID for this invocation.
+     */
+    sessionId: string;
+    _forwardTo: Set<AnyActorRef>;
+    /**
+     * 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);
+    private _deferred;
+    private _getInitialState;
+    private update;
+    onTransition(listener: SnapshotListener<TBehavior>): this;
+    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 given state, or the initial state.
+     * @param initialState The state to start the statechart from
+     */
+    start(initialState?: InternalStateFrom<TBehavior> | StateValue): this;
+    private _process;
+    /**
+     * Stops the interpreter and unsubscribe all listeners.
+     */
+    stop(): this;
+    private _complete;
+    private _stop;
+    /**
+     * 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(event: TEvent | SCXML.Event<TEvent>): void;
+    private forward;
+    delaySend(sendAction: SendActionObject): void;
+    cancel(sendId: string | number): void;
+    private attachDevTools;
+    toJSON(): {
+        id: string;
+    };
+    [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): InterpreterFrom<TMachine>;
+export declare function interpret<TBehavior extends Behavior<any, any>>(behavior: TBehavior, options?: InterpreterOptions): Interpreter<TBehavior>;
+export {};

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/registry.d.ts

@@ -1,8 +1,8 @@
-import { ActorRef } from './types';
-export interface Registry {
-    bookId(): string;
-    register(id: string, actor: ActorRef<any>): string;
-    get(id: string): ActorRef<any> | undefined;
-    free(id: string): void;
-}
-export declare const registry: Registry;
+import { ActorRef } from './types';
+export interface Registry {
+    bookId(): string;
+    register(id: string, actor: ActorRef<any>): string;
+    get(id: string): ActorRef<any> | undefined;
+    free(id: string): void;
+}
+export declare const registry: Registry;

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;

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

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