xstate 4.28.1 → 4.30.2

package/es/stateUtils.d.ts

@@ -1,15 +1,16 @@
-import { EventObject, StateNode, StateValue } from '.';
+import { EventObject, StateValue } from './types';
+import { StateNode } from './StateNode';
 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>) => boolean;
+export declare const isLeafNode: (stateNode: StateNode<any, any, 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>): 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>>): Set<StateNode<TC, any, TE, any>>;
+export declare function getAllStateNodes<TC, TE extends EventObject>(stateNode: StateNode<TC, any, TE, any, any, any>): Array<StateNode<TC, any, TE, any, any, any>>;
+export declare function getConfiguration<TC, TE extends EventObject>(prevStateNodes: Iterable<StateNode<TC, any, TE, any, any, any>>, stateNodes: Iterable<StateNode<TC, any, TE, any, any, any>>): Set<StateNode<TC, any, TE, any, any, 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>>, stateNode: StateNode<TC, any, TE, any>): boolean;
+export declare function isInFinalState<TC, TE extends EventObject>(configuration: Array<StateNode<TC, any, TE, any, any, any>>, stateNode: StateNode<TC, any, TE, any, any, any>): boolean;
 export declare function getMeta(configuration?: StateNode[]): Record<string, any>;
 export declare function getTagsFromConfiguration(configuration: StateNode<any, any, any, any>[]): Set<string>;
 export {};

package/es/typegenTypes.d.ts

@@ -0,0 +1,121 @@
+import { BaseActionObject, EventObject, IndexByType, IsNever, Prop, Values, IsAny, ServiceMap, Cast } from './types';
+export interface TypegenDisabled {
+    '@@xstate/typegen': false;
+}
+export interface TypegenEnabled {
+    '@@xstate/typegen': true;
+}
+export interface TypegenMeta extends TypegenEnabled {
+    /**
+     * Allows you to specify all the results of state.matches
+     */
+    matchesStates: string | {};
+    /**
+     * Allows you to specify all tags used by the machine
+     */
+    tags: string;
+    /**
+     * Allows you to specify all the missing implementations
+     * of the machine
+     */
+    missingImplementations: {
+        actions: string;
+        delays: string;
+        guards: string;
+        services: string;
+    };
+    /**
+     * A map for the internal events of the machine.
+     *
+     * key: 'done.invoke.myService'
+     * value: {
+     *   type: 'done.invoke.myService';
+     *   data: unknown;
+     *   __tip: 'Declare the type in event types!';
+     * }
+     */
+    internalEvents: {};
+    /**
+     * Maps the name of the service to the event type
+     * of the done.invoke action
+     *
+     * key: 'invokeSrc'
+     * value: 'done.invoke.invokeName'
+     */
+    invokeSrcNameMap: Record<string, string>;
+    /**
+     * Keeps track of which events lead to which
+     * actions.
+     *
+     * Key: 'EVENT_NAME'
+     * Value: 'actionName' | 'otherActionName'
+     */
+    eventsCausingActions: Record<string, string>;
+    /**
+     * Keeps track of which events lead to which
+     * delays.
+     *
+     * Key: 'EVENT_NAME'
+     * Value: 'delayName' | 'otherDelayName'
+     */
+    eventsCausingDelays: Record<string, string>;
+    /**
+     * Keeps track of which events lead to which
+     * guards.
+     *
+     * Key: 'EVENT_NAME'
+     * Value: 'guardName' | 'otherGuardName'
+     */
+    eventsCausingGuards: Record<string, string>;
+    /**
+     * Keeps track of which events lead to which
+     * services.
+     *
+     * Key: 'EVENT_NAME'
+     * Value: 'serviceName' | 'otherServiceName'
+     */
+    eventsCausingServices: Record<string, string>;
+}
+export interface ResolvedTypegenMeta extends TypegenMeta {
+    indexedActions: Record<string, BaseActionObject>;
+    indexedEvents: Record<string, EventObject>;
+}
+export declare type TypegenConstraint = TypegenEnabled | TypegenDisabled;
+export declare type AreAllImplementationsAssumedToBeProvided<TResolvedTypesMeta, TMissingImplementations = Prop<TResolvedTypesMeta, 'missingImplementations'>> = IsAny<TResolvedTypesMeta> extends true ? true : TResolvedTypesMeta extends TypegenEnabled ? IsNever<Values<{
+    [K in keyof TMissingImplementations]: TMissingImplementations[K];
+}>> extends true ? true : false : true;
+export declare type MarkAllImplementationsAsProvided<TResolvedTypesMeta> = TResolvedTypesMeta & {
+    missingImplementations: {
+        actions: never;
+        delays: never;
+        guards: never;
+        services: never;
+    };
+};
+declare type GenerateServiceEvent<TServiceName, TEventType, TServiceMap extends ServiceMap> = TEventType extends any ? {
+    type: TEventType;
+} & Prop<TServiceMap, TServiceName> : never;
+declare type GenerateServiceEvents<TServiceMap extends ServiceMap, TInvokeSrcNameMap> = string extends keyof TServiceMap ? never : Cast<{
+    [K in keyof TInvokeSrcNameMap]: GenerateServiceEvent<K, TInvokeSrcNameMap[K], TServiceMap>;
+}[keyof TInvokeSrcNameMap], EventObject>;
+declare type MergeWithInternalEvents<TIndexedEvents, TInternalEvents> = TIndexedEvents & Pick<TInternalEvents, Exclude<keyof TInternalEvents, keyof TIndexedEvents>>;
+declare type AllowAllEvents = {
+    eventsCausingActions: Record<string, string>;
+    eventsCausingDelays: Record<string, string>;
+    eventsCausingGuards: Record<string, string>;
+    eventsCausingServices: Record<string, string>;
+};
+export declare type ResolveTypegenMeta<TTypesMeta extends TypegenConstraint, TEvent extends EventObject, TAction extends BaseActionObject, TServiceMap extends ServiceMap> = TTypesMeta extends TypegenEnabled ? TTypesMeta & {
+    indexedActions: IndexByType<TAction>;
+    indexedEvents: MergeWithInternalEvents<IndexByType<(string extends TEvent['type'] ? never : TEvent) | GenerateServiceEvents<TServiceMap, Prop<TTypesMeta, 'invokeSrcNameMap'>>>, Prop<TTypesMeta, 'internalEvents'>>;
+} : MarkAllImplementationsAsProvided<TypegenDisabled> & AllowAllEvents & {
+    indexedActions: IndexByType<TAction>;
+    indexedEvents: Record<string, TEvent> & {
+        __XSTATE_ALLOW_ANY_INVOKE_DATA_HACK__: {
+            data: any;
+        };
+    };
+    invokeSrcNameMap: Record<string, '__XSTATE_ALLOW_ANY_INVOKE_DATA_HACK__'>;
+};
+export {};
+//# sourceMappingURL=typegenTypes.d.ts.map

