xstate 4.35.2 → 5.0.0-alpha.1

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

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

package/{lib/devTools.d.ts → dist/declarations/src/dev/index.d.ts}

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

package/{es → dist/declarations/src}/environment.d.ts

@@ -1,2 +1 @@
-export declare const IS_PRODUCTION: boolean;
-//# sourceMappingURL=environment.d.ts.map
+export declare const IS_PRODUCTION: boolean;

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

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

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

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

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

@@ -0,0 +1,108 @@
+import type { AnyActorRef, AnyStateMachine, Behavior, EventFromBehavior, InterpreterFrom, SnapshotFrom } from './types';
+import { AreAllImplementationsAssumedToBeProvided } from './typegenTypes';
+import { ActorRef, DoneEvent, EventObject, InteropSubscribable, InterpreterOptions, Observer, SCXML, SendActionObject, StateValue, Subscription } from './types';
+import { symbolObservable } from './symbolObservable';
+export declare type SnapshotListener<TBehavior extends Behavior<any, any>> = (state: SnapshotFrom<TBehavior>) => void;
+export declare type EventListener<TEvent extends EventObject = EventObject> = (event: TEvent) => void;
+export declare type Listener = () => void;
+export declare type ErrorListener = (error: any) => void;
+export interface Clock {
+    setTimeout(fn: (...args: any[]) => void, timeout: number): any;
+    clearTimeout(id: any): void;
+}
+export declare enum ActorStatus {
+    NotStarted = 0,
+    Running = 1,
+    Stopped = 2
+}
+declare type InternalStateFrom<TBehavior extends Behavior<any, any, any>> = TBehavior extends Behavior<infer _, infer __, infer TInternalState> ? TInternalState : never;
+export declare class Interpreter<TBehavior extends Behavior<any, any>, TEvent extends EventObject = EventFromBehavior<TBehavior>> implements ActorRef<TEvent, SnapshotFrom<TBehavior>> {
+    behavior: TBehavior;
+    /**
+     * The current state of the interpreted behavior.
+     */
+    private _state?;
+    /**
+     * The clock that is responsible for setting and clearing timeouts, such as delayed events and transitions.
+     */
+    clock: Clock;
+    options: Readonly<InterpreterOptions>;
+    /**
+     * The unique identifier for this actor relative to its parent.
+     */
+    id: string;
+    private mailbox;
+    private delayedEventsMap;
+    private observers;
+    private logger;
+    /**
+     * Whether the service is started.
+     */
+    status: ActorStatus;
+    _parent?: ActorRef<any>;
+    ref: ActorRef<TEvent>;
+    private _actorContext;
+    /**
+     * The globally unique process ID for this invocation.
+     */
+    sessionId: string;
+    _forwardTo: Set<AnyActorRef>;
+    /**
+     * Creates a new Interpreter instance (i.e., service) for the given behavior with the provided options, if any.
+     *
+     * @param behavior The behavior to be interpreted
+     * @param options Interpreter options
+     */
+    constructor(behavior: TBehavior, options?: InterpreterOptions);
+    private _deferred;
+    private _getInitialState;
+    private update;
+    onTransition(listener: SnapshotListener<TBehavior>): this;
+    subscribe(observer: Observer<SnapshotFrom<TBehavior>>): Subscription;
+    subscribe(nextListener?: (state: SnapshotFrom<TBehavior>) => void, errorListener?: (error: any) => void, completeListener?: () => void): Subscription;
+    /**
+     * Adds a state listener that is notified when the statechart has reached its final state.
+     * @param listener The state listener
+     */
+    onDone(listener: EventListener<DoneEvent>): this;
+    /**
+     * Starts the interpreter from the given state, or the initial state.
+     * @param initialState The state to start the statechart from
+     */
+    start(initialState?: InternalStateFrom<TBehavior> | StateValue): this;
+    private _process;
+    /**
+     * Stops the interpreter and unsubscribe all listeners.
+     */
+    stop(): this;
+    private _complete;
+    private _stop;
+    /**
+     * Sends an event to the running interpreter to trigger a transition.
+     *
+     * An array of events (batched) can be sent as well, which will send all
+     * batched events to the running interpreter. The listeners will be
+     * notified only **once** when all events are processed.
+     *
+     * @param event The event(s) to send
+     */
+    send(event: TEvent | SCXML.Event<TEvent>): void;
+    private forward;
+    delaySend(sendAction: SendActionObject): void;
+    cancel(sendId: string | number): void;
+    private attachDevTools;
+    toJSON(): {
+        id: string;
+    };
+    [Symbol.observable](): InteropSubscribable<SnapshotFrom<TBehavior>>;
+    getSnapshot(): SnapshotFrom<TBehavior>;
+}
+/**
+ * Creates a new Interpreter instance for the given machine with the provided options, if any.
+ *
+ * @param machine The machine to interpret
+ * @param options Interpreter options
+ */
+export declare function interpret<TMachine extends AnyStateMachine>(machine: AreAllImplementationsAssumedToBeProvided<TMachine['__TResolvedTypesMeta']> extends true ? TMachine : 'Some implementations missing', options?: InterpreterOptions): InterpreterFrom<TMachine>;
+export declare function interpret<TBehavior extends Behavior<any, any>>(behavior: TBehavior, options?: InterpreterOptions): Interpreter<TBehavior>;
+export {};

