xstate 4.26.0-pr2674-202191175724 → 4.26.0

package/es/interpreter.d.ts

@@ -1,10 +1,9 @@
 import { StateMachine, Event, EventObject, DefaultContext, StateSchema, StateValue, InterpreterOptions, SingleOrArray, Subscribable, DoneEvent, MachineOptions, SCXML, EventData, Observer, Spawnable, Typestate, ActorRef, ActorRefFrom, Behavior, Subscription } from './types';
 import { State } from './State';
-import { AreAllImplementationsAssumedToBeProvided, TypegenDisabled } from './typegenTypes';
 export declare type StateListener<TContext, TEvent extends EventObject, TStateSchema extends StateSchema<TContext> = any, TTypestate extends Typestate<TContext> = {
     value: any;
     context: TContext;
-}, TResolvedTypesMeta = TypegenDisabled> = (state: State<TContext, TEvent, TStateSchema, TTypestate, TResolvedTypesMeta>, event: TEvent) => void;
+}> = (state: State<TContext, TEvent, TStateSchema, TTypestate>, event: TEvent) => void;
 export declare type ContextListener<TContext = DefaultContext> = (context: TContext, prevContext: TContext | undefined) => void;
 export declare type EventListener<TEvent extends EventObject = EventObject> = (event: TEvent) => void;
 export declare type Listener = () => void;
