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

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 { InvokeActionObject, AnyStateMachine, Spawner, ActorRef, MachineContext, EventObject, SCXML } from '.';
+export declare function createSpawner<TContext extends MachineContext, TEvent extends EventObject>(self: ActorRef<any, any> | undefined, machine: AnyStateMachine, context: TContext, _event: SCXML.Event<TEvent>, mutCapturedActions: InvokeActionObject[]): Spawner;

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

@@ -1,85 +1,70 @@
-import { BaseActionObject, EventObject, StateValue, TransitionConfig, TransitionDefinition, DelayedTransitionDefinition, SingleOrArray, SCXML, Transitions, StateValueMap, HistoryValue, InitialTransitionConfig, InitialTransitionDefinition, Event, MachineContext } from './types';
-import { State } from './State';
-import { NULL_EVENT } from './constants';
-import type { StateMachine } from './StateMachine';
-import type { StateNode } from './StateNode';
-import { AnyStateMachine } from '.';
-declare type Configuration<TContext extends MachineContext, TE extends EventObject> = Iterable<StateNode<TContext, TE>>;
-declare type AdjList<TContext extends MachineContext, TE extends EventObject> = Map<StateNode<TContext, TE>, Array<StateNode<TContext, TE>>>;
-export declare const isAtomicStateNode: (stateNode: StateNode<any, any>) => boolean;
-export declare function getChildren<TContext extends MachineContext, TE extends EventObject>(stateNode: StateNode<TContext, TE>): Array<StateNode<TContext, TE>>;
-export declare function getProperAncestors<TContext extends MachineContext, TEvent extends EventObject>(stateNode: StateNode<TContext, TEvent>, toStateNode: StateNode<TContext, TEvent> | null): Array<typeof stateNode>;
-export declare function getAllStateNodes<TContext extends MachineContext, TE extends EventObject>(stateNode: StateNode<TContext, TE>): Array<StateNode<TContext, TE>>;
-export declare function getConfiguration<TC extends MachineContext, TE extends EventObject>(stateNodes: Iterable<StateNode<TC, TE>>): Set<StateNode<TC, TE>>;
-export declare function getAdjList<TContext extends MachineContext, TE extends EventObject>(configuration: Configuration<TContext, TE>): AdjList<TContext, TE>;
-export declare function getStateValue<TContext extends MachineContext, TE extends EventObject>(rootNode: StateNode<TContext, TE>, configuration: Configuration<TContext, TE>): StateValue;
-export declare function has<T>(iterable: Iterable<T>, item: T): boolean;
-export declare function nextEvents<TContext extends MachineContext, TE extends EventObject>(configuration: Array<StateNode<TContext, TE>>): Array<TE['type']>;
-export declare function isInFinalState<TContext extends MachineContext, TE extends EventObject>(configuration: Array<StateNode<TContext, TE>>, stateNode?: StateNode<TContext, TE>): boolean;
-export declare const isStateId: (str: string) => boolean;
-export declare function getCandidates<TEvent extends EventObject>(stateNode: StateNode<any, TEvent>, receivedEventType: TEvent['type'], 
-/**
- * If `true`, will use SCXML event partial token matching semantics
- * without the need for the ".*" suffix
- */
-partialMatch?: boolean): Array<TransitionDefinition<any, TEvent>>;
-/**
- * All delayed transitions from the config.
- */
-export declare function getDelayedTransitions<TContext extends MachineContext, TEvent extends EventObject>(stateNode: StateNode<TContext, TEvent>): Array<DelayedTransitionDefinition<TContext, TEvent>>;
-export declare function formatTransition<TContext extends MachineContext, TEvent extends EventObject>(stateNode: StateNode<TContext, TEvent>, transitionConfig: TransitionConfig<TContext, TEvent> & {
-    event: TEvent['type'] | typeof NULL_EVENT | '*';
-}): TransitionDefinition<TContext, TEvent>;
-export declare function formatTransitions<TContext extends MachineContext, TEvent extends EventObject>(stateNode: StateNode<TContext, TEvent>): Array<TransitionDefinition<TContext, TEvent>>;
-export declare function formatInitialTransition<TContext extends MachineContext, TEvent extends EventObject>(stateNode: StateNode<TContext, TEvent>, _target: SingleOrArray<string> | InitialTransitionConfig<TContext, TEvent>): InitialTransitionDefinition<TContext, TEvent>;
-export declare function resolveTarget<TContext extends MachineContext, TEvent extends EventObject>(stateNode: StateNode<TContext, TEvent>, _target: Array<string | StateNode<TContext, TEvent>> | undefined): Array<StateNode<TContext, TEvent>> | undefined;
-export declare function getInitialStateNodes<TContext extends MachineContext, TEvent extends EventObject>(stateNode: StateNode<TContext, TEvent>): Array<StateNode<TContext, TEvent>>;
-/**
- * Returns the child state node from its relative `stateKey`, or throws.
- */
-export declare function getStateNode<TContext extends MachineContext, TEvent extends EventObject>(stateNode: StateNode<TContext, TEvent>, stateKey: string): StateNode<TContext, TEvent>;
-/**
- * Returns the state nodes represented by the current state value.
- *
- * @param state The state value or State instance
- */
-export declare function getStateNodes<TContext extends MachineContext, TEvent extends EventObject>(stateNode: StateNode<TContext, TEvent>, state: StateValue | State<TContext, TEvent>): Array<StateNode<TContext, TEvent>>;
-export declare function transitionLeafNode<TContext extends MachineContext, TEvent extends EventObject>(stateNode: StateNode<TContext, TEvent>, stateValue: string, state: State<TContext, TEvent>, _event: SCXML.Event<TEvent>): Transitions<TContext, TEvent> | undefined;
-export declare function transitionCompoundNode<TContext extends MachineContext, TEvent extends EventObject>(stateNode: StateNode<TContext, TEvent>, stateValue: StateValueMap, state: State<TContext, TEvent>, _event: SCXML.Event<TEvent>): Transitions<TContext, TEvent> | undefined;
-export declare function transitionParallelNode<TContext extends MachineContext, TEvent extends EventObject>(stateNode: StateNode<TContext, TEvent>, stateValue: StateValueMap, state: State<TContext, TEvent>, _event: SCXML.Event<TEvent>): Transitions<TContext, TEvent> | undefined;
-export declare function transitionNode<TContext extends MachineContext, TEvent extends EventObject>(stateNode: StateNode<TContext, TEvent>, stateValue: StateValue, state: State<TContext, TEvent, any>, _event: SCXML.Event<TEvent>): Transitions<TContext, TEvent> | undefined;
-export declare function removeConflictingTransitions<TContext extends MachineContext, TEvent extends EventObject>(enabledTransitions: Array<TransitionDefinition<TContext, TEvent>>, configuration: Set<StateNode<TContext, TEvent>>, state: State<TContext, TEvent>): Array<TransitionDefinition<TContext, TEvent>>;
-export declare function enterStates<TContext extends MachineContext, TEvent extends EventObject>(transitions: Array<TransitionDefinition<TContext, TEvent>>, mutConfiguration: Set<StateNode<TContext, TEvent>>, state: State<TContext, TEvent>): {
-    statesToInvoke: Set<StateNode<TContext, TEvent>>;
-    internalQueue: SCXML.Event<TEvent>[];
-    actions: BaseActionObject[];
-};
-/**
- * https://www.w3.org/TR/scxml/#microstepProcedure
- *
- * @private
- * @param transitions
- * @param currentState
- * @param mutConfiguration
- */
-export declare function microstep<TContext extends MachineContext, TEvent extends EventObject>(transitions: Array<TransitionDefinition<TContext, TEvent>>, currentState: State<TContext, TEvent>, context: TContext, mutConfiguration: Set<StateNode<TContext, TEvent>>, machine: StateMachine<TContext, TEvent>, _event: SCXML.Event<TEvent>): {
-    actions: BaseActionObject[];
-    configuration: typeof mutConfiguration;
-    historyValue: HistoryValue<TContext, TEvent>;
-    internalQueue: Array<SCXML.Event<TEvent>>;
-    context: TContext;
-};
-export declare function resolveMicroTransition<TContext extends MachineContext, TEvent extends EventObject>(machine: StateMachine<TContext, TEvent, any, any, any>, transitions: Transitions<TContext, TEvent>, currentState: State<TContext, TEvent, any>, _event?: SCXML.Event<TEvent>): State<TContext, TEvent, any>;
-declare type StateFromMachine<TMachine extends AnyStateMachine> = TMachine['initialState'];
-export declare function macrostep<TMachine extends AnyStateMachine>(state: StateFromMachine<TMachine>, event: Event<TMachine['__TEvent']> | SCXML.Event<TMachine['__TEvent']> | null, machine: TMachine): typeof state;
-/**
- * Resolves a partial state value with its full representation in the state node's machine.
- *
- * @param stateValue The partial state value to resolve.
- */
-export declare function resolveStateValue<TContext extends MachineContext, TEvent extends EventObject>(rootNode: StateNode<TContext, TEvent>, stateValue: StateValue): StateValue;
-export declare function toState<TMachine extends AnyStateMachine>(state: StateValue | TMachine['initialState'], machine: TMachine): StateFromMachine<TMachine>;
-export declare function stateValuesEqual(a: StateValue | undefined, b: StateValue | undefined): boolean;
-export declare function getMeta(configuration?: Array<StateNode<any, any>>): Record<string, any>;
-export declare function getTagsFromConfiguration(configuration: Array<StateNode<any, any>>): Set<string>;
-export {};
+import { BaseActionObject, EventObject, StateValue, TransitionConfig, TransitionDefinition, SingleOrArray, SCXML, StateValueMap, InitialTransitionConfig, MachineContext } from './types.js';
+import { State } from './State.js';
+import { NULL_EVENT } from './constants.js';
+import type { StateNode } from './StateNode.js';
+import { AnyActorContext, AnyHistoryValue, AnyState, AnyStateMachine, AnyStateNode, AnyTransitionDefinition, DelayedTransitionDefinition, InitialTransitionDefinition, StateFromMachine } from '.';
+type Configuration<TContext extends MachineContext, TE extends EventObject> = Iterable<StateNode<TContext, TE>>;
+type AnyConfiguration = Configuration<any, any>;
+type AdjList = Map<AnyStateNode, Array<AnyStateNode>>;
+export declare function getConfiguration(stateNodes: Iterable<AnyStateNode>): Set<AnyStateNode>;
+export declare function getAdjList<TContext extends MachineContext, TE extends EventObject>(configuration: Configuration<TContext, TE>): AdjList;
+export declare function getStateValue(rootNode: AnyStateNode, configuration: AnyConfiguration): StateValue;
+export declare function isInFinalState(configuration: Array<AnyStateNode>, stateNode?: AnyStateNode): boolean;
+export declare const isStateId: (str: string) => boolean;
+export declare function getCandidates<TEvent extends EventObject>(stateNode: StateNode<any, TEvent>, receivedEventType: TEvent['type'], 
+/**
+ * If `true`, will use SCXML event partial token matching semantics
+ * without the need for the ".*" suffix
+ */
+partialMatch?: boolean): Array<TransitionDefinition<any, TEvent>>;
+/**
+ * All delayed transitions from the config.
+ */
+export declare function getDelayedTransitions<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode): Array<DelayedTransitionDefinition<TContext, TEvent>>;
+export declare function formatTransition<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, transitionConfig: TransitionConfig<TContext, TEvent> & {
+    event: TEvent['type'] | typeof NULL_EVENT | '*';
+}): AnyTransitionDefinition;
+export declare function formatTransitions<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode): Array<AnyTransitionDefinition>;
+export declare function formatInitialTransition<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, _target: SingleOrArray<string> | InitialTransitionConfig<TContext, TEvent>): InitialTransitionDefinition<TContext, TEvent>;
+export declare function resolveTarget(stateNode: AnyStateNode, targets: Array<string | AnyStateNode> | undefined): Array<AnyStateNode> | undefined;
+export declare function getInitialStateNodes(stateNode: AnyStateNode): Array<AnyStateNode>;
+/**
+ * Returns the child state node from its relative `stateKey`, or throws.
+ */
+export declare function getStateNode(stateNode: AnyStateNode, stateKey: string): AnyStateNode;
+/**
+ * Returns the state nodes represented by the current state value.
+ *
+ * @param state The state value or State instance
+ */
+export declare function getStateNodes<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, state: StateValue | State<TContext, TEvent>): Array<AnyStateNode>;
+export declare function transitionAtomicNode<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, stateValue: string, state: State<TContext, TEvent>, _event: SCXML.Event<TEvent>): Array<TransitionDefinition<TContext, TEvent>> | undefined;
+export declare function transitionCompoundNode<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, stateValue: StateValueMap, state: State<TContext, TEvent>, _event: SCXML.Event<TEvent>): Array<TransitionDefinition<TContext, TEvent>> | undefined;
+export declare function transitionParallelNode<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, stateValue: StateValueMap, state: State<TContext, TEvent>, _event: SCXML.Event<TEvent>): Array<TransitionDefinition<TContext, TEvent>> | undefined;
+export declare function transitionNode<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, stateValue: StateValue, state: State<TContext, TEvent, any>, _event: SCXML.Event<TEvent>): Array<TransitionDefinition<TContext, TEvent>> | undefined;
+export declare function removeConflictingTransitions(enabledTransitions: Array<AnyTransitionDefinition>, configuration: Set<AnyStateNode>, historyValue: AnyHistoryValue): Array<AnyTransitionDefinition>;
+/**
+ * https://www.w3.org/TR/scxml/#microstepProcedure
+ *
+ * @private
+ * @param transitions
+ * @param currentState
+ * @param mutConfiguration
+ */
+export declare function microstep<TContext extends MachineContext, TEvent extends EventObject>(transitions: Array<TransitionDefinition<TContext, TEvent>>, currentState: State<TContext, TEvent, any>, actorCtx: AnyActorContext | undefined, scxmlEvent: SCXML.Event<TEvent>): State<TContext, TEvent, any>;
+export declare function resolveActionsAndContext<TContext extends MachineContext, TEvent extends EventObject>(actions: BaseActionObject[], scxmlEvent: SCXML.Event<TEvent>, currentState: State<TContext, TEvent, any>, actorCtx: AnyActorContext | undefined): {
+    nextState: AnyState;
+};
+export declare function macrostep<TMachine extends AnyStateMachine>(state: StateFromMachine<TMachine>, scxmlEvent: SCXML.Event<TMachine['__TEvent']>, actorCtx: AnyActorContext | undefined): {
+    state: typeof state;
+    microstates: Array<typeof state>;
+};
+/**
+ * Resolves a partial state value with its full representation in the state node's machine.
+ *
+ * @param stateValue The partial state value to resolve.
+ */
+export declare function resolveStateValue(rootNode: AnyStateNode, stateValue: StateValue): StateValue;
+export declare function stateValuesEqual(a: StateValue | undefined, b: StateValue | undefined): boolean;
+export declare function getInitialConfiguration(rootNode: AnyStateNode): AnyStateNode[];
+export {};

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