package/{es → dist/declarations/src}/mapState.d.ts

@@ -1,4 +1,3 @@
-export declare function mapState(stateMap: {
-    [stateId: string]: any;
-}, stateId: string): any;
-//# sourceMappingURL=mapState.d.ts.map
+export declare function mapState(stateMap: {
+    [stateId: string]: any;
+}, stateId: string): any;

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

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

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

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

package/{es → dist/declarations/src}/schema.d.ts

@@ -1,3 +1,2 @@
-export declare function createSchema<T>(schema?: any): T;
-export declare const t: typeof createSchema;
-//# sourceMappingURL=schema.d.ts.map
+export declare function createSchema<T>(schema?: any): T;
+export declare const t: typeof createSchema;

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

@@ -0,0 +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;

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

@@ -0,0 +1,70 @@
+import { BaseActionObject, EventObject, StateValue, TransitionConfig, TransitionDefinition, SingleOrArray, SCXML, StateValueMap, InitialTransitionConfig, MachineContext } from './types';
+import { State } from './State';
+import { NULL_EVENT } from './constants';
+import type { StateNode } from './StateNode';
+import { ActorContext, AnyHistoryValue, AnyState, AnyStateMachine, AnyStateNode, AnyTransitionDefinition, DelayedTransitionDefinition, InitialTransitionDefinition, StateFromMachine } from '.';
+declare type Configuration<TContext extends MachineContext, TE extends EventObject> = Iterable<StateNode<TContext, TE>>;
+declare type AnyConfiguration = Configuration<any, any>;
+declare 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: ActorContext<any, any> | 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: ActorContext<any, any> | undefined): {
+    nextState: AnyState;
+};
+export declare function macrostep<TMachine extends AnyStateMachine>(state: StateFromMachine<TMachine>, scxmlEvent: SCXML.Event<TMachine['__TEvent']>, actorCtx: ActorContext<any, any> | 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/{lib → dist/declarations/src}/typegenTypes.d.ts

@@ -1,133 +1,132 @@
-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 {
-    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;
-        delays: never;
-        guards: never;
-        services: never;
-    };
-}
-export interface MarkAllImplementationsAsProvided<TResolvedTypesMeta> {
-    '@@xstate/typegen': Prop<TResolvedTypesMeta, '@@xstate/typegen'>;
-    resolved: Prop<TResolvedTypesMeta, 'resolved'> & AllImplementationsProvided;
-}
-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 interface ResolveTypegenMeta<TTypesMeta extends TypegenConstraint, TEvent extends EventObject, TAction extends BaseActionObject, TServiceMap extends ServiceMap> {
-    '@@xstate/typegen': TTypesMeta['@@xstate/typegen'];
-    resolved: {
-        enabled: TTypesMeta & {
-            indexedActions: IndexByType<TAction>;
-            indexedEvents: MergeWithInternalEvents<IndexByType<(string extends TEvent['type'] ? never : TEvent) | GenerateServiceEvents<TServiceMap, 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 {};
-//# sourceMappingURL=typegenTypes.d.ts.map
+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 {};