@@ -30,24 +29,15 @@ declare global {
 export declare class Interpreter<TContext, TStateSchema extends StateSchema = any, TEvent extends EventObject = EventObject, TTypestate extends Typestate<TContext> = {
     value: any;
     context: TContext;
-}, TResolvedTypesMeta = TypegenDisabled> implements ActorRef<TEvent, State<TContext, TEvent, TStateSchema, TTypestate, TResolvedTypesMeta>> {
-    machine: StateMachine<TContext, TStateSchema, TEvent, TTypestate, any, TResolvedTypesMeta>;
+}> implements ActorRef<TEvent, State<TContext, TEvent, TStateSchema, TTypestate>> {
+    machine: StateMachine<TContext, TStateSchema, TEvent, TTypestate>;
     /**
      * The default interpreter options:
      *
      * - `clock` uses the global `setTimeout` and `clearTimeout` functions
      * - `logger` uses the global `console.log()` method
      */
-    static defaultOptions: {
-        execute: boolean;
-        deferEvents: boolean;
-        clock: {
-            setTimeout: (fn: any, ms: any) => number;
-            clearTimeout: (id: any) => void;
-        };
-        logger: any;
-        devTools: boolean;
-    };
+    static defaultOptions: InterpreterOptions;
     /**
      * The current state of the interpreted machine.
      */
@@ -87,9 +77,9 @@ export declare class Interpreter<TContext, TStateSchema extends StateSchema = an
      * @param machine The machine to be interpreted
      * @param options Interpreter options
      */
-    constructor(machine: StateMachine<TContext, TStateSchema, TEvent, TTypestate, any, TResolvedTypesMeta>, options?: InterpreterOptions);
-    get initialState(): State<TContext, TEvent, TStateSchema, TTypestate, TResolvedTypesMeta>;
-    get state(): State<TContext, TEvent, TStateSchema, TTypestate, TResolvedTypesMeta>;
+    constructor(machine: StateMachine<TContext, TStateSchema, TEvent, TTypestate>, options?: Partial<InterpreterOptions>);
+    get initialState(): State<TContext, TEvent, TStateSchema, TTypestate>;
+    get state(): State<TContext, TEvent, TStateSchema, TTypestate>;
     static interpret: typeof interpret;
     /**
      * Executes the actions of the given state, with that state's `context` and `event`.
@@ -97,56 +87,56 @@ export declare class Interpreter<TContext, TStateSchema extends StateSchema = an
      * @param state The state whose actions will be executed
      * @param actionsConfig The action implementations to use
      */
-    execute(state: State<TContext, TEvent, TStateSchema, TTypestate, TResolvedTypesMeta>, actionsConfig?: MachineOptions<TContext, TEvent>['actions']): void;
+    execute(state: State<TContext, TEvent, TStateSchema, TTypestate>, actionsConfig?: MachineOptions<TContext, TEvent>['actions']): void;
     private update;
-    onTransition(listener: StateListener<TContext, TEvent, TStateSchema, TTypestate, TResolvedTypesMeta>): this;
-    subscribe(nextListener?: (state: State<TContext, TEvent, any, TTypestate, TResolvedTypesMeta>) => void, errorListener?: (error: any) => void, completeListener?: () => void): Subscription;
-    subscribe(observer: Observer<State<TContext, TEvent, any, TTypestate, TResolvedTypesMeta>>): Subscription;
+    onTransition(listener: StateListener<TContext, TEvent, TStateSchema, TTypestate>): this;
+    subscribe(nextListener?: (state: State<TContext, TEvent, any, TTypestate>) => void, errorListener?: (error: any) => void, completeListener?: () => void): Subscription;
+    subscribe(observer: Observer<State<TContext, TEvent, any, TTypestate>>): Subscription;
     /**
      * Adds an event listener that is notified whenever an event is sent to the running interpreter.
      * @param listener The event listener
      */
-    onEvent(listener: EventListener): this;
+    onEvent(listener: EventListener): Interpreter<TContext, TStateSchema, TEvent, TTypestate>;
     /**
      * Adds an event listener that is notified whenever a `send` event occurs.
      * @param listener The event listener
      */
-    onSend(listener: EventListener): this;
+    onSend(listener: EventListener): Interpreter<TContext, TStateSchema, TEvent, TTypestate>;
     /**
      * Adds a context listener that is notified whenever the state context changes.
      * @param listener The context listener
      */
-    onChange(listener: ContextListener<TContext>): this;
+    onChange(listener: ContextListener<TContext>): Interpreter<TContext, TStateSchema, TEvent, TTypestate>;
     /**
      * Adds a listener that is notified when the machine is stopped.
      * @param listener The listener
      */
-    onStop(listener: Listener): this;
+    onStop(listener: Listener): Interpreter<TContext, TStateSchema, TEvent, TTypestate>;
     /**
      * 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;
+    onDone(listener: EventListener<DoneEvent>): Interpreter<TContext, TStateSchema, TEvent, TTypestate>;
     /**
      * Removes a listener.
      * @param listener The listener to remove
      */
-    off(listener: (...args: any[]) => void): this;
+    off(listener: (...args: any[]) => void): Interpreter<TContext, TStateSchema, TEvent, TTypestate>;
     /**
      * Alias for Interpreter.prototype.start
      */
-    init: (initialState?: StateValue | State<TContext, TEvent, TStateSchema, TTypestate, TResolvedTypesMeta> | undefined) => this;
+    init: (initialState?: StateValue | State<TContext, TEvent, TStateSchema, TTypestate> | undefined) => Interpreter<TContext, TStateSchema, TEvent, TTypestate>;
     /**
      * 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, TStateSchema, TTypestate, TResolvedTypesMeta> | StateValue): this;
+    start(initialState?: State<TContext, TEvent, TStateSchema, TTypestate> | StateValue): Interpreter<TContext, TStateSchema, TEvent, TTypestate>;
     /**
      * Stops the interpreter and unsubscribe all listeners.
      *
      * This will also notify the `onStop` listeners.
      */
-    stop(): this;
+    stop(): Interpreter<TContext, TStateSchema, TEvent, TTypestate>;
     /**
      * Sends an event to the running interpreter to trigger a transition.
      *
@@ -156,7 +146,7 @@ export declare class Interpreter<TContext, TStateSchema extends StateSchema = an
      *
      * @param event The event(s) to send
      */
-    send: (event: SingleOrArray<Event<TEvent>> | SCXML.Event<TEvent>, payload?: EventData | undefined) => State<TContext, TEvent, TStateSchema, TTypestate, TResolvedTypesMeta>;
+    send: (event: SingleOrArray<Event<TEvent>> | SCXML.Event<TEvent>, payload?: EventData | undefined) => State<TContext, TEvent, TStateSchema, TTypestate>;
     private batch;
     /**
      * Returns a send function bound to this interpreter instance.
@@ -172,7 +162,7 @@ export declare class Interpreter<TContext, TStateSchema extends StateSchema = an
      *
      * @param event The event to determine the next state
      */
-    nextState(event: Event<TEvent> | SCXML.Event<TEvent>): State<TContext, TEvent, TStateSchema, TTypestate, TResolvedTypesMeta>;
+    nextState(event: Event<TEvent> | SCXML.Event<TEvent>): State<TContext, TEvent, TStateSchema, TTypestate>;
     private forward;
     private defer;
     private cancel;
@@ -196,8 +186,8 @@ export declare class Interpreter<TContext, TStateSchema extends StateSchema = an
     toJSON(): {
         id: string;
     };
-    [Symbol.observable](): Subscribable<State<TContext, TEvent, TStateSchema, TTypestate, TResolvedTypesMeta>>;
-    getSnapshot(): State<TContext, TEvent, TStateSchema, TTypestate, TResolvedTypesMeta>;
+    [Symbol.observable](): Subscribable<State<TContext, TEvent, TStateSchema, TTypestate>>;
+    getSnapshot(): State<TContext, TEvent, TStateSchema, TTypestate>;
 }
 export declare function spawn<T extends Behavior<any, any>>(entity: T, nameOrOptions?: string | SpawnOptions): ActorRefFrom<T>;
 export declare function spawn<TC, TE extends EventObject>(entity: StateMachine<TC, any, TE>, nameOrOptions?: string | SpawnOptions): ActorRefFrom<StateMachine<TC, any, TE>>;
@@ -211,6 +201,6 @@ export declare function spawn(entity: Spawnable, nameOrOptions?: string | SpawnO
 export declare function interpret<TContext = DefaultContext, TStateSchema extends StateSchema = any, TEvent extends EventObject = EventObject, TTypestate extends Typestate<TContext> = {
     value: any;
     context: TContext;
-}, TResolvedTypesMeta = TypegenDisabled>(machine: AreAllImplementationsAssumedToBeProvided<TResolvedTypesMeta> extends true ? StateMachine<TContext, TStateSchema, TEvent, TTypestate, any, TResolvedTypesMeta> : 'Some implementations missing', options?: InterpreterOptions): Interpreter<TContext, TStateSchema, TEvent, TTypestate, TResolvedTypesMeta>;
+}>(machine: StateMachine<TContext, TStateSchema, TEvent, TTypestate>, options?: Partial<InterpreterOptions>): Interpreter<TContext, TStateSchema, TEvent, TTypestate>;
 export {};
 //# sourceMappingURL=interpreter.d.ts.map

package/es/interpreter.js

@@ -840,7 +840,8 @@ function () {
 
             var source = isFunction(serviceCreator) ? serviceCreator(context, _event.data, {
               data: resolvedData,
-              src: invokeSource
+              src: invokeSource,
+              meta: activity.meta
             }) : serviceCreator;
 
             if (!source) {

package/es/model.d.ts

@@ -1,5 +1,5 @@
-import type { Cast, EventObject, BaseActionObject, Prop, IsNever } from './types';
-import { UnionFromCreatorsReturnTypes, FinalModelCreators, Model, ModelCreators } from './model.types';
+import type { EventObject, BaseActionObject } from './types';
+import { Cast, UnionFromCreatorsReturnTypes, FinalModelCreators, Model, ModelCreators, Prop, IsNever } from './model.types';
 export declare function createModel<TContext, TEvent extends EventObject, TAction extends BaseActionObject = BaseActionObject>(initialContext: TContext): Model<TContext, TEvent, TAction, void>;
 export declare function createModel<TContext, TModelCreators extends ModelCreators<TModelCreators>, TFinalModelCreators = FinalModelCreators<TModelCreators>, TComputedEvent = UnionFromCreatorsReturnTypes<Prop<TFinalModelCreators, 'events'>>, TComputedAction = UnionFromCreatorsReturnTypes<Prop<TFinalModelCreators, 'actions'>>>(initialContext: TContext, creators: TModelCreators): Model<TContext, Cast<TComputedEvent, EventObject>, IsNever<TComputedAction> extends true ? BaseActionObject : Cast<TComputedAction, BaseActionObject>, TFinalModelCreators>;
 //# sourceMappingURL=model.d.ts.map

package/es/model.types.d.ts

@@ -1,17 +1,18 @@
-import { AnyFunction, AssignAction, Assigner, BaseActionObject, Compute, EventObject, ExtractEvent, MachineConfig, Prop, PropertyAssigner, StateMachine } from './types';
-import { MaybeTypegenMachineOptions, ResolveTypegenMeta, TypegenConstraint, TypegenDisabled } from './typegenTypes';
+import { EventObject, Assigner, ExtractEvent, PropertyAssigner, AssignAction, MachineConfig, MachineOptions, StateMachine, BaseActionObject } from './types';
+export declare type AnyFunction = (...args: any[]) => any;
+export declare type IsNever<T> = [T] extends [never] ? true : false;
+export declare type Cast<T extends any, TCastType extends any> = T extends TCastType ? T : TCastType;
+export declare type Compute<A extends any> = {
+    [K in keyof A]: A[K];
+} & unknown;
+export declare type Prop<T, K> = K extends keyof T ? T[K] : never;
 export interface Model<TContext, TEvent extends EventObject, TAction extends BaseActionObject = BaseActionObject, TModelCreators = void> {
     initialContext: TContext;
     assign: <TEventType extends TEvent['type'] = TEvent['type']>(assigner: Assigner<TContext, ExtractEvent<TEvent, TEventType>> | PropertyAssigner<TContext, ExtractEvent<TEvent, TEventType>>, eventType?: TEventType) => AssignAction<TContext, ExtractEvent<TEvent, TEventType>>;
     events: Prop<TModelCreators, 'events'>;
     actions: Prop<TModelCreators, 'actions'>;
     reset: () => AssignAction<TContext, any>;
-    createMachine: {
-        <TTypesMeta extends TypegenConstraint = TypegenDisabled>(config: MachineConfig<TContext, any, TEvent, TAction, TTypesMeta>, implementations?: MaybeTypegenMachineOptions<TContext, TEvent, TAction, ResolveTypegenMeta<TTypesMeta, TEvent, TAction>>): StateMachine<TContext, any, TEvent, {
-            value: any;
-            context: TContext;
-        }, TAction, ResolveTypegenMeta<TTypesMeta, TEvent, TAction>>;
-    };
+    createMachine: (config: MachineConfig<TContext, any, TEvent, TAction>, implementations?: Partial<MachineOptions<TContext, TEvent, TAction>>) => StateMachine<TContext, any, TEvent>;
 }
 export declare type ModelContextFrom<TModel extends Model<any, any, any, any>> = TModel extends Model<infer TContext, any, any, any> ? TContext : never;
 export declare type ModelEventsFrom<TModel extends Model<any, any, any, any> | undefined> = TModel extends Model<any, infer TEvent, any, any> ? TEvent : EventObject;

package/es/scxml.d.ts

@@ -1,6 +1,6 @@
-import { StateMachine } from './index';
+import { StateNode } from './index';
 export interface ScxmlToMachineOptions {
     delimiter?: string;
 }
-export declare function toMachine(xml: string, options: ScxmlToMachineOptions): StateMachine<any, any, any>;
+export declare function toMachine(xml: string, options: ScxmlToMachineOptions): StateNode;
 //# sourceMappingURL=scxml.d.ts.map

package/es/stateUtils.d.ts

@@ -1,16 +1,16 @@
-import { EventObject, StateValue } from './types';
-import { StateNode } from './StateNode';
+import { EventObject, StateNode, StateValue } from '.';
 declare type Configuration<TC, TE extends EventObject> = Iterable<StateNode<TC, any, TE>>;
 declare type AdjList<TC, TE extends EventObject> = Map<StateNode<TC, any, TE>, Array<StateNode<TC, any, TE>>>;
-export declare const isLeafNode: (stateNode: StateNode<any, any, any, any, any>) => boolean;
+export declare const isLeafNode: (stateNode: StateNode<any, any, any, any>) => boolean;
 export declare function getChildren<TC, TE extends EventObject>(stateNode: StateNode<TC, any, TE>): Array<StateNode<TC, any, TE>>;
-export declare function getAllStateNodes<TC, TE extends EventObject>(stateNode: StateNode<TC, any, TE, any, any>): Array<StateNode<TC, any, TE, any, any>>;
-export declare function getConfiguration<TC, TE extends EventObject>(prevStateNodes: Iterable<StateNode<TC, any, TE, any, any>>, stateNodes: Iterable<StateNode<TC, any, TE, any, any>>): Iterable<StateNode<TC, any, TE, any, any>>;
+export declare function getAllStateNodes<TC, TE extends EventObject>(stateNode: StateNode<TC, any, TE, any>): Array<StateNode<TC, any, TE, any>>;
+export declare function getConfiguration<TC, TE extends EventObject>(prevStateNodes: Iterable<StateNode<TC, any, TE, any>>, stateNodes: Iterable<StateNode<TC, any, TE, any>>): Iterable<StateNode<TC, any, TE, any>>;
 export declare function getAdjList<TC, TE extends EventObject>(configuration: Configuration<TC, TE>): AdjList<TC, TE>;
 export declare function getValue<TC, TE extends EventObject>(rootNode: StateNode<TC, any, TE, any>, configuration: Configuration<TC, TE>): StateValue;
 export declare function has<T>(iterable: Iterable<T>, item: T): boolean;
 export declare function nextEvents<TC, TE extends EventObject>(configuration: Array<StateNode<TC, any, TE>>): Array<TE['type']>;
-export declare function isInFinalState<TC, TE extends EventObject>(configuration: Array<StateNode<TC, any, TE, any, any>>, stateNode: StateNode<TC, any, TE, any, any>): boolean;
+export declare function isInFinalState<TC, TE extends EventObject>(configuration: Array<StateNode<TC, any, TE, any>>, stateNode: StateNode<TC, any, TE, any>): boolean;
 export declare function getMeta(configuration?: StateNode[]): Record<string, any>;
+export declare function getTagsFromConfiguration(configuration: StateNode<any, any, any, any>[]): Set<string>;
 export {};
 //# sourceMappingURL=stateUtils.d.ts.map

package/es/stateUtils.js

@@ -1,5 +1,5 @@
 import { __values, __spreadArray, __read } from './_virtual/_tslib.js';
-import { keys, flatten } from './utils.js';
+import { flatten, keys } from './utils.js';
 
 var isLeafNode = function (stateNode) {
   return stateNode.type === 'atomic' || stateNode.type === 'final';
@@ -252,5 +252,10 @@ function getMeta(configuration) {
     return acc;
   }, {});
 }
+function getTagsFromConfiguration(configuration) {
+  return new Set(flatten(configuration.map(function (sn) {
+    return sn.tags;
+  })));
+}
 
-export { getAdjList, getAllStateNodes, getChildren, getConfiguration, getMeta, getValue, has, isInFinalState, isLeafNode, nextEvents };
+export { getAdjList, getAllStateNodes, getChildren, getConfiguration, getMeta, getTagsFromConfiguration, getValue, has, isInFinalState, isLeafNode, nextEvents };

package/es/types.d.ts

@@ -1,25 +1,9 @@
-import { Clock, Interpreter } from './interpreter';
-import { Model } from './model.types';
-import { State } from './State';
 import { StateNode } from './StateNode';
-import { MarkAllImplementationsAsProvided, MaybeTypegenMachineOptions, TypegenDisabled } from './typegenTypes';
-export declare type AnyFunction = (...args: any[]) => any;
+import { State } from './State';
+import { Interpreter, Clock } from './interpreter';
+import { IsNever, Model, Prop } from './model.types';
+declare type AnyFunction = (...args: any[]) => any;
 declare type ReturnTypeOrValue<T> = T extends AnyFunction ? ReturnType<T> : T;
-export declare type IsNever<T> = [T] extends [never] ? true : false;
-export declare type Cast<T extends any, TCastType extends any> = T extends TCastType ? T : TCastType;
-export declare type Compute<A extends any> = {
-    [K in keyof A]: A[K];
-} & unknown;
-export declare type Prop<T, K> = K extends keyof T ? T[K] : never;
-export declare type Values<T> = T[keyof T];
-export declare type Merge<M, N> = Omit<M, keyof N> & N;
-export declare type IndexByType<T extends {
-    type: string;
-}> = {
-    [K in T['type']]: Extract<T, {
-        type: K;
-    }>;
-};
 export declare type EventType = string;
 export declare type ActionType = string;
 export declare type MetaObject = Record<string, any>;
@@ -60,7 +44,7 @@ export declare type EventData = Record<string, any> & {
  * The specified string event types or the specified event objects.
  */
 export declare type Event<TEvent extends EventObject> = TEvent['type'] | TEvent;
-export interface ActionMeta<TContext, TEvent extends EventObject, TAction extends BaseActionObject = BaseActionObject> extends StateMeta<TContext, TEvent> {
+export interface ActionMeta<TContext, TEvent extends EventObject, TAction extends ActionObject<TContext, TEvent> = ActionObject<TContext, TEvent>> extends StateMeta<TContext, TEvent> {
     action: TAction;
     _event: SCXML.Event<TEvent>;
 }
@@ -69,8 +53,8 @@ export interface AssignMeta<TContext, TEvent extends EventObject> {
     action: AssignAction<TContext, TEvent>;
     _event: SCXML.Event<TEvent>;
 }
-export declare type ActionFunction<TContext, TEvent extends EventObject, TAction extends BaseActionObject = BaseActionObject> = (context: TContext, event: TEvent, meta: ActionMeta<TContext, TEvent, TAction>) => void;
-export interface ChooseConditon<TContext, TEvent extends EventObject> {
+export declare type ActionFunction<TContext, TEvent extends EventObject, TAction extends ActionObject<TContext, TEvent> = ActionObject<TContext, TEvent>> = (context: TContext, event: TEvent, meta: ActionMeta<TContext, TEvent, TAction>) => void;
+export interface ChooseCondition<TContext, TEvent extends EventObject> {
     cond?: Condition<TContext, TEvent>;
     actions: Actions<TContext, TEvent>;
 }
@@ -174,6 +158,7 @@ export declare type InvokeCallback<TEvent extends EventObject = AnyEventObject,
 export interface InvokeMeta {
     data: any;
     src: InvokeSourceDefinition;
+    meta?: MetaObject;
 }
 /**
  * Returns either a Promises or a callback handler (for streams of events) given the
@@ -213,6 +198,7 @@ export interface InvokeDefinition<TContext, TEvent extends EventObject> extends
      * Data should be mapped to match the child machine's context shape.
      */
     data?: Mapper<TContext, TEvent, any> | PropertyMapper<TContext, TEvent, any>;
+    meta?: MetaObject;
 }
 export interface Delay {
     id: string;
@@ -295,6 +281,10 @@ export interface InvokeConfig<TContext, TEvent extends EventObject> {
      * The transition to take upon the invoked child machine sending an error event.
      */
     onError?: string | SingleOrArray<TransitionConfig<TContext, DoneInvokeEvent<any>>>;
+    /**
+     * Meta data related to this invocation
+     */
+    meta?: MetaObject;
 }
 export interface StateNodeConfig<TContext, TStateSchema extends StateSchema, TEvent extends EventObject, TAction extends BaseActionObject = BaseActionObject> {
     /**
@@ -450,6 +440,7 @@ export interface StateNodeDefinition<TContext, TStateSchema extends StateSchema,
     data?: FinalStateNodeConfig<TContext, TEvent>['data'];
     invoke: Array<InvokeDefinition<TContext, TEvent>>;
     description?: string;
+    tags: string[];
 }
 export declare type AnyStateNodeDefinition = StateNodeDefinition<any, any, any>;
 export interface AtomicStateNodeConfig<TContext, TEvent extends EventObject> extends StateNodeConfig<TContext, StateSchema, TEvent> {
@@ -471,7 +462,7 @@ export interface FinalStateNodeConfig<TContext, TEvent extends EventObject> exte
     data?: Mapper<TContext, TEvent, any> | PropertyMapper<TContext, TEvent, any>;
 }
 export declare type SimpleOrStateNodeConfig<TContext, TStateSchema extends StateSchema, TEvent extends EventObject> = AtomicStateNodeConfig<TContext, TEvent> | StateNodeConfig<TContext, TStateSchema, TEvent>;
-export declare type ActionFunctionMap<TContext, TEvent extends EventObject, TAction extends BaseActionObject = BaseActionObject> = {
+export declare type ActionFunctionMap<TContext, TEvent extends EventObject, TAction extends ActionObject<TContext, TEvent> = ActionObject<TContext, TEvent>> = {
     [K in TAction['type']]?: ActionObject<TContext, TEvent> | ActionFunction<TContext, TEvent, TAction extends {
         type: K;
     } ? TAction : never>;
@@ -479,25 +470,25 @@ export declare type ActionFunctionMap<TContext, TEvent extends EventObject, TAct
 export declare type DelayFunctionMap<TContext, TEvent extends EventObject> = Record<string, DelayConfig<TContext, TEvent>>;
 export declare type ServiceConfig<TContext, TEvent extends EventObject = AnyEventObject> = string | StateMachine<any, any, any> | InvokeCreator<TContext, TEvent>;
 export declare type DelayConfig<TContext, TEvent extends EventObject> = number | DelayExpr<TContext, TEvent>;
-export interface MachineOptions<TContext, TEvent extends EventObject, TAction extends BaseActionObject = BaseActionObject> {
-    guards?: Record<string, ConditionPredicate<TContext, TEvent>>;
-    actions?: ActionFunctionMap<TContext, TEvent, TAction>;
+export interface MachineOptions<TContext, TEvent extends EventObject, TAction extends ActionObject<TContext, TEvent> = ActionObject<TContext, TEvent>> {
+    guards: Record<string, ConditionPredicate<TContext, TEvent>>;
+    actions: ActionFunctionMap<TContext, TEvent, TAction>;
     /**
      * @deprecated Use `services` instead.
      */
-    activities?: Record<string, ActivityConfig<TContext, TEvent>>;
-    services?: Record<string, ServiceConfig<TContext, TEvent>>;
-    delays?: DelayFunctionMap<TContext, TEvent>;
+    activities: Record<string, ActivityConfig<TContext, TEvent>>;
+    services: Record<string, ServiceConfig<TContext, TEvent>>;
+    delays: DelayFunctionMap<TContext, TEvent>;
     /**
      * @private
      */
-    _parent?: StateNode<TContext, any, TEvent, any, any>;
+    _parent?: StateNode<TContext, any, TEvent, any>;
     /**
      * @private
      */
     _key?: string;
 }
-export interface MachineConfig<TContext, TStateSchema extends StateSchema, TEvent extends EventObject, TAction extends BaseActionObject = BaseActionObject, TTypesMeta = TypegenDisabled> extends StateNodeConfig<TContext, TStateSchema, TEvent, TAction> {
+export interface MachineConfig<TContext, TStateSchema extends StateSchema, TEvent extends EventObject, TAction extends BaseActionObject = ActionObject<TContext, TEvent>> extends StateNodeConfig<TContext, TStateSchema, TEvent, TAction> {
     /**
      * The initial context (extended state)
      */
@@ -507,7 +498,6 @@ export interface MachineConfig<TContext, TStateSchema extends StateSchema, TEven
      */
     version?: string;
     schema?: MachineSchema<TContext, TEvent>;
-    tsTypes?: TTypesMeta | true;
 }
 export interface MachineSchema<TContext, TEvent extends EventObject> {
     context?: TContext;
@@ -542,13 +532,13 @@ export interface HistoryStateNode<TContext> extends StateNode<TContext> {
 export interface StateMachine<TContext, TStateSchema extends StateSchema, TEvent extends EventObject, TTypestate extends Typestate<TContext> = {
     value: any;
     context: TContext;
-}, TAction extends BaseActionObject = BaseActionObject, TResolvedTypesMeta = TypegenDisabled> extends StateNode<TContext, TStateSchema, TEvent, TTypestate, TResolvedTypesMeta> {
+}, _TAction extends ActionObject<TContext, TEvent> = ActionObject<TContext, TEvent>> extends StateNode<TContext, TStateSchema, TEvent, TTypestate> {
     id: string;
-    states: StateNode<TContext, TStateSchema, TEvent, TTypestate, TResolvedTypesMeta>['states'];
-    withConfig(options: MaybeTypegenMachineOptions<TContext, TEvent, TAction, TResolvedTypesMeta, true>, context?: TContext | (() => TContext)): StateMachine<TContext, TStateSchema, TEvent, TTypestate, TAction, MarkAllImplementationsAsProvided<TResolvedTypesMeta>>;
-    withContext(context: TContext | (() => TContext)): StateMachine<TContext, TStateSchema, TEvent, TTypestate, any, TResolvedTypesMeta>;
+    states: StateNode<TContext, TStateSchema, TEvent>['states'];
+    withConfig(options: Partial<MachineOptions<TContext, TEvent>>, context?: TContext | (() => TContext)): StateMachine<TContext, TStateSchema, TEvent, TTypestate>;
+    withContext(context: TContext | (() => TContext)): StateMachine<TContext, TStateSchema, TEvent, TTypestate>;
 }
-export declare type StateFrom<T extends StateMachine<any, any, any, any, any, any> | ((...args: any[]) => StateMachine<any, any, any, any, any, any>)> = T extends StateMachine<any, any, any, any, any, any> ? ReturnType<T['transition']> : T extends (...args: any[]) => StateMachine<any, any, any, any, any, any> ? ReturnType<ReturnType<T>['transition']> : never;
+export declare type StateFrom<T extends StateMachine<any, any, any, any> | ((...args: any[]) => StateMachine<any, any, any, any>)> = T extends StateMachine<any, any, any> ? ReturnType<T['transition']> : T extends (...args: any[]) => StateMachine<any, any, any> ? ReturnType<ReturnType<T>['transition']> : never;
 export interface ActionMap<TContext, TEvent extends EventObject> {
     onEntry: Array<Action<TContext, TEvent>>;
     actions: Array<Action<TContext, TEvent>>;
@@ -567,13 +557,13 @@ export interface ActivityMap {
 }
 export interface StateTransition<TContext, TEvent extends EventObject> {
     transitions: Array<TransitionDefinition<TContext, TEvent>>;
-    configuration: Array<StateNode<TContext, any, TEvent, any, any>>;
-    entrySet: Array<StateNode<TContext, any, TEvent, any, any>>;
-    exitSet: Array<StateNode<TContext, any, TEvent, any, any>>;
+    configuration: Array<StateNode<TContext, any, TEvent, any>>;
+    entrySet: Array<StateNode<TContext, any, TEvent, any>>;
+    exitSet: Array<StateNode<TContext, any, TEvent, any>>;
     /**
      * The source state that preceded the transition.
      */
-    source: State<TContext, any, any, any, any> | undefined;
+    source: State<TContext, any, any, any> | undefined;
     actions: Array<ActionObject<TContext, TEvent>>;
 }
 export interface TransitionData<TContext, TEvent extends EventObject> {
@@ -716,7 +706,7 @@ export interface PureAction<TContext, TEvent extends EventObject> extends Action
 }
 export interface ChooseAction<TContext, TEvent extends EventObject> extends ActionObject<TContext, TEvent> {
     type: ActionTypes.Choose;
-    conds: Array<ChooseConditon<TContext, TEvent>>;
+    conds: Array<ChooseCondition<TContext, TEvent>>;
 }
 export interface TransitionDefinition<TContext, TEvent extends EventObject> extends TransitionConfig<TContext, TEvent> {
     target: Array<StateNode<TContext, any, TEvent>> | undefined;
@@ -794,7 +784,7 @@ export interface SCXMLEventMeta<TEvent extends EventObject> {
     _event: SCXML.Event<TEvent>;
 }
 export interface StateMeta<TContext, TEvent extends EventObject> {
-    state: State<TContext, TEvent, any, any, any>;
+    state: State<TContext, TEvent, any, any>;
     _event: SCXML.Event<TEvent>;
 }
 export interface Typestate<TContext> {
@@ -813,7 +803,7 @@ export interface StateConfig<TContext, TEvent extends EventObject> {
     _event: SCXML.Event<TEvent>;
     _sessionid: string | null;
     historyValue?: HistoryValue | undefined;
-    history?: State<TContext, TEvent, any, any, any>;
+    history?: State<TContext, TEvent>;
     actions?: Array<ActionObject<TContext, TEvent>>;
     /**
      * @deprecated
@@ -826,7 +816,7 @@ export interface StateConfig<TContext, TEvent extends EventObject> {
     children: Record<string, ActorRef<any>>;
     done?: boolean;
     tags?: Set<string>;
-    machine?: StateMachine<TContext, any, TEvent, any, any, any>;
+    machine?: StateMachine<TContext, any, TEvent, any>;
 }
 export interface StateSchema<TC = any> {
     meta?: any;
@@ -839,9 +829,9 @@ export interface InterpreterOptions {
     /**
      * Whether state actions should be executed immediately upon transition. Defaults to `true`.
      */
-    execute?: boolean;
-    clock?: Clock;
-    logger?: (...args: any[]) => void;
+    execute: boolean;
+    clock: Clock;
+    logger: (...args: any[]) => void;
     parent?: AnyInterpreter;
     /**
      * If `true`, defers processing of sent events until the service
@@ -850,7 +840,7 @@ export interface InterpreterOptions {
      *
      * Default: `true`
      */
-    deferEvents?: boolean;
+    deferEvents: boolean;
     /**
      * The custom `id` for referencing this service.
      */
@@ -860,7 +850,8 @@ export interface InterpreterOptions {
      *
      * Default: `false`
      */
-    devTools?: boolean | object;
+    devTools: boolean | object;
+    [option: string]: any;
 }
 export declare namespace SCXML {
     interface Event<TEvent extends EventObject> {
@@ -954,16 +945,15 @@ export interface ActorRef<TEvent extends EventObject, TEmitted = any> extends Su
  * @deprecated Use `ActorRef` instead.
  */
 export declare type SpawnedActorRef<TEvent extends EventObject, TEmitted = any> = ActorRef<TEvent, TEmitted>;
-export declare type ActorRefWithDeprecatedState<TContext, TEvent extends EventObject, TTypestate extends Typestate<TContext>, TResolvedTypesMeta = TypegenDisabled> = ActorRef<TEvent, State<TContext, TEvent, any, TTypestate, TResolvedTypesMeta>> & {
+export declare type ActorRefWithDeprecatedState<TContext, TEvent extends EventObject, TTypestate extends Typestate<TContext>> = ActorRef<TEvent, State<TContext, TEvent, any, TTypestate>> & {
     /**
      * @deprecated Use `.getSnapshot()` instead.
      */
-    state: State<TContext, TEvent, any, TTypestate, TResolvedTypesMeta>;
+    state: State<TContext, TEvent, any, TTypestate>;
 };
-export declare type ActorRefFrom<T> = T extends StateMachine<infer TContext, any, infer TEvent, infer TTypestate> ? ActorRefWithDeprecatedState<TContext, TEvent, TTypestate> : T extends (...args: any[]) => StateMachine<infer TContext, any, infer TEvent, infer TTypestate, any, infer TResolvedTypesMeta> ? ActorRefWithDeprecatedState<TContext, TEvent, TTypestate, TResolvedTypesMeta> : T extends Promise<infer U> ? ActorRef<never, U> : T extends Behavior<infer TEvent1, infer TEmitted> ? ActorRef<TEvent1, TEmitted> : T extends (...args: any[]) => Behavior<infer TEvent1, infer TEmitted> ? ActorRef<TEvent1, TEmitted> : never;
-export declare type AnyInterpreter = Interpreter<any, any, any, any, any>;
-export declare type InterpreterFrom<T extends StateMachine<any, any, any, any> | ((...args: any[]) => StateMachine<any, any, any, any>)> = T extends StateMachine<infer TContext, infer TStateSchema, infer TEvent, infer TTypestate, any, infer TResolvedTypesMeta> ? Interpreter<TContext, TStateSchema, TEvent, TTypestate, TResolvedTypesMeta> : T extends (...args: any[]) => StateMachine<infer TContext, infer TStateSchema, infer TEvent, infer TTypestate, any, infer TResolvedTypesMeta> ? Interpreter<TContext, TStateSchema, TEvent, TTypestate, TResolvedTypesMeta> : never;
-export declare type MachineOptionsFrom<T extends StateMachine<any, any, any, any> | ((...args: any[]) => StateMachine<any, any, any, any>), TRequireMissingImplementations extends boolean = false> = T extends StateMachine<infer TContext, any, infer TEvent, any, any, infer TResolvedTypesMeta> ? MaybeTypegenMachineOptions<TContext, TEvent, any, TResolvedTypesMeta, TRequireMissingImplementations> : T extends (...args: any[]) => StateMachine<infer TContext, any, infer TEvent, any, any, infer TResolvedTypesMeta> ? MaybeTypegenMachineOptions<TContext, TEvent, any, TResolvedTypesMeta, TRequireMissingImplementations> : never;
+export declare type ActorRefFrom<T> = T extends StateMachine<infer TContext, any, infer TEvent, infer TTypestate> ? ActorRefWithDeprecatedState<TContext, TEvent, TTypestate> : T extends (...args: any[]) => StateMachine<infer TContext, any, infer TEvent, infer TTypestate> ? ActorRefWithDeprecatedState<TContext, TEvent, TTypestate> : T extends Promise<infer U> ? ActorRef<never, U> : T extends Behavior<infer TEvent1, infer TEmitted> ? ActorRef<TEvent1, TEmitted> : T extends (...args: any[]) => Behavior<infer TEvent1, infer TEmitted> ? ActorRef<TEvent1, TEmitted> : never;
+export declare type AnyInterpreter = Interpreter<any, any, any, any>;
+export declare type InterpreterFrom<T extends StateMachine<any, any, any, any> | ((...args: any[]) => StateMachine<any, any, any, any>)> = T extends StateMachine<infer TContext, infer TStateSchema, infer TEvent, infer TTypestate> ? Interpreter<TContext, TStateSchema, TEvent, TTypestate> : T extends (...args: any[]) => StateMachine<infer TContext, infer TStateSchema, infer TEvent, infer TTypestate> ? Interpreter<TContext, TStateSchema, TEvent, TTypestate> : never;
 export interface ActorContext<TEvent extends EventObject, TEmitted> {
     parent?: ActorRef<any, any>;
     self: ActorRef<TEvent, TEmitted>;
@@ -976,7 +966,10 @@ export interface Behavior<TEvent extends EventObject, TEmitted = any> {
     start?: (actorCtx: ActorContext<TEvent, TEmitted>) => TEmitted;
 }
 export declare type EmittedFrom<T> = ReturnTypeOrValue<T> extends infer R ? R extends ActorRef<infer _, infer TEmitted> ? TEmitted : R extends Behavior<infer _, infer TEmitted> ? TEmitted : R extends ActorContext<infer _, infer TEmitted> ? TEmitted : never : never;
-export declare type EventFrom<T> = ReturnTypeOrValue<T> extends infer R ? R extends StateMachine<infer _, infer __, infer TEvent, infer ____> ? TEvent : R extends Model<infer _, infer TEvent, infer ___, infer ____> ? TEvent : R extends State<infer _, infer TEvent, infer ___, infer ____> ? TEvent : R extends Interpreter<infer _, infer __, infer TEvent, infer ____> ? TEvent : never : never;
+declare type ResolveEventType<T> = ReturnTypeOrValue<T> extends infer R ? R extends StateMachine<infer _, infer __, infer TEvent, infer ____> ? TEvent : R extends Model<infer _, infer TEvent, infer ___, infer ____> ? TEvent : R extends State<infer _, infer TEvent, infer ___, infer ____> ? TEvent : R extends Interpreter<infer _, infer __, infer TEvent, infer ____> ? TEvent : never : never;
+export declare type EventFrom<T, K extends Prop<TEvent, 'type'> = never, TEvent = ResolveEventType<T>> = IsNever<K> extends true ? TEvent : Extract<TEvent, {
+    type: K;
+}>;
 export declare type ContextFrom<T> = ReturnTypeOrValue<T> extends infer R ? R extends StateMachine<infer TContext, infer _, infer __, infer ___> ? TContext : R extends Model<infer TContext, infer _, infer __, infer ___> ? TContext : R extends State<infer TContext, infer _, infer __, infer ___> ? TContext : R extends Interpreter<infer TContext, infer _, infer __, infer ___> ? TContext : never : never;
 export {};
 //# sourceMappingURL=types.d.ts.map

package/es/utils.d.ts

@@ -63,7 +63,7 @@ export declare function toTransitionConfigArray<TContext, TEvent extends EventOb
 }>;
 export declare function normalizeTarget<TContext, TEvent extends EventObject>(target: SingleOrArray<string | StateNode<TContext, any, TEvent>> | undefined): Array<string | StateNode<TContext, any, TEvent>> | undefined;
 export declare function reportUnhandledExceptionOnInvocation(originalError: any, currentError: any, id: string): void;
-export declare function evaluateGuard<TContext, TEvent extends EventObject>(machine: StateNode<TContext, any, TEvent, any, any>, guard: Guard<TContext, TEvent>, context: TContext, _event: SCXML.Event<TEvent>, state: State<TContext, TEvent>): boolean;
+export declare function evaluateGuard<TContext, TEvent extends EventObject>(machine: StateNode<TContext, any, TEvent, any>, guard: Guard<TContext, TEvent>, context: TContext, _event: SCXML.Event<TEvent>, state: State<TContext, TEvent>): boolean;
 export declare function toInvokeSource(src: string | InvokeSourceDefinition): InvokeSourceDefinition;
 export declare function toObserver<T>(nextHandler: Observer<T> | ((value: T) => void), errorHandler?: (error: any) => void, completionHandler?: () => void): Observer<T>;
 //# sourceMappingURL=utils.d.ts.map

package/es/utils.js

@@ -548,7 +548,7 @@ function evaluateGuard(machine, guard, context, _event, state) {
     return ((guards === null || guards === void 0 ? void 0 : guards[guard.name]) || guard.predicate)(context, _event.data, guardMeta);
   }
 
-  var condFn = guards === null || guards === void 0 ? void 0 : guards[guard.type];
+  var condFn = guards[guard.type];
 
   if (!condFn) {
     throw new Error("Guard '" + guard.type + "' is not implemented on machine '" + machine.id + "'.");

package/lib/Actor.d.ts

@@ -1,4 +1,5 @@
-import { EventObject, Subscribable, InvokeDefinition, AnyEventObject, StateMachine, Spawnable, SCXML, ActorRef, BaseActorRef } from './types';
+import { EventObject, Subscribable, InvokeDefinition, AnyEventObject, StateMachine, Spawnable, SCXML } from './types';
+import { ActorRef, BaseActorRef } from '.';
 export interface Actor<TContext = any, TEvent extends EventObject = AnyEventObject> extends Subscribable<TContext> {
     id: string;
     send: (event: TEvent) => any;

package/lib/Machine.d.ts

@@ -1,13 +1,12 @@
 import { Model } from './model.types';
-import { AnyEventObject, BaseActionObject, DefaultContext, EventObject, MachineConfig, MachineOptions, StateMachine, StateSchema, Typestate } from './types';
-import { MaybeTypegenMachineOptions, TypegenConstraint, TypegenDisabled, ResolveTypegenMeta } from './typegenTypes';
+import { AnyEventObject, DefaultContext, EventObject, MachineConfig, MachineOptions, StateMachine, StateSchema, Typestate } from './types';
 /**
  * @deprecated Use `createMachine(...)` instead.
  */
-export declare function Machine<TContext = any, TEvent extends EventObject = AnyEventObject>(config: MachineConfig<TContext, any, TEvent>, options?: MachineOptions<TContext, TEvent>, initialContext?: TContext): StateMachine<TContext, any, TEvent>;
-export declare function Machine<TContext = DefaultContext, TStateSchema extends StateSchema = any, TEvent extends EventObject = AnyEventObject>(config: MachineConfig<TContext, TStateSchema, TEvent>, options?: MachineOptions<TContext, TEvent>, initialContext?: TContext): StateMachine<TContext, TStateSchema, TEvent>;
+export declare function Machine<TContext = any, TEvent extends EventObject = AnyEventObject>(config: MachineConfig<TContext, any, TEvent>, options?: Partial<MachineOptions<TContext, TEvent>>, initialContext?: TContext): StateMachine<TContext, any, TEvent>;
+export declare function Machine<TContext = DefaultContext, TStateSchema extends StateSchema = any, TEvent extends EventObject = AnyEventObject>(config: MachineConfig<TContext, TStateSchema, TEvent>, options?: Partial<MachineOptions<TContext, TEvent>>, initialContext?: TContext): StateMachine<TContext, TStateSchema, TEvent>;
 export declare function createMachine<TContext, TEvent extends EventObject = AnyEventObject, TTypestate extends Typestate<TContext> = {
     value: any;
     context: TContext;
-}, TTypesMeta extends TypegenConstraint = TypegenDisabled, TResolvedTypesMeta = ResolveTypegenMeta<TTypesMeta, TEvent, BaseActionObject>>(config: TContext extends Model<any, any, any, any> ? 'Model type no longer supported as generic type. Please use `model.createMachine(...)` instead.' : MachineConfig<TContext, any, TEvent, BaseActionObject, TTypesMeta>, options?: MaybeTypegenMachineOptions<TContext, TEvent, BaseActionObject, TResolvedTypesMeta>): StateMachine<TContext, any, TEvent, any, BaseActionObject, TResolvedTypesMeta>;
+}>(config: TContext extends Model<any, any, any, any> ? 'Model type no longer supported as generic type. Please use `model.createMachine(...)` instead.' : MachineConfig<TContext, any, TEvent>, options?: Partial<MachineOptions<TContext, TEvent>>): StateMachine<TContext, any, TEvent, TTypestate>;
 //# sourceMappingURL=Machine.d.ts.map