@@ -0,0 +1 @@
+export declare const symbolObservable: typeof Symbol.observable;

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

@@ -0,0 +1,2 @@
+import { ActorSystem, ActorSystemInfo } from './types.js';
+export declare function createSystem<T extends ActorSystemInfo>(): ActorSystem<T>;

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

@@ -1,132 +1,132 @@
-import { BaseActionObject, EventObject, IndexByType, IsNever, Prop, Values, IsAny, ActorMap, 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;
-        actors: string;
-        delays: string;
-        guards: string;
-    };
-    /**
-     * A map for the internal events of the machine.
-     *
-     * key: 'done.invoke.myActor'
-     * value: {
-     *   type: 'done.invoke.myActor';
-     *   data: unknown;
-     *   __tip: 'Declare the type in event types!';
-     * }
-     */
-    internalEvents: {};
-    /**
-     * Maps the name of the actor 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
-     * actors.
-     *
-     * Key: 'EVENT_NAME'
-     * Value: 'actorName' | 'otherActorName'
-     */
-    eventsCausingActors: Record<string, string>;
-}
-export interface ResolvedTypegenMeta extends TypegenMeta {
-    resolved: TypegenMeta & {
-        indexedActions: Record<string, BaseActionObject>;
-        indexedEvents: Record<string, EventObject>;
-    };
-}
-export declare type TypegenConstraint = TypegenEnabled | TypegenDisabled;
-export declare type AreAllImplementationsAssumedToBeProvided<TResolvedTypesMeta, TMissingImplementations = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'missingImplementations'>> = IsAny<TResolvedTypesMeta> extends true ? true : TResolvedTypesMeta extends TypegenEnabled ? IsNever<Values<{
-    [K in keyof TMissingImplementations]: TMissingImplementations[K];
-}>> extends true ? true : false : true;
-interface AllImplementationsProvided {
-    missingImplementations: {
-        actions: never;
-        actors: never;
-        delays: never;
-        guards: never;
-    };
-}
-export interface MarkAllImplementationsAsProvided<TResolvedTypesMeta> {
-    '@@xstate/typegen': Prop<TResolvedTypesMeta, '@@xstate/typegen'>;
-    resolved: Prop<TResolvedTypesMeta, 'resolved'> & AllImplementationsProvided;
-}
-declare type GenerateActorEvent<TActorName, TEventType, TActorMap extends ActorMap> = TEventType extends any ? {
-    type: TEventType;
-} & Prop<TActorMap, TActorName> : never;
-declare type GenerateActorEvents<TActorMap extends ActorMap, TInvokeSrcNameMap> = string extends keyof TActorMap ? never : Cast<{
-    [K in keyof TInvokeSrcNameMap]: GenerateActorEvent<K, TInvokeSrcNameMap[K], TActorMap>;
-}[keyof TInvokeSrcNameMap], EventObject>;
-declare type MergeWithInternalEvents<TIndexedEvents, TInternalEvents> = TIndexedEvents & Pick<TInternalEvents, Exclude<keyof TInternalEvents, keyof TIndexedEvents>>;
-declare type AllowAllEvents = {
-    eventsCausingActions: Record<string, string>;
-    eventsCausingActors: Record<string, string>;
-    eventsCausingDelays: Record<string, string>;
-    eventsCausingGuards: Record<string, string>;
-};
-export interface ResolveTypegenMeta<TTypesMeta extends TypegenConstraint, TEvent extends EventObject, TAction extends BaseActionObject, TActorMap extends ActorMap> {
-    '@@xstate/typegen': TTypesMeta['@@xstate/typegen'];
-    resolved: {
-        enabled: TTypesMeta & {
-            indexedActions: IndexByType<TAction>;
-            indexedEvents: MergeWithInternalEvents<IndexByType<(string extends TEvent['type'] ? never : TEvent) | GenerateActorEvents<TActorMap, Prop<TTypesMeta, 'invokeSrcNameMap'>>>, Prop<TTypesMeta, 'internalEvents'>>;
-        };
-        disabled: TypegenDisabled & AllImplementationsProvided & 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__'>;
-        };
-    }[IsNever<TTypesMeta> extends true ? 'disabled' : TTypesMeta extends TypegenEnabled ? 'enabled' : 'disabled'];
-}
-export {};
+import { EventObject, IndexByType, IsNever, Prop, Values, IsAny, ActorMap, Cast, ParameterizedObject } from './types.js';
+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;
+        actors: string;
+        delays: string;
+        guards: string;
+    };
+    /**
+     * A map for the internal events of the machine.
+     *
+     * key: 'done.invoke.myActor'
+     * value: {
+     *   type: 'done.invoke.myActor';
+     *   data: unknown;
+     *   __tip: 'Declare the type in event types!';
+     * }
+     */
+    internalEvents: {};
+    /**
+     * Maps the name of the actor 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
+     * actors.
+     *
+     * Key: 'EVENT_NAME'
+     * Value: 'actorName' | 'otherActorName'
+     */
+    eventsCausingActors: Record<string, string>;
+}
+export interface ResolvedTypegenMeta extends TypegenMeta {
+    resolved: TypegenMeta & {
+        indexedActions: Record<string, ParameterizedObject>;
+        indexedEvents: Record<string, EventObject>;
+    };
+}
+export type TypegenConstraint = TypegenEnabled | TypegenDisabled;
+export type AreAllImplementationsAssumedToBeProvided<TResolvedTypesMeta, TMissingImplementations = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'missingImplementations'>> = IsAny<TResolvedTypesMeta> extends true ? true : TResolvedTypesMeta extends TypegenEnabled ? IsNever<Values<{
+    [K in keyof TMissingImplementations]: TMissingImplementations[K];
+}>> extends true ? true : false : true;
+interface AllImplementationsProvided {
+    missingImplementations: {
+        actions: never;
+        actors: never;
+        delays: never;
+        guards: never;
+    };
+}
+export interface MarkAllImplementationsAsProvided<TResolvedTypesMeta> {
+    '@@xstate/typegen': Prop<TResolvedTypesMeta, '@@xstate/typegen'>;
+    resolved: Prop<TResolvedTypesMeta, 'resolved'> & AllImplementationsProvided;
+}
+type GenerateActorEvent<TActorName, TEventType, TActorMap extends ActorMap> = TEventType extends any ? {
+    type: TEventType;
+} & Prop<TActorMap, TActorName> : never;
+type GenerateActorEvents<TActorMap extends ActorMap, TInvokeSrcNameMap> = string extends keyof TActorMap ? never : Cast<{
+    [K in keyof TInvokeSrcNameMap]: GenerateActorEvent<K, TInvokeSrcNameMap[K], TActorMap>;
+}[keyof TInvokeSrcNameMap], EventObject>;
+type MergeWithInternalEvents<TIndexedEvents, TInternalEvents> = TIndexedEvents & Pick<TInternalEvents, Exclude<keyof TInternalEvents, keyof TIndexedEvents>>;
+type AllowAllEvents = {
+    eventsCausingActions: Record<string, string>;
+    eventsCausingActors: Record<string, string>;
+    eventsCausingDelays: Record<string, string>;
+    eventsCausingGuards: Record<string, string>;
+};
+export interface ResolveTypegenMeta<TTypesMeta extends TypegenConstraint, TEvent extends EventObject, TAction extends ParameterizedObject, TActorMap extends ActorMap> {
+    '@@xstate/typegen': TTypesMeta['@@xstate/typegen'];
+    resolved: {
+        enabled: TTypesMeta & {
+            indexedActions: IndexByType<TAction>;
+            indexedEvents: MergeWithInternalEvents<IndexByType<(string extends TEvent['type'] ? never : TEvent) | GenerateActorEvents<TActorMap, Prop<TTypesMeta, 'invokeSrcNameMap'>>>, Prop<TTypesMeta, 'internalEvents'>>;
+        };
+        disabled: TypegenDisabled & AllImplementationsProvided & 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__'>;
+        };
+    }[IsNever<TTypesMeta> extends true ? 'disabled' : TTypesMeta extends TypegenEnabled ? 'enabled' : 'disabled'];
+}
+export {};