package/es/types.d.ts

@@ -1,9 +1,26 @@
-import { StateNode } from './StateNode';
+import { Clock, Interpreter } from './interpreter';
+import { Model } from './model.types';
 import { State } from './State';
-import { Interpreter, Clock } from './interpreter';
-import { IsNever, Model, Prop } from './model.types';
-declare type AnyFunction = (...args: any[]) => any;
+import { StateNode } from './StateNode';
+import { MarkAllImplementationsAsProvided, TypegenDisabled, ResolveTypegenMeta, TypegenConstraint, AreAllImplementationsAssumedToBeProvided } from './typegenTypes';
+export 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 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 Equals<A1 extends any, A2 extends any> = (<A>() => A extends A2 ? true : false) extends <A>() => A extends A1 ? true : false ? true : false;
+export declare type IsAny<T> = Equals<T, any>;
 export declare type Cast<A, B> = A extends B ? A : B;
 export declare type EventType = string;
 export declare type ActionType = string;
@@ -45,7 +62,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 ActionObject<TContext, TEvent> = ActionObject<TContext, TEvent>> extends StateMeta<TContext, TEvent> {
+export interface ActionMeta<TContext, TEvent extends EventObject, TAction extends BaseActionObject = BaseActionObject> extends StateMeta<TContext, TEvent> {
     action: TAction;
     _event: SCXML.Event<TEvent>;
 }
@@ -54,7 +71,9 @@ 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 ActionObject<TContext, TEvent> = ActionObject<TContext, TEvent>> = (context: TContext, event: TEvent, meta: ActionMeta<TContext, TEvent, TAction>) => void;
+export declare type ActionFunction<TContext, TEvent extends EventObject, TAction extends BaseActionObject = BaseActionObject> = {
+    bivarianceHack(context: TContext, event: TEvent, meta: ActionMeta<TContext, TEvent, TAction>): void;
+}['bivarianceHack'];
 export interface ChooseCondition<TContext, TEvent extends EventObject> {
     cond?: Condition<TContext, TEvent>;
     actions: Actions<TContext, TEvent>;
@@ -71,7 +90,7 @@ export declare type SimpleEventsOf<TEvent extends EventObject> = ExtractWithSimp
 export declare type BaseAction<TContext, TEvent extends EventObject, TAction extends BaseActionObject> = SimpleActionsOf<TAction>['type'] | TAction | RaiseAction<any> | SendAction<TContext, TEvent, any> | AssignAction<TContext, TEvent> | LogAction<TContext, TEvent> | CancelAction | StopAction<TContext, TEvent> | ChooseAction<TContext, TEvent> | ActionFunction<TContext, TEvent>;
 export declare type BaseActions<TContext, TEvent extends EventObject, TAction extends BaseActionObject> = SingleOrArray<BaseAction<TContext, TEvent, TAction>>;
 export declare type Actions<TContext, TEvent extends EventObject> = SingleOrArray<Action<TContext, TEvent>>;
-export declare type StateKey = string | State<any>;
+export declare type StateKey = string | AnyState;
 export interface StateValueMap {
     [key: string]: StateValue;
 }
@@ -146,7 +165,9 @@ export interface PayloadSender<TEvent extends EventObject> {
      */
     <K extends TEvent['type']>(eventType: K, payload: NeverIfEmpty<ExtractExtraParameters<TEvent, K>>): void;
 }
-export declare type Receiver<TEvent extends EventObject> = (listener: (event: TEvent) => void) => void;
+export declare type Receiver<TEvent extends EventObject> = (listener: {
+    bivarianceHack(event: TEvent): void;
+}['bivarianceHack']) => void;
 export declare type InvokeCallback<TEvent extends EventObject = AnyEventObject, TSentEvent extends EventObject = AnyEventObject> = (callback: Sender<TSentEvent>, onReceive: Receiver<TEvent>) => (() => void) | Promise<any> | void;
 export interface InvokeMeta {
     data: any;
@@ -166,7 +187,8 @@ export interface InvokeMeta {
  * @param context The current machine `context`
  * @param event The event that invoked the service
  */
-export declare type InvokeCreator<TContext, TEvent extends EventObject, TFinalContext = any> = (context: TContext, event: TEvent, meta: InvokeMeta) => PromiseLike<TFinalContext> | StateMachine<TFinalContext, any, any> | Subscribable<EventObject> | InvokeCallback<any, TEvent> | Behavior<any>;
+export declare type InvokeCreator<TContext, TSourceEvent extends EventObject, TFinalContext = any, TInputEvent extends EventObject = any, // keeping a slot for it here, but it's actually not used right now to ensure that the communication contract between actors is satisfied
+TOutputEvent extends EventObject = TSourceEvent> = (context: TContext, event: TSourceEvent, meta: InvokeMeta) => PromiseLike<TFinalContext> | StateMachine<TFinalContext, any, any, any, any, any, any> | Subscribable<EventObject> | InvokeCallback<TInputEvent, TOutputEvent> | Behavior<any>;
 export interface InvokeDefinition<TContext, TEvent extends EventObject> extends ActivityDefinition<TContext, TEvent> {
     /**
      * The source of the machine to be invoked, or the machine itself.
@@ -246,7 +268,7 @@ export interface InvokeConfig<TContext, TEvent extends EventObject> {
     /**
      * The source of the machine to be invoked, or the machine itself.
      */
-    src: string | InvokeSourceDefinition | StateMachine<any, any, any> | InvokeCreator<TContext, TEvent, any>;
+    src: string | InvokeSourceDefinition | AnyStateMachine | InvokeCreator<TContext, TEvent, any>;
     /**
      * If `true`, events sent to the parent service will be forwarded to the invoked service.
      *
@@ -316,7 +338,7 @@ export interface StateNodeConfig<TContext, TStateSchema extends StateSchema, TEv
     /**
      * The services to invoke upon entering this state node. These services will be stopped upon exiting this state node.
      */
-    invoke?: SingleOrArray<InvokeConfig<TContext, TEvent> | StateMachine<any, any, any>>;
+    invoke?: SingleOrArray<InvokeConfig<TContext, TEvent> | AnyStateMachine>;
     /**
      * The mapping of event types to their potential transition(s).
      */
@@ -436,6 +458,8 @@ export interface StateNodeDefinition<TContext, TStateSchema extends StateSchema,
     tags: string[];
 }
 export declare type AnyStateNodeDefinition = StateNodeDefinition<any, any, any>;
+export declare type AnyState = State<any, any, any, any, any>;
+export declare type AnyStateMachine = StateMachine<any, any, any, any, any, any, any>;
 export interface AtomicStateNodeConfig<TContext, TEvent extends EventObject> extends StateNodeConfig<TContext, StateSchema, TEvent> {
     initial?: undefined;
     parallel?: false | undefined;
@@ -455,33 +479,52 @@ 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 ActionObject<TContext, TEvent> = ActionObject<TContext, TEvent>> = {
+export declare type ActionFunctionMap<TContext, TEvent extends EventObject, TAction extends BaseActionObject = BaseActionObject> = {
     [K in TAction['type']]?: ActionObject<TContext, TEvent> | ActionFunction<TContext, TEvent, TAction extends {
         type: K;
     } ? TAction : never>;
 };
 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 ServiceConfig<TContext, TEvent extends EventObject = AnyEventObject> = string | AnyStateMachine | InvokeCreator<TContext, TEvent>;
 export declare type DelayConfig<TContext, TEvent extends EventObject> = number | DelayExpr<TContext, TEvent>;
-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>;
+declare type MachineOptionsActions<TContext, TResolvedTypesMeta, TEventsCausingActions = Prop<TResolvedTypesMeta, 'eventsCausingActions'>, TIndexedEvents = Prop<TResolvedTypesMeta, 'indexedEvents'>, TIndexedActions = Prop<TResolvedTypesMeta, 'indexedActions'>> = {
+    [K in keyof TEventsCausingActions]?: ActionObject<TContext, Cast<Prop<TIndexedEvents, TEventsCausingActions[K]>, EventObject>> | ActionFunction<TContext, Cast<Prop<TIndexedEvents, TEventsCausingActions[K]>, EventObject>, Cast<Prop<TIndexedActions, K>, BaseActionObject>>;
+};
+declare type MachineOptionsDelays<TContext, TResolvedTypesMeta, TEventsCausingDelays = Prop<TResolvedTypesMeta, 'eventsCausingDelays'>, TIndexedEvents = Prop<TResolvedTypesMeta, 'indexedEvents'>> = {
+    [K in keyof TEventsCausingDelays]?: DelayConfig<TContext, Cast<Prop<TIndexedEvents, TEventsCausingDelays[K]>, EventObject>>;
+};
+declare type MachineOptionsGuards<TContext, TResolvedTypesMeta, TEventsCausingGuards = Prop<TResolvedTypesMeta, 'eventsCausingGuards'>, TIndexedEvents = Prop<TResolvedTypesMeta, 'indexedEvents'>> = {
+    [K in keyof TEventsCausingGuards]?: ConditionPredicate<TContext, Cast<Prop<TIndexedEvents, TEventsCausingGuards[K]>, EventObject>>;
+};
+declare type MachineOptionsServices<TContext, TResolvedTypesMeta, TEventsCausingServices = Prop<TResolvedTypesMeta, 'eventsCausingServices'>, TIndexedEvents = Prop<TResolvedTypesMeta, 'indexedEvents'>, TInvokeSrcNameMap = Prop<TResolvedTypesMeta, 'invokeSrcNameMap'>> = {
+    [K in keyof TEventsCausingServices]?: AnyStateMachine | InvokeCreator<TContext, Cast<Prop<TIndexedEvents, TEventsCausingServices[K]>, EventObject>, Prop<Prop<TIndexedEvents, Prop<TInvokeSrcNameMap, K>>, 'data'>, EventObject, Cast<TIndexedEvents[keyof TIndexedEvents], EventObject>>;
+};
+declare type MakeKeysRequired<T extends string> = {
+    [K in T]: unknown;
+};
+declare type MaybeMakeMissingImplementationsRequired<TImplementationType, TMissingImplementationsForType, TRequireMissingImplementations> = TRequireMissingImplementations extends true ? IsNever<TMissingImplementationsForType> extends true ? {} : {
+    [K in Cast<TImplementationType, string>]: MakeKeysRequired<Cast<TMissingImplementationsForType, string>>;
+} : {};
+declare type GenerateActionsConfigPart<TContext, TResolvedTypesMeta, TRequireMissingImplementations, TMissingImplementations> = MaybeMakeMissingImplementationsRequired<'actions', Prop<TMissingImplementations, 'actions'>, TRequireMissingImplementations> & {
+    actions?: MachineOptionsActions<TContext, TResolvedTypesMeta>;
+};
+declare type GenerateDelaysConfigPart<TContext, TResolvedTypesMeta, TRequireMissingImplementations, TMissingImplementations> = MaybeMakeMissingImplementationsRequired<'delays', Prop<TMissingImplementations, 'delays'>, TRequireMissingImplementations> & {
+    delays?: MachineOptionsDelays<TContext, TResolvedTypesMeta>;
+};
+declare type GenerateGuardsConfigPart<TContext, TResolvedTypesMeta, TRequireMissingImplementations, TMissingImplementations> = MaybeMakeMissingImplementationsRequired<'guards', Prop<TMissingImplementations, 'guards'>, TRequireMissingImplementations> & {
+    guards?: MachineOptionsGuards<TContext, TResolvedTypesMeta>;
+};
+declare type GenerateServicesConfigPart<TContext, TResolvedTypesMeta, TRequireMissingImplementations, TMissingImplementations> = MaybeMakeMissingImplementationsRequired<'services', Prop<TMissingImplementations, 'services'>, TRequireMissingImplementations> & {
+    services?: MachineOptionsServices<TContext, TResolvedTypesMeta>;
+};
+export declare type InternalMachineOptions<TContext, TEvent extends EventObject, TResolvedTypesMeta, TRequireMissingImplementations extends boolean = false, TMissingImplementations = Prop<TResolvedTypesMeta, 'missingImplementations'>> = GenerateActionsConfigPart<TContext, TResolvedTypesMeta, TRequireMissingImplementations, TMissingImplementations> & GenerateDelaysConfigPart<TContext, TResolvedTypesMeta, TRequireMissingImplementations, TMissingImplementations> & GenerateGuardsConfigPart<TContext, TResolvedTypesMeta, TRequireMissingImplementations, TMissingImplementations> & GenerateServicesConfigPart<TContext, TResolvedTypesMeta, TRequireMissingImplementations, TMissingImplementations> & {
     /**
      * @deprecated Use `services` instead.
      */
-    activities: Record<string, ActivityConfig<TContext, TEvent>>;
-    services: Record<string, ServiceConfig<TContext, TEvent>>;
-    delays: DelayFunctionMap<TContext, TEvent>;
-    /**
-     * @private
-     */
-    _parent?: StateNode<TContext, any, TEvent, any>;
-    /**
-     * @private
-     */
-    _key?: string;
-}
-export interface MachineConfig<TContext, TStateSchema extends StateSchema, TEvent extends EventObject, TAction extends BaseActionObject = ActionObject<TContext, TEvent>> extends StateNodeConfig<TContext, TStateSchema, TEvent, TAction> {
+    activities?: Record<string, ActivityConfig<TContext, TEvent>>;
+};
+export declare type MachineOptions<TContext, TEvent extends EventObject, TAction extends BaseActionObject = BaseActionObject, TServiceMap extends ServiceMap = ServiceMap, TTypesMeta extends TypegenConstraint = TypegenDisabled> = InternalMachineOptions<TContext, TEvent, ResolveTypegenMeta<TTypesMeta, TEvent, TAction, TServiceMap>>;
+export interface MachineConfig<TContext, TStateSchema extends StateSchema, TEvent extends EventObject, TAction extends BaseActionObject = BaseActionObject, TServiceMap extends ServiceMap = ServiceMap, TTypesMeta = TypegenDisabled> extends StateNodeConfig<TContext, TStateSchema, TEvent, TAction> {
     /**
      * The initial context (extended state)
      */
@@ -490,9 +533,13 @@ export interface MachineConfig<TContext, TStateSchema extends StateSchema, TEven
      * The machine's own version.
      */
     version?: string;
-    schema?: MachineSchema<TContext, TEvent>;
+    schema?: MachineSchema<TContext, TEvent, TServiceMap>;
+    tsTypes?: TTypesMeta;
 }
-export interface MachineSchema<TContext, TEvent extends EventObject> {
+export declare type ServiceMap = Record<string, {
+    data: any;
+}>;
+export interface MachineSchema<TContext, TEvent extends EventObject, TServiceMap extends ServiceMap = ServiceMap> {
     context?: TContext;
     events?: TEvent;
     actions?: {
@@ -503,10 +550,7 @@ export interface MachineSchema<TContext, TEvent extends EventObject> {
         type: string;
         [key: string]: any;
     };
-    services?: {
-        type: string;
-        [key: string]: any;
-    };
+    services?: TServiceMap;
 }
 export interface StandardMachineConfig<TContext, TStateSchema extends StateSchema, TEvent extends EventObject> extends StateNodeConfig<TContext, TStateSchema, TEvent> {
 }
@@ -522,16 +566,31 @@ export interface HistoryStateNode<TContext> extends StateNode<TContext> {
     history: 'shallow' | 'deep';
     target: StateValue | undefined;
 }
+/** @ts-ignore TS complains about withConfig & withContext not being compatible here when extending StateNode */
 export interface StateMachine<TContext, TStateSchema extends StateSchema, TEvent extends EventObject, TTypestate extends Typestate<TContext> = {
     value: any;
     context: TContext;
-}, _TAction extends ActionObject<TContext, TEvent> = ActionObject<TContext, TEvent>> extends StateNode<TContext, TStateSchema, TEvent, TTypestate> {
+}, TAction extends BaseActionObject = BaseActionObject, TServiceMap extends ServiceMap = ServiceMap, TResolvedTypesMeta = ResolveTypegenMeta<TypegenDisabled, TEvent, TAction, TServiceMap>> extends StateNode<TContext, TStateSchema, TEvent, TTypestate, TServiceMap, TResolvedTypesMeta> {
     id: string;
-    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> | ((...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;
+    states: StateNode<TContext, TStateSchema, TEvent, TTypestate, TServiceMap, TResolvedTypesMeta>['states'];
+    withConfig(options: InternalMachineOptions<TContext, TEvent, TResolvedTypesMeta, true>, context?: TContext | (() => TContext)): StateMachine<TContext, TStateSchema, TEvent, TTypestate, TAction, TServiceMap, AreAllImplementationsAssumedToBeProvided<TResolvedTypesMeta> extends false ? MarkAllImplementationsAsProvided<TResolvedTypesMeta> : TResolvedTypesMeta>;
+    withContext(context: TContext | (() => TContext)): StateMachine<TContext, TStateSchema, TEvent, TTypestate, TAction, TServiceMap, TResolvedTypesMeta>;
+    /** @deprecated an internal property acting as a "phantom" type, not meant to be used at runtime */
+    __TContext: TContext;
+    /** @deprecated an internal property acting as a "phantom" type, not meant to be used at runtime */
+    __TStateSchema: TStateSchema;
+    /** @deprecated an internal property acting as a "phantom" type, not meant to be used at runtime */
+    __TEvent: TEvent;
+    /** @deprecated an internal property acting as a "phantom" type, not meant to be used at runtime */
+    __TTypestate: TTypestate;
+    /** @deprecated an internal property acting as a "phantom" type, not meant to be used at runtime */
+    __TAction: TAction;
+    /** @deprecated an internal property acting as a "phantom" type, not meant to be used at runtime */
+    __TServiceMap: TServiceMap;
+    /** @deprecated an internal property acting as a "phantom" type, not meant to be used at runtime */
+    __TResolvedTypesMeta: TResolvedTypesMeta;
+}
+export declare type StateFrom<T extends AnyStateMachine | ((...args: any[]) => AnyStateMachine)> = T extends AnyStateMachine ? ReturnType<T['transition']> : T extends (...args: any[]) => AnyStateMachine ? ReturnType<ReturnType<T>['transition']> : never;
 export interface ActionMap<TContext, TEvent extends EventObject> {
     onEntry: Array<Action<TContext, TEvent>>;
     actions: Array<Action<TContext, TEvent>>;
@@ -550,13 +609,13 @@ export interface ActivityMap {
 }
 export interface StateTransition<TContext, TEvent extends EventObject> {
     transitions: Array<TransitionDefinition<TContext, TEvent>>;
-    configuration: Array<StateNode<TContext, any, TEvent, any>>;
-    entrySet: Array<StateNode<TContext, any, TEvent, any>>;
-    exitSet: Array<StateNode<TContext, any, TEvent, any>>;
+    configuration: Array<StateNode<TContext, any, TEvent, any, any, any>>;
+    entrySet: Array<StateNode<TContext, any, TEvent, any, any, any>>;
+    exitSet: Array<StateNode<TContext, any, TEvent, any, any, any>>;
     /**
      * The source state that preceded the transition.
      */
-    source: State<TContext, any, any, any> | undefined;
+    source: State<TContext, any, any, any, any> | undefined;
     actions: Array<ActionObject<TContext, TEvent>>;
 }
 export interface TransitionData<TContext, TEvent extends EventObject> {
@@ -611,7 +670,7 @@ export interface DoneEventObject extends EventObject {
 }
 export interface UpdateObject extends EventObject {
     id: string | number;
-    state: State<any, any>;
+    state: AnyState;
 }
 export declare type DoneEvent = DoneEventObject & string;
 export interface NullEvent {
@@ -777,7 +836,7 @@ export interface SCXMLEventMeta<TEvent extends EventObject> {
     _event: SCXML.Event<TEvent>;
 }
 export interface StateMeta<TContext, TEvent extends EventObject> {
-    state: State<TContext, TEvent, any, any>;
+    state: State<TContext, TEvent, any, any, any>;
     _event: SCXML.Event<TEvent>;
 }
 export interface Typestate<TContext> {
@@ -796,7 +855,7 @@ export interface StateConfig<TContext, TEvent extends EventObject> {
     _event: SCXML.Event<TEvent>;
     _sessionid: string | null;
     historyValue?: HistoryValue | undefined;
-    history?: State<TContext, TEvent>;
+    history?: State<TContext, TEvent, any, any, any>;
     actions?: Array<ActionObject<TContext, TEvent>>;
     /**
      * @deprecated
@@ -809,8 +868,9 @@ export interface StateConfig<TContext, TEvent extends EventObject> {
     children: Record<string, ActorRef<any>>;
     done?: boolean;
     tags?: Set<string>;
-    machine?: StateMachine<TContext, any, TEvent, any>;
+    machine?: StateMachine<TContext, any, TEvent, any, any, any, any>;
 }
+export declare type AnyStateConfig = StateConfig<any, AnyEventObject>;
 export interface StateSchema<TC = any> {
     meta?: any;
     context?: Partial<TC>;
@@ -822,9 +882,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
@@ -833,7 +893,7 @@ export interface InterpreterOptions {
      *
      * Default: `true`
      */
-    deferEvents: boolean;
+    deferEvents?: boolean;
     /**
      * The custom `id` for referencing this service.
      */
@@ -843,8 +903,7 @@ export interface InterpreterOptions {
      *
      * Default: `false`
      */
-    devTools: boolean | object;
-    [option: string]: any;
+    devTools?: boolean | object;
 }
 export declare namespace SCXML {
     interface Event<TEvent extends EventObject> {
@@ -917,13 +976,16 @@ export interface Subscription {
     unsubscribe(): void;
 }
 export interface InteropObservable<T> {
-    [Symbol.observable]: () => Subscribable<T>;
+    [Symbol.observable]: () => InteropSubscribable<T>;
 }
-export interface Subscribable<T> {
-    subscribe(next: (value: T) => void, error?: (error: any) => void, complete?: () => void): Subscription;
+export interface InteropSubscribable<T> {
+    subscribe(observer: Observer<T>): Subscription;
+}
+export interface Subscribable<T> extends InteropSubscribable<T> {
     subscribe(observer: Observer<T>): Subscription;
+    subscribe(next: (value: T) => void, error?: (error: any) => void, complete?: () => void): Subscription;
 }
-export declare type Spawnable = StateMachine<any, any, any> | PromiseLike<any> | InvokeCallback | InteropObservable<any> | Subscribable<any> | Behavior<any>;
+export declare type Spawnable = AnyStateMachine | PromiseLike<any> | InvokeCallback | InteropObservable<any> | Subscribable<any> | Behavior<any>;
 export declare type ExtractEvent<TEvent extends EventObject, TEventType extends TEvent['type']> = TEvent extends {
     type: TEventType;
 } ? TEvent : never;
@@ -941,15 +1003,17 @@ 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>> = ActorRef<TEvent, State<TContext, TEvent, any, TTypestate>> & {
+export declare type ActorRefWithDeprecatedState<TContext, TEvent extends EventObject, TTypestate extends Typestate<TContext>, TResolvedTypesMeta = TypegenDisabled> = ActorRef<TEvent, State<TContext, TEvent, any, TTypestate, TResolvedTypesMeta>> & {
     /**
      * @deprecated Use `.getSnapshot()` instead.
      */
-    state: State<TContext, TEvent, any, TTypestate>;
+    state: State<TContext, TEvent, any, TTypestate, TResolvedTypesMeta>;
 };
-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 declare type ActorRefFrom<T> = T extends StateMachine<infer TContext, any, infer TEvent, infer TTypestate, any, any, any> ? ActorRefWithDeprecatedState<TContext, TEvent, TTypestate> : T extends (...args: any[]) => StateMachine<infer TContext, any, infer TEvent, infer TTypestate, any, 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 AnyStateMachine | ((...args: any[]) => AnyStateMachine)> = T extends StateMachine<infer TContext, infer TStateSchema, infer TEvent, infer TTypestate, any, any, infer TResolvedTypesMeta> ? Interpreter<TContext, TStateSchema, TEvent, TTypestate, TResolvedTypesMeta> : T extends (...args: any[]) => StateMachine<infer TContext, infer TStateSchema, infer TEvent, infer TTypestate, any, any, infer TResolvedTypesMeta> ? Interpreter<TContext, TStateSchema, TEvent, TTypestate, TResolvedTypesMeta> : never;
+export declare type MachineOptionsFrom<T extends AnyStateMachine | ((...args: any[]) => AnyStateMachine), TRequireMissingImplementations extends boolean = false> = ReturnTypeOrValue<T> extends StateMachine<infer TContext, any, infer TEvent, any, any, any, infer TResolvedTypesMeta> ? InternalMachineOptions<TContext, TEvent, TResolvedTypesMeta, TRequireMissingImplementations> : never;
+export declare type __ResolvedTypesMetaFrom<T> = T extends StateMachine<any, any, any, any, any, any, infer TResolvedTypesMeta> ? TResolvedTypesMeta : never;
 export interface ActorContext<TEvent extends EventObject, TEmitted> {
     parent?: ActorRef<any, any>;
     self: ActorRef<TEvent, TEmitted>;

package/es/utils.d.ts

@@ -1,7 +1,8 @@
-import { Event, StateValue, ActionType, Action, EventObject, PropertyMapper, Mapper, EventType, HistoryValue, AssignAction, Condition, Subscribable, StateMachine, ConditionPredicate, SCXML, StateLike, EventData, TransitionConfig, TransitionConfigTarget, NullEvent, SingleOrArray, Guard, InvokeSourceDefinition, Observer, Behavior } from './types';
+import { Event, StateValue, ActionType, Action, EventObject, PropertyMapper, Mapper, EventType, HistoryValue, AssignAction, Condition, Subscribable, ConditionPredicate, SCXML, StateLike, EventData, TransitionConfig, TransitionConfigTarget, NullEvent, SingleOrArray, Guard, InvokeSourceDefinition, Observer, Behavior } from './types';
 import { StateNode } from './StateNode';
 import { State } from './State';
 import { Actor } from './Actor';
+import { AnyStateMachine } from '.';
 export declare function keys<T extends object>(value: T): Array<keyof T & string>;
 export declare function matchesState(parentStateId: StateValue, childStateId: StateValue, delimiter?: string): boolean;
 export declare function getEventType<TEvent extends EventObject = EventObject>(event: Event<TEvent>): TEvent['type'];
@@ -52,12 +53,11 @@ export declare function isFunction(value: any): value is Function;
 export declare function isString(value: any): value is string;
 export declare function toGuard<TContext, TEvent extends EventObject>(condition?: Condition<TContext, TEvent>, guardMap?: Record<string, ConditionPredicate<TContext, TEvent>>): Guard<TContext, TEvent> | undefined;
 export declare function isObservable<T>(value: any): value is Subscribable<T>;
-export declare const symbolObservable: string | typeof Symbol.observable;
+export declare const symbolObservable: typeof Symbol.observable;
 export declare const interopSymbols: {
-    [x: string]: () => any;
     [Symbol.observable]: () => any;
 };
-export declare function isMachine(value: any): value is StateMachine<any, any, any>;
+export declare function isMachine(value: any): value is AnyStateMachine;
 export declare function isActor(value: any): value is Actor;
 export declare const uniqueId: () => string;
 export declare function toEventObject<TEvent extends EventObject>(event: Event<TEvent>, payload?: EventData): TEvent;
@@ -67,7 +67,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>, 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, 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>;
 export declare function createInvokeId(stateNodeId: string, index: number): string;

package/es/utils.js

@@ -460,9 +460,12 @@ function isObservable(value) {
 }
 var symbolObservable = /*#__PURE__*/function () {
   return typeof Symbol === 'function' && Symbol.observable || '@@observable';
-}();
+}(); // TODO: to be removed in v5, left it out just to minimize the scope of the change and maintain compatibility with older versions of integration paackages
+
 var interopSymbols = (_a = {}, _a[symbolObservable] = function () {
   return this;
+}, _a[Symbol.observable] = function () {
+  return this;
 }, _a);
 function isMachine(value) {
   try {
@@ -552,7 +555,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[guard.type];
+  var condFn = guards === null || guards === void 0 ? void 0 : guards[guard.type];
 
   if (!condFn) {
     throw new Error("Guard '".concat(guard.type, "' is not implemented on machine '").concat(machine.id, "'."));

package/lib/Actor.d.ts

@@ -1,5 +1,4 @@
-import { EventObject, Subscribable, InvokeDefinition, AnyEventObject, StateMachine, Spawnable, SCXML } from './types';
-import { ActorRef, BaseActorRef } from '.';
+import { EventObject, Subscribable, InvokeDefinition, AnyEventObject, StateMachine, Spawnable, SCXML, ActorRef, BaseActorRef } from './types';
 export interface Actor<TContext = any, TEvent extends EventObject = AnyEventObject> extends Subscribable<TContext> {
     id: string;
     send: (event: TEvent) => any;
@@ -22,5 +21,5 @@ export declare function createInvocableActor<TC, TE extends EventObject>(invokeD
 export declare function createDeferredActor(entity: Spawnable, id: string, data?: any): ActorRef<any, undefined>;
 export declare function isActor(item: any): item is ActorRef<any>;
 export declare function isSpawnedActor(item: any): item is ActorRef<any>;
-export declare function toActorRef<TEvent extends EventObject, TEmitted = any, TActorRefLike extends BaseActorRef<TEvent> = BaseActorRef<TEvent>>(actorRefLike: TActorRefLike): ActorRef<TEvent, TEmitted>;
+export declare function toActorRef<TEvent extends EventObject, TEmitted = any, TActorRefLike extends BaseActorRef<TEvent> = BaseActorRef<TEvent>>(actorRefLike: TActorRefLike): ActorRef<TEvent, TEmitted> & Omit<TActorRefLike, keyof ActorRef<any, any>>;
 //# sourceMappingURL=Actor.d.ts.map