@systemfsoftware/xstate 0.0.0-bootstrap.0 → 6.0.0-beta.65

package/dist/types-B2EAwOk-.d.ts

@@ -0,0 +1,3511 @@
+import { a as InferInternalEvents, d as SetupStateSchemas, f as StandardSchemaV1, i as InferEvents, n as EventObject, o as MachineContext, r as GuardSchemas, t as ActionSchemas, u as Values$1 } from "./base.types-DF8ZPiXj.js";
+/** @public */
+declare function isMachineSnapshot(value: unknown): value is AnyMachineSnapshot;
+type Values<T> = T[keyof T];
+type MatchingObjectStateValue<TStateValue extends Record<string, unknown>, TTestStateValue extends Record<string, unknown>> = false extends Values<{ [K in keyof TTestStateValue]: K extends keyof TStateValue ? NonNullable<TStateValue[K]> extends StateValue ? NonNullable<TTestStateValue[K]> extends StateValue ? [MatchingStateValue<NonNullable<TStateValue[K]>, NonNullable<TTestStateValue[K]>>] extends [never] ? false : true : false : false : false; }> ? never : { [K in keyof TStateValue]: K extends keyof TTestStateValue ? MatchingStateValue<NonNullable<TStateValue[K]>, NonNullable<TTestStateValue[K]>> : TStateValue[K]; };
+type MatchingStateValue<TStateValue extends StateValue, TTestStateValue extends StateValue> = StateValue extends TTestStateValue ? TStateValue : string extends TTestStateValue ? TStateValue : TStateValue extends unknown ? TTestStateValue extends string ? TStateValue extends string ? TTestStateValue extends TStateValue ? TTestStateValue : Extract<TStateValue, TTestStateValue> : TStateValue extends Record<string, unknown> ? TStateValue & Record<TTestStateValue, StateValue | undefined> : never : TTestStateValue extends Record<string, unknown> ? TStateValue extends Record<string, unknown> ? MatchingObjectStateValue<TStateValue, TTestStateValue> : never : never : never;
+interface MachineSnapshotBase<TContext extends MachineContext, TEvent extends EventObject, TChildren extends Record<string, AnyActorRef | undefined>, TStateValue extends StateValue, TTag extends string, _TOutput, TMeta extends MetaObject, TStateSchema extends StateSchema = StateSchema> {
+  /** The state machine that produced this state snapshot. */
+  machine: AnyStateMachine;
+  /** The tags of the active state nodes that represent the current state value. */
+  tags: Set<string>;
+  /**
+   * The current state value.
+   *
+   * This represents the active state nodes in the state machine.
+   *
+   * - For atomic state nodes, it is a string.
+   * - For compound parent state nodes, it is an object where:
+   *
+   *   - The key is the parent state node's key
+   *   - The value is the current state value of the active child state node(s)
+   *
+   * @example
+   *
+   * ```ts
+   * // single-level state node
+   * snapshot.value; // => 'yellow'
+   *
+   * // nested state nodes
+   * snapshot.value; // => { red: 'wait' }
+   * ```
+   */
+  value: TStateValue;
+  /** The current status of this snapshot. */
+  status: SnapshotStatus;
+  error: unknown;
+  context: TContext;
+  historyValue: Readonly<HistoryValue>;
+  /** The enabled state nodes representative of the state value. */
+  nodes: Array<AnyStateNode>;
+  /** An object mapping actor names to spawned/invoked actors. */
+  children: TChildren;
+  /** Pending logical timers owned by this machine snapshot. */
+  timers: Readonly<Record<string, LogicalTimer>>;
+  /**
+   * Whether the current state value is a subset of the given partial state
+   * value.
+   *
+   * @param partialStateValue
+   */
+  matches<const TTestStateValue extends string>(partialStateValue: TTestStateValue, ...args: string extends TTestStateValue ? [never] : []): this is MachineSnapshot<StateContextFromStateValue<TStateSchema, TContext, TTestStateValue>, TEvent, TChildren, MatchingStateValue<TStateValue, TTestStateValue>, TTag, _TOutput, TMeta, TStateSchema>;
+  matches<const TTestStateValue extends StateValueMap>(partialStateValue: TTestStateValue, ...args: string extends keyof TTestStateValue ? [never] : []): this is MachineSnapshot<StateContextFromStateValue<TStateSchema, TContext, TTestStateValue>, TEvent, TChildren, MatchingStateValue<TStateValue, TTestStateValue>, TTag, _TOutput, TMeta, TStateSchema>;
+  matches(partialStateValue: StateValue): boolean;
+  /**
+   * Whether the current state nodes has a state node with the specified `tag`.
+   *
+   * @param tag
+   */
+  hasTag: (tag: TTag) => boolean;
+  /**
+   * Determines whether sending the `event` will cause a non-forbidden
+   * transition to be selected, even if the transitions have no actions nor
+   * change the state value.
+   *
+   * @param event The event to test
+   * @returns Whether the event will cause a transition
+   */
+  can: (event: TEvent) => boolean;
+  getMeta: () => Record<StateId<TStateSchema> & string, TMeta | undefined>;
+  /**
+   * Returns the inputs for the current active state nodes, keyed by state node
+   * id.
+   */
+  getInputs: () => StateIdInputs<TStateSchema>;
+  toJSON: () => unknown;
+}
+interface ActiveMachineSnapshot<TContext extends MachineContext, TEvent extends EventObject, TChildren extends Record<string, AnyActorRef | undefined>, TStateValue extends StateValue, TTag extends string, TOutput, TMeta extends MetaObject, TStateSchema extends StateSchema> extends MachineSnapshotBase<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TStateSchema> {
+  status: 'active';
+  output: undefined;
+  error: undefined;
+}
+interface DoneMachineSnapshot<TContext extends MachineContext, TEvent extends EventObject, TChildren extends Record<string, AnyActorRef | undefined>, TStateValue extends StateValue, TTag extends string, TOutput, TMeta extends MetaObject, TStateSchema extends StateSchema> extends MachineSnapshotBase<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TStateSchema> {
+  status: 'done';
+  output: TOutput;
+  error: undefined;
+}
+interface ErrorMachineSnapshot<TContext extends MachineContext, TEvent extends EventObject, TChildren extends Record<string, AnyActorRef | undefined>, TStateValue extends StateValue, TTag extends string, TOutput, TMeta extends MetaObject, TStateSchema extends StateSchema> extends MachineSnapshotBase<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TStateSchema> {
+  status: 'error';
+  output: undefined;
+  error: unknown;
+}
+interface StoppedMachineSnapshot<TContext extends MachineContext, TEvent extends EventObject, TChildren extends Record<string, AnyActorRef | undefined>, TStateValue extends StateValue, TTag extends string, TOutput, TMeta extends MetaObject, TStateSchema extends StateSchema> extends MachineSnapshotBase<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TStateSchema> {
+  status: 'stopped';
+  output: undefined;
+  error: undefined;
+}
+/** @public */
+type MachineSnapshot<TContext extends MachineContext, TEvent extends EventObject, TChildren extends Record<string, AnyActorRef | undefined>, TStateValue extends StateValue, TTag extends string, TOutput, TMeta extends MetaObject, TStateSchema extends StateSchema> = ActiveMachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TStateSchema> | DoneMachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TStateSchema> | ErrorMachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TStateSchema> | StoppedMachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TStateSchema>;
+/** Type-only metadata for validating setup-created invoke transitions. */
+declare const createdInvokeConfig: unique symbol;
+type InferOutput<T extends StandardSchemaV1, U> = Compute<StandardSchemaV1.InferOutput<T> extends U ? StandardSchemaV1.InferOutput<T> : never>;
+/**
+ * The machine input type declared by an input schema, or `unknown` when no
+ * input schema is declared (the unresolved schema parameter infers `unknown`).
+ */
+type InferMachineInput<T extends StandardSchemaV1> = unknown extends StandardSchemaV1.InferOutput<T> ? unknown : InferOutput<T, unknown>;
+/**
+ * Extracts the machine output type from the config's `output` property: the
+ * return type of an output mapper, or the type of a static output value.
+ * Falls back to `TFallback` when the config declares no `output`.
+ */
+type OutputFromConfig<TConfig, TFallback> = TConfig extends {
+  output: infer TOutput;
+} ? TOutput extends ((...args: never[]) => infer TResult) ? TResult : TOutput : TFallback;
+/**
+ * The output type contributed by a single top-level final state: its
+ * `schemas.output` if declared, otherwise its `output` mapper's return type
+ * (or static value), otherwise `undefined` (a final state with no `output`
+ * completes the machine with `undefined` output).
+ */
+type FinalStateConfigOutput<TStateConfig> = TStateConfig extends {
+  schemas: {
+    output: infer TOutputSchema extends StandardSchemaV1;
+  };
+} ? StandardSchemaV1.InferOutput<TOutputSchema> : OutputFromConfig<TStateConfig, undefined>;
+/**
+ * The union of output types across the config's top-level final states, or
+ * `never` when it has none. Reaching a top-level final state completes the
+ * machine with that state's output when no root `output` mapper is declared.
+ */
+type TopLevelFinalOutput<TConfig> = TConfig extends {
+  states: infer TStates;
+} ? { [K in keyof TStates]: TStates[K] extends {
+  type: 'final';
+} ? FinalStateConfigOutput<TStates[K]> : never; }[keyof TStates] : never;
+/**
+ * The machine's output type when no output schema is declared in `setup()`: a
+ * declared `schemas.output` is authoritative, otherwise the output type is
+ * inferred from the config's `output` property, falling back to the union of
+ * top-level final-state output types.
+ */
+type SchemaOrConfigOutput<TOutputSchema extends StandardSchemaV1, TConfig> = StandardSchemaV1 extends TOutputSchema ? OutputFromConfig<TConfig, [TopLevelFinalOutput<TConfig>] extends [never] ? InferOutput<TOutputSchema, unknown> : TopLevelFinalOutput<TConfig>> : InferOutput<TOutputSchema, unknown>;
+type InferChildren<TChildrenSchemaMap extends Record<string, StandardSchemaV1>> = string extends keyof TChildrenSchemaMap ? {} : { [K in keyof TChildrenSchemaMap & string]?: StandardSchemaV1.InferOutput<TChildrenSchemaMap[K]> extends AnyActorRef ? NormalizeActorRef<StandardSchemaV1.InferOutput<TChildrenSchemaMap[K]>> : never; };
+type InferActions<TActionSchemaMap extends ActionSchemas> = string extends keyof TActionSchemaMap ? {} : { [K in keyof TActionSchemaMap & string]: (params: StandardSchemaV1.InferOutput<TActionSchemaMap[K]['params']>) => void | {
+  context?: any;
+  children?: any;
+}; };
+type InferGuards<TGuardSchemaMap extends GuardSchemas> = string extends keyof TGuardSchemaMap ? {} : { [K in keyof TGuardSchemaMap & string]: (params: StandardSchemaV1.InferOutput<TGuardSchemaMap[K]['params']>) => boolean; };
+type OutputMapper<TContext extends MachineContext, TEvent extends EventObject, TResult, TInput = Record<string, unknown> | undefined> = (args: Parameters<Mapper<TContext, TEvent, TResult, TEvent>>[0] & {
+  input: TInput;
+}) => TResult;
+type OutputConfig<TContext extends MachineContext, TEvent extends EventObject, TOutput, TInput = Record<string, unknown> | undefined> = unknown extends TOutput ? OutputMapper<TContext, TEvent, NonReducibleUnknown, TInput> | NonReducibleUnknown : OutputMapper<TContext, TEvent, TOutput, TInput> | TOutput;
+type ValidateTopLevelFinalOutputs<TConfig, TContext extends MachineContext, TEvent extends EventObject> = TConfig extends {
+  schemas: {
+    output: infer TOutputSchema extends StandardSchemaV1;
+  };
+  states: infer TStates;
+} ? {
+  states?: { [K in keyof TStates]: TStates[K] extends {
+    type: 'final';
+  } ? TStates[K] & {
+    output?: OutputConfig<TContext, TEvent, StandardSchemaV1.InferOutput<TOutputSchema>>;
+  } : TStates[K]; };
+} : {};
+type NormalizeActorRef<TActorRef> = TActorRef extends ActorRef<infer TSnapshot, infer TEvent, infer TEmitted, infer TSendEvent> ? ActorRef<TSnapshot, TEvent, TEmitted, TSendEvent> : never;
+type DistributiveOmit<T, K extends keyof any> = T extends any ? Omit<T, K> : never;
+/**
+ * Runtime options for state machine execution.
+ *
+ * @example
+ *
+ * ```ts
+ * const machine = createMachine({
+ *   // ... machine config
+ *   options: {
+ *     maxIterations: 5000
+ *     // other runtime options can be added here
+ *   }
+ * });
+ * ```
+ */
+interface MachineOptions {
+  /**
+   * Maximum number of microsteps one macrostep may take before an
+   * `InfiniteTransitionError` is thrown. Raise it for machines that
+   * legitimately take many eventless or raised-event steps per event.
+   *
+   * @default 1000
+   */
+  maxIterations?: number;
+}
+type MachineSchemas<TContextSchema extends StandardSchemaV1, TEventSchemaMap extends Record<string, StandardSchemaV1>, TInternalEventSchemaMap extends Record<string, StandardSchemaV1>, TEmittedSchemaMap extends Record<string, StandardSchemaV1>, TInputSchema extends StandardSchemaV1, TOutputSchema extends StandardSchemaV1, TMetaSchema extends StandardSchemaV1, TTransitionMetaSchema extends StandardSchemaV1, TTagSchema extends StandardSchemaV1, TChildrenSchemaMap extends Record<string, StandardSchemaV1>> = {
+  events?: TEventSchemaMap;
+  internalEvents?: TInternalEventSchemaMap;
+  actions?: ActionSchemas;
+  guards?: GuardSchemas;
+  context?: TContextSchema;
+  emitted?: TEmittedSchemaMap;
+  input?: TInputSchema;
+  output?: TOutputSchema;
+  meta?: TMetaSchema;
+  transitionMeta?: TTransitionMetaSchema;
+  tags?: TTagSchema;
+  children?: TChildrenSchemaMap;
+};
+type AnyMachineSchemas = MachineSchemas<StandardSchemaV1, Record<string, StandardSchemaV1>, Record<string, StandardSchemaV1>, Record<string, StandardSchemaV1>, StandardSchemaV1, StandardSchemaV1, StandardSchemaV1, StandardSchemaV1, StandardSchemaV1, Record<string, StandardSchemaV1>>;
+/**
+ * The v5 `types` key has no v6 equivalent. Typing it as this message makes the
+ * compiler print the replacement rather than accepting dead configuration.
+ */
+type RemovedTypesKey = '`types` was replaced by `schemas` in v6. Declare `context`, `events` and the other contracts under `schemas`, or run `xstate-codemod migrate --transform types-to-schemas`.';
+/** @public */
+type Next_MachineConfig<TContextSchema extends StandardSchemaV1, TEventSchemaMap extends Record<string, StandardSchemaV1>, TInternalEventSchemaMap extends Record<string, StandardSchemaV1>, TEmittedSchemaMap extends Record<string, StandardSchemaV1>, TInputSchema extends StandardSchemaV1, TOutputSchema extends StandardSchemaV1, TMetaSchema extends StandardSchemaV1, TTransitionMetaSchema extends StandardSchemaV1, TTagSchema extends StandardSchemaV1, TChildrenSchemaMap extends Record<string, StandardSchemaV1>, TContext extends MachineContext = InferOutput<TContextSchema, MachineContext>, TEvent extends EventObject = InferEvents<TEventSchemaMap> | InferInternalEvents<TInternalEventSchemaMap>, TChildren extends Record<string, AnyActorRef | undefined> = InferChildren<TChildrenSchemaMap>, TDelays extends string = string, _TTag extends string = string, TActionMap extends Sources['actions'] = Sources['actions'], TActorMap extends Sources['actors'] = Sources['actors'], TGuardMap extends Sources['guards'] = Sources['guards'], TDelayMap extends Sources['delays'] = Sources['delays'], TContextRequired extends boolean = IsNever<TContext> extends true ? false : true, TSystemRegistry extends SystemRegistry = SystemRegistry> = (DistributiveOmit<Next_StateNodeConfig<TContext, DoNotInfer<TEvent>, DoNotInfer<TDelays>, DoNotInfer<StandardSchemaV1.InferOutput<TTagSchema> & string>, DoNotInfer<StandardSchemaV1.InferOutput<TOutputSchema>>, DoNotInfer<InferEvents<TEmittedSchemaMap>>, DoNotInfer<InferOutput<TMetaSchema, MetaObject>>, DoNotInfer<TChildren>, DoNotInfer<TActionMap>, DoNotInfer<TActorMap>, DoNotInfer<TGuardMap>, DoNotInfer<TDelayMap>, Record<string, unknown> | undefined, Record<string, unknown>, DoNotInfer<TSystemRegistry>, DoNotInfer<InferOutput<TOutputSchema, unknown>>, DoNotInfer<StandardSchemaV1 extends TTransitionMetaSchema ? InferOutput<TMetaSchema, MetaObject> : InferOutput<TTransitionMetaSchema, MetaObject>>>, 'output' | 'schemas'> & {
+  /**
+   * Declared only so that a leftover v5 `types` key is rejected instead of
+   * being accepted and silently ignored: nothing reads it in v6.
+   */
+  types?: RemovedTypesKey;
+  schemas?: MachineSchemas<TContextSchema, TEventSchemaMap, TInternalEventSchemaMap, TEmittedSchemaMap, TInputSchema, TOutputSchema, TMetaSchema, TTransitionMetaSchema, TTagSchema, TChildrenSchemaMap>;
+  actions?: TActionMap;
+  guards?: TGuardMap & GuardSourceMap<TContext, TEvent>;
+  actors?: TActorMap;
+  /** The machine's own version. */
+  version?: string;
+  /**
+   * Migrates a persisted snapshot created by a different version of this
+   * machine to the current `version`. Called during restore when the persisted
+   * snapshot's `version` does not match the machine's `version` (`fromVersion`
+   * is the persisted version, possibly `undefined`). Restoring a
+   * version-mismatched snapshot without a `migrate` function throws.
+   */
+  migrate?: (persistedSnapshot: any, fromVersion: string | undefined) => unknown;
+  output?: Mapper<TContext, DoneStateEvent<DoNotInfer<InferOutput<TOutputSchema, unknown>>>, DoNotInfer<InferOutput<TOutputSchema, unknown>>, TEvent> | DoNotInfer<InferOutput<TOutputSchema, unknown>>;
+  delays?: { [K in TDelays | number]?: number | (({ context, event, stateNode }: {
+    context: TContext;
+    event: TEvent;
+    stateNode: AnyStateNode;
+  }) => number); };
+  options?: MachineOptions;
+}) & (TContextRequired extends false ? {
+  context?: InitialContext<LowInfer<TContext>, TActorMap, InferOutput<TInputSchema, unknown>, TEvent>;
+} : {
+  context: InitialContext<LowInfer<TContext>, TActorMap, InferOutput<TInputSchema, unknown>, TEvent>;
+});
+/**
+ * Recursively widens literal types and strips `readonly`. Used to widen context
+ * inferred from a literal initial value: `{ count: 0 }` becomes
+ * `{ count: number }`, since `createMachine`'s `const` state-schema inference
+ * would otherwise freeze context at its initial literal type and make every
+ * context update a type error.
+ *
+ * @public
+ */
+type WidenLiterals<T> = T extends string ? string : T extends number ? number : T extends boolean ? boolean : T extends bigint ? bigint : T extends ((...args: any[]) => any) ? T : T extends readonly (infer U)[] ? WidenLiterals<U>[] : T extends object ? { -readonly [K in keyof T]: WidenLiterals<T[K]>; } : T;
+type InvokeSrcArgs<TContext extends MachineContext, TEvent extends EventObject, TActorMap extends Sources['actors']> = {
+  actors: TActorMap;
+  context: TContext;
+  event: TEvent;
+  self: AnyActorRef;
+};
+type InvokeInputArgs<TContext extends MachineContext, TEvent extends EventObject, TEmitted extends EventObject, TChildren extends Record<string, AnyActorRef | undefined>, TInput = undefined> = {
+  context: TContext;
+  event: TEvent;
+  input: TInput;
+  self: ActorSelf<MachineSnapshot<TContext, TEvent, TChildren, StateValue, string, unknown, TODO, TODO>, TEvent, TEmitted>;
+};
+type HasExplicitChildren<TChildren extends Record<string, AnyActorRef | undefined>> = string extends keyof TChildren ? false : [keyof TChildren] extends [never] ? false : true;
+/**
+ * @public Completion events (`xstate.done.actor` / `xstate.error.actor`) of
+ * the children declared in `schemas.children`, keyed by `actorId`. Folded into
+ * the event union seen by `entry`, `exit`, guards and transition functions.
+ */
+type ChildCompletionEvents<TChildren extends Record<string, AnyActorRef | undefined>> = HasExplicitChildren<TChildren> extends true ? Values$1<{ [K in keyof TChildren & string]: DoneActorEvent<OutputFrom<NonNullable<TChildren[K]>>, K> | ErrorActorEvent<ErrorFrom<NonNullable<TChildren[K]>>, K>; }> : never;
+type ChildIdForLogic<TLogic extends AnyActorLogic, TChildren extends Record<string, AnyActorRef | undefined>> = HasExplicitChildren<TChildren> extends true ? Values$1<{ [K in keyof TChildren & string]: ActorRefFromLogic<TLogic> extends NonNullable<TChildren[K]> ? K : never; }> : string;
+type LogicForChildRef<TActorRef> = NonNullable<TActorRef> extends ActorRef<infer TSnapshot, infer TEvent, infer TEmitted, any> ? ActorLogic<TSnapshot, TEvent, any, any, TEmitted> : never;
+/**
+ * The `onDone` config for inline (unregistered-logic) invoke branches.
+ *
+ * When the actor map has registered sources, this deliberately has no
+ * function forms (no transition function, no context mapper): passing a
+ * registered logic value as `src` makes TypeScript narrow the invoke union to
+ * the matching registered branch plus the inline branch, and per-actor
+ * `event.output` inference in `onDone` callbacks only survives if the
+ * registered branch contributes the union's only call signature. Inline
+ * (unregistered) logic in such setups can use the object/target forms, or be
+ * registered to get function-form transitions.
+ *
+ * With no registered sources (empty or permissive maps) there is no competing
+ * branch, so the full transition config is allowed.
+ */
+type InlineInvokeOnDone<TContext extends MachineContext, TEvent extends EventObject, TEmitted extends EventObject, TActionMap extends Sources['actions'], TActorMap extends Sources['actors'], TGuardMap extends Sources['guards'], TDelayMap extends Sources['delays'], TMeta extends MetaObject, TChildren extends Record<string, AnyActorRef | undefined>> = [keyof TActorMap & string] extends [never] ? Next_TransitionConfigOrTarget<TContext, DoneActorEvent<any>, TEvent, TEmitted, TActionMap, TActorMap, TGuardMap, TDelayMap, TMeta, undefined, TChildren> : string extends keyof TActorMap ? Next_TransitionConfigOrTarget<TContext, DoneActorEvent<OutputFrom<TActorMap[keyof TActorMap & string]>>, TEvent, TEmitted, TActionMap, TActorMap, TGuardMap, TDelayMap, TMeta, undefined, TChildren> : undefined | {
+  matches?: EventPayloadPattern<DoneActorEvent>;
+  target?: string | string[];
+  context?: TransitionContextPatch<TContext>;
+  description?: string;
+  reenter?: boolean;
+  meta?: TMeta;
+  input?: Record<string, unknown> | ((args: {
+    context: any;
+    event: any;
+  }) => Record<string, unknown>);
+};
+type InlineChildInvokeConfig<TContext extends MachineContext, TEvent extends EventObject, TEmitted extends EventObject, TChildren extends Record<string, AnyActorRef | undefined>, TActionMap extends Sources['actions'], TActorMap extends Sources['actors'], TGuardMap extends Sources['guards'], TDelayMap extends Sources['delays'], TMeta extends MetaObject, TSystemRegistry extends SystemRegistry, TInput = undefined> = Values$1<{ [K in keyof TChildren & string]: Omit<Next_InvokeConfigBase<TContext, TEvent, TEmitted, TChildren, TActionMap, TActorMap, TGuardMap, TDelayMap, TMeta, TSystemRegistry>, 'onDone'> & {
+  onDone?: InlineInvokeOnDone<TContext, TEvent, TEmitted, TActionMap, TActorMap, TGuardMap, TDelayMap, TMeta, TChildren>;
+  id: K;
+  src: LogicForChildRef<TChildren[K]>;
+  input?: ((args: InvokeInputArgs<TContext, TEvent, TEmitted, TChildren, TInput>) => unknown) | NonReducibleUnknown;
+}; }>;
+type InlineInvokeConfig<TContext extends MachineContext, TEvent extends EventObject, TEmitted extends EventObject, TChildren extends Record<string, AnyActorRef | undefined>, TActionMap extends Sources['actions'], TActorMap extends Sources['actors'], TGuardMap extends Sources['guards'], TDelayMap extends Sources['delays'], TMeta extends MetaObject, TSystemRegistry extends SystemRegistry, TInput = undefined> = HasExplicitChildren<TChildren> extends true ? InlineChildInvokeConfig<TContext, TEvent, TEmitted, TChildren, TActionMap, TActorMap, TGuardMap, TDelayMap, TMeta, TSystemRegistry, TInput> : Omit<Next_InvokeConfigBase<TContext, TEvent, TEmitted, TChildren, TActionMap, TActorMap, TGuardMap, TDelayMap, TMeta, TSystemRegistry>, 'onDone'> & {
+  onDone?: InlineInvokeOnDone<TContext, TEvent, TEmitted, TActionMap, TActorMap, TGuardMap, TDelayMap, TMeta, TChildren>;
+  src: AnyActorLogic;
+  input?: ((args: InvokeInputArgs<TContext, TEvent, TEmitted, TChildren, TInput>) => unknown) | NonReducibleUnknown;
+};
+/**
+ * Invoke config. A union of:
+ *
+ * - One branch per registered actor source (distributed over the `actors` map),
+ *   where `src` — a key, the logic itself, or a resolver function returning
+ *   either — is correlated with `input`, so static and mapped inputs typecheck
+ *   against that logic's input type.
+ * - A branch for inline (unregistered) actor logic values, whose `input` cannot
+ *   be correlated (the config is not generic over inline logic).
+ *
+ * @public
+ */
+type Next_InvokeConfig<TContext extends MachineContext, TEvent extends EventObject, TEmitted extends EventObject, TChildren extends Record<string, AnyActorRef | undefined>, TActionMap extends Sources['actions'], TActorMap extends Sources['actors'], TGuardMap extends Sources['guards'], TDelayMap extends Sources['delays'], TMeta extends MetaObject, TSystemRegistry extends SystemRegistry = SystemRegistry, TInput = undefined> = string extends keyof TActorMap ? HasExplicitChildren<TChildren> extends true ? InlineInvokeConfig<TContext, TEvent, TEmitted, TChildren, TActionMap, TActorMap, TGuardMap, TDelayMap, TMeta, TSystemRegistry, TInput> : Next_InvokeConfigBase<TContext, TEvent, TEmitted, TChildren, TActionMap, TActorMap, TGuardMap, TDelayMap, TMeta, TSystemRegistry> & {
+  src: string | AnyActorLogic | ((args: InvokeSrcArgs<TContext, TEvent, TActorMap>) => string | AnyActorLogic);
+  input?: ((args: InvokeInputArgs<TContext, TEvent, TEmitted, TChildren, TInput>) => unknown) | NonReducibleUnknown;
+} : { [K in keyof TActorMap & string]: Next_InvokeConfigBase<TContext, TEvent, TEmitted, TChildren, TActionMap, TActorMap, TGuardMap, TDelayMap, TMeta, TSystemRegistry, DoneActorEvent<OutputFrom<TActorMap[K]>>, ErrorActorEvent<ErrorFrom<TActorMap[K]>>> & {
+  id?: ChildIdForLogic<TActorMap[K], TChildren>;
+  input?: ((args: InvokeInputArgs<TContext, TEvent, TEmitted, TChildren, TInput>) => InputFrom<TActorMap[K]>) | InputFrom<TActorMap[K]>;
+} & ({
+  src: K;
+} | {
+  src: TActorMap[K];
+} | {
+  src: (args: InvokeSrcArgs<TContext, TEvent, TActorMap>) => K | TActorMap[K];
+}); }[keyof TActorMap & string] | InlineInvokeConfig<TContext, TEvent, TEmitted, TChildren, TActionMap, TActorMap, TGuardMap, TDelayMap, TMeta, TSystemRegistry, TInput>;
+interface Next_InvokeConfigBase<TContext extends MachineContext, TEvent extends EventObject, TEmitted extends EventObject, TChildren extends Record<string, AnyActorRef | undefined>, TActionMap extends Sources['actions'], TActorMap extends Sources['actors'], TGuardMap extends Sources['guards'], TDelayMap extends Sources['delays'], TMeta extends MetaObject, TSystemRegistry extends SystemRegistry, TDoneEvent extends EventObject = [keyof TActorMap & string] extends [never] ? DoneActorEvent<any> : DoneActorEvent<OutputFrom<TActorMap[keyof TActorMap & string]>>, TErrorEvent extends EventObject = [keyof TActorMap & string] extends [never] ? ErrorActorEvent<any> : ErrorActorEvent<ErrorFrom<TActorMap[keyof TActorMap & string]>>> {
+  id?: string;
+  registryKey?: keyof TSystemRegistry & string;
+  onDone?: Next_TransitionConfigOrTarget<TContext, TDoneEvent, TEvent, TEmitted, TActionMap, TActorMap, TGuardMap, TDelayMap, TMeta, undefined, TChildren>;
+  onError?: Next_TransitionConfigOrTarget<TContext, TErrorEvent, TEvent, TEmitted, TActionMap, TActorMap, TGuardMap, TDelayMap, TMeta, undefined, TChildren>;
+  onSnapshot?: Next_TransitionConfigOrTarget<TContext, SnapshotEvent<any>, TEvent, TEmitted, TActionMap, TActorMap, TGuardMap, TDelayMap, TMeta, undefined, TChildren>;
+  /**
+   * The duration (in ms) after which this invocation will time out if it has
+   * not completed. "This task is taking too long."
+   *
+   * When the timeout expires, the `onTimeout` transition is taken. If the
+   * invoke completes first, the timeout is cancelled.
+   */
+  timeout?: number | ((args: {
+    context: TContext;
+    event: TEvent;
+  }) => number);
+  /**
+   * Transition taken when the invoke-level `timeout` expires. Required when
+   * `timeout` is set on an invoke.
+   */
+  onTimeout?: Next_TransitionConfigOrTarget<TContext, ActorTimeoutEvent, TEvent, TEmitted, TActionMap, TActorMap, TGuardMap, TDelayMap, TMeta, undefined, TChildren>;
+}
+/** Lookup state input type from an input map, with fallback to undefined */
+type LookupInput<TInputMap extends Record<string, unknown>, K extends string> = K extends keyof TInputMap ? TInputMap[K] : undefined;
+type StateAction<TContext extends MachineContext, TEvent extends EventObject, TEmittedEvent extends EventObject, TActionMap extends Sources['actions'], TActorMap extends Sources['actors'], TGuardMap extends Sources['guards'], TDelayMap extends Sources['delays'], TInput = Record<string, unknown> | undefined, TChildren extends Record<string, AnyActorRef | undefined> = {}> = (_: Omit<Parameters<Action<TContext, TEvent, TEmittedEvent, TActionMap, TActorMap, TGuardMap, TDelayMap, never>>[0], 'params'> & {
+  input: TInput;
+  /** The state node being entered (`entry`) or exited (`exit`). */
+  stateNode: AnyStateNode;
+}, enqueue: EnqueueObject<TEvent, TEmittedEvent, SystemRegistry, TActorMap, TChildren>) => ReturnType<Action<TContext, TEvent, TEmittedEvent, TActionMap, TActorMap, TGuardMap, TDelayMap, never>>;
+type Next_ChoiceTarget<TMeta extends MetaObject> = {
+  target: string | string[];
+  description?: string;
+  reenter?: boolean;
+  meta?: TMeta;
+  input?: Record<string, unknown> | ((args: {
+    context: any;
+    event: any;
+  }) => Record<string, unknown>);
+};
+type Next_ChoiceArgs<TContext extends MachineContext, TCurrentEvent extends EventObject, TEvent extends EventObject, TActionMap extends Sources['actions'], TActorMap extends Sources['actors'], TGuardMap extends Sources['guards'], TDelayMap extends Sources['delays'], _TCtx extends MachineContext = [TContext] extends [never] ? any : TContext> = Parameters<TransitionConfigFunction<TContext, TCurrentEvent, TEvent, EventObject, TActionMap, TActorMap, TGuardMap, TDelayMap, MetaObject, undefined, // TInput
+  _TCtx>>[0];
+/**
+ * Route config: either a static config object, or a transition-style function
+ * that acts as the route's guard and resolver — returning `undefined`/`false`
+ * blocks the route; returning `true` or a config object allows it (optionally
+ * updating `context` and providing `input`/`reenter`/`meta`).
+ *
+ * Guard objects/strings on routes are only produced by the JSON layer
+ * (`createMachineFromConfig`) — authoring uses the function form.
+ */
+type Next_RouteConfig<TContext extends MachineContext, TEvent extends EventObject, TMeta extends MetaObject, TActionMap extends Sources['actions'], TActorMap extends Sources['actors'], TGuardMap extends Sources['guards'], TDelayMap extends Sources['delays']> = {
+  description?: string;
+  reenter?: boolean;
+  meta?: TMeta;
+  input?: Record<string, unknown> | ((args: {
+    context: any;
+    event: any;
+  }) => Record<string, unknown>);
+} | ((args: Next_ChoiceArgs<TContext, TEvent, TEvent, TActionMap, TActorMap, TGuardMap, TDelayMap>) => boolean | void | {
+  context?: TContext;
+  reenter?: boolean;
+  meta?: TMeta;
+  input?: Record<string, unknown> | ((args: {
+    context: any;
+    event: any;
+  }) => Record<string, unknown>);
+});
+type Next_ChoiceConfigFunction<TContext extends MachineContext, TCurrentEvent extends EventObject, TEvent extends EventObject, TActionMap extends Sources['actions'], TActorMap extends Sources['actors'], TGuardMap extends Sources['guards'], TDelayMap extends Sources['delays'], TMeta extends MetaObject, _TCtx extends MachineContext = [TContext] extends [never] ? any : TContext> = (args: Next_ChoiceArgs<TContext, TCurrentEvent, TEvent, TActionMap, TActorMap, TGuardMap, TDelayMap, _TCtx>) => Next_ChoiceTarget<TMeta>;
+/** @public */
+type Next_StateNodeConfig<TContext extends MachineContext, TEvent extends EventObject, TDelays extends string, TTag extends string, _TOutput, TEmitted extends EventObject, TStateMeta extends MetaObject, TChildren extends Record<string, AnyActorRef | undefined>, TActionMap extends Sources['actions'], TActorMap extends Sources['actors'], TGuardMap extends Sources['guards'], TDelayMap extends Sources['delays'], TInput = Record<string, unknown> | undefined, TInputMap extends Record<string, unknown> = Record<string, unknown>, TSystemRegistry extends SystemRegistry = SystemRegistry, TChildOutput = unknown, TTransitionMeta extends MetaObject = TStateMeta> = Next_RegularStateNodeConfig<TContext, TEvent, TDelays, TTag, _TOutput, TEmitted, TStateMeta, TTransitionMeta, TChildren, TActionMap, TActorMap, TGuardMap, TDelayMap, TInput, TInputMap, TSystemRegistry, TChildOutput> | Next_ChoiceStateNodeConfig<TContext, TEvent, TTag, TStateMeta, TTransitionMeta, TActionMap, TActorMap, TGuardMap, TDelayMap>;
+/** @public Referenced by emitted declarations of `Next_StateNodeConfig`. */
+interface Next_ChoiceStateNodeConfig<TContext extends MachineContext, TEvent extends EventObject, TTag extends string, TStateMeta extends MetaObject, TTransitionMeta extends MetaObject, TActionMap extends Sources['actions'], TActorMap extends Sources['actors'], TGuardMap extends Sources['guards'], TDelayMap extends Sources['delays']> {
+  contextSchema?: StandardSchemaV1;
+  schemas?: SetupStateSchemas;
+  type: 'choice';
+  /** Function that resolves this choice state to a target. */
+  choice: Next_ChoiceConfigFunction<TContext, TEvent, TEvent, TActionMap, TActorMap, TGuardMap, TDelayMap, TTransitionMeta>;
+  id?: string | undefined;
+  order?: number;
+  tags?: TTag[];
+  description?: string;
+  meta?: TStateMeta;
+  route?: Next_RouteConfig<TContext, TEvent, TTransitionMeta, TActionMap, TActorMap, TGuardMap, TDelayMap> | undefined;
+  initial?: never;
+  history?: never;
+  states?: never;
+  invoke?: never;
+  on?: never;
+  entry?: never;
+  exit?: never;
+  onDone?: never;
+  onError?: never;
+  after?: never;
+  timeout?: never;
+  onTimeout?: never;
+  always?: never;
+  output?: never;
+  target?: never;
+}
+/** @public Referenced by emitted declarations of `Next_StateNodeConfig`. */
+interface Next_RegularStateNodeConfig<TContext extends MachineContext, TEvent extends EventObject, TDelays extends string, TTag extends string, TOutput, TEmitted extends EventObject, TStateMeta extends MetaObject, TTransitionMeta extends MetaObject, TChildren extends Record<string, AnyActorRef | undefined>, TActionMap extends Sources['actions'], TActorMap extends Sources['actors'], TGuardMap extends Sources['guards'], TDelayMap extends Sources['delays'], TInput = Record<string, unknown> | undefined, TInputMap extends Record<string, unknown> = Record<string, unknown>, TSystemRegistry extends SystemRegistry = SystemRegistry, TChildOutput = unknown> {
+  contextSchema?: StandardSchemaV1;
+  schemas?: SetupStateSchemas;
+  /** The initial state transition. */
+  initial?: string | {
+    target: string;
+    meta?: TTransitionMeta;
+    description?: string;
+    input?: Record<string, unknown> | ((args: {
+      context: TContext;
+      event: TEvent;
+    }) => Record<string, unknown>);
+  } | undefined;
+  /**
+   * The type of this state node:
+   *
+   * - `'atomic'` - no child state nodes
+   * - `'compound'` - nested child state nodes (XOR)
+   * - `'parallel'` - orthogonal nested child state nodes (AND)
+   * - `'history'` - history state node
+   * - `'final'` - final state node
+   */
+  type?: 'atomic' | 'compound' | 'parallel' | 'final' | 'history';
+  /**
+   * Indicates whether the state node is a history state node, and what type of
+   * history: shallow, deep, true (shallow), false (none), undefined (none)
+   */
+  history?: 'shallow' | 'deep' | boolean | undefined;
+  /**
+   * The mapping of state node keys to their state node configurations
+   * (recursive).
+   */
+  states?: { [K in string]: Next_StateNodeConfig<TContext, TEvent, TDelays, TTag, any, // TOutput,
+    TEmitted, TStateMeta, TChildren, TActionMap, TActorMap, TGuardMap, TDelayMap, LookupInput<TInputMap, K>, TInputMap, TSystemRegistry, TChildOutput, TTransitionMeta>; };
+  /**
+   * The services to invoke upon entering this state node. These services will
+   * be stopped upon exiting this state node.
+   */
+  invoke?: SingleOrArray<Next_InvokeConfig<TContext, TEvent, TEmitted, TChildren, TActionMap, TActorMap, TGuardMap, TDelayMap, TTransitionMeta, TSystemRegistry, TInput>>;
+  /** The mapping of event types to their potential transition(s). */
+  on?: { [K in EventDescriptor<TEvent>]?: Next_TransitionConfigOrTarget<TContext, ExtractEvent<TEvent, K>, TEvent, TEmitted, TActionMap, TActorMap, TGuardMap, TDelayMap, TTransitionMeta, TInput, TChildren>; } & (string extends TEvent['type'] ? unknown : { [K in `xstate.${string}`]?: Next_TransitionConfigOrTarget<TContext, {
+    type: K;
+  }, TEvent, TEmitted, TActionMap, TActorMap, TGuardMap, TDelayMap, TTransitionMeta, TInput, TChildren>; });
+  /**
+   * Enables routing to this state via `{ type: 'xstate.route', to: '#id' }`.
+   * Requires this state node to have an explicit `id`.
+   */
+  route?: Next_RouteConfig<TContext, TEvent, TTransitionMeta, TActionMap, TActorMap, TGuardMap, TDelayMap> | undefined;
+  entry?: StateAction<TContext, TEvent, TEmitted, TActionMap, TActorMap, TGuardMap, TDelayMap, TInput, TChildren>;
+  exit?: StateAction<TContext, TEvent, TEmitted, TActionMap, TActorMap, TGuardMap, TDelayMap, TInput, TChildren>;
+  /**
+   * The potential transition(s) to be taken upon reaching a final child state
+   * node.
+   *
+   * This is equivalent to defining a `[done(id)]` transition on this state
+   * node's `on` property.
+   */
+  onDone?: Next_TransitionConfigOrTarget<TContext, DoneStateEvent<TChildOutput>, TEvent, TEmitted, TActionMap, TActorMap, TGuardMap, TDelayMap, TTransitionMeta, undefined, TChildren>;
+  /**
+   * The transition to take when an `xstate.error.*` event is raised while this
+   * state node or one of its descendants is active.
+   */
+  onError?: Next_TransitionConfigOrTarget<TContext, ErrorEvent, TEvent, TEmitted, TActionMap, TActorMap, TGuardMap, TDelayMap, TTransitionMeta, undefined, TChildren>;
+  /**
+   * The mapping (or array) of delays (in milliseconds) to their potential
+   * transition(s). The delayed transitions are taken after the specified delay
+   * in an interpreter.
+   */
+  after?: { [K in NoInfer<TDelays> | number | DelayDurationKey]?: Next_StaticTransitionConfig<TContext, AfterEvent, TEvent, TActionMap, TActorMap, TGuardMap, TDelayMap, TTransitionMeta> | TransitionConfigFunction<TContext, AfterEvent, TEvent, TODO, // TEmitted
+    TActionMap, TActorMap, TGuardMap, TDelayMap, TTransitionMeta, TInput, [TContext] extends [never] ? any : TContext, TChildren>; };
+  /**
+   * The duration (in ms) after which this state will transition via `onTimeout`
+   * if still active. "We've been in this state too long."
+   *
+   * Independent of `after` - both can coexist on the same state. Both cancel on
+   * state exit.
+   *
+   * Can be a static number, a delay reference string, or a dynamic function.
+   */
+  timeout?: number | NoInfer<TDelays> | ((args: {
+    context: TContext;
+    event: TEvent;
+    stateNode: AnyStateNode;
+    input: TInput;
+  }) => number);
+  /** Transition taken when `timeout` expires. Required when `timeout` is set. */
+  onTimeout?: Next_TransitionConfigOrTarget<TContext, TimeoutEvent, TEvent, TEmitted, TActionMap, TActorMap, TGuardMap, TDelayMap, TTransitionMeta, TInput, TChildren>;
+  /**
+   * An eventless transition that is always taken when this state node is
+   * active.
+   */
+  always?: Next_TransitionConfigOrTarget<TContext, TEvent, TEvent, TEmitted, TActionMap, TActorMap, TGuardMap, TDelayMap, TTransitionMeta, undefined, TChildren>;
+  choice?: never;
+  /**
+   * The meta data associated with this state node, which will be returned in
+   * State instances.
+   */
+  meta?: TStateMeta;
+  /**
+   * The output data sent with the `xstate.done.state` event if this is a final
+   * state node.
+   *
+   * The output data will be evaluated with the current `context` and placed on
+   * the `.data` property of the event.
+   */
+  output?: OutputConfig<TContext, TEvent, TOutput, TInput>;
+  /**
+   * The unique ID of the state node, which can be referenced as a transition
+   * target via the `#id` syntax.
+   */
+  id?: string | undefined;
+  /**
+   * The order this state node appears. Corresponds to the implicit document
+   * order.
+   */
+  order?: number;
+  /**
+   * The tags for this state node, which are accumulated into the `state.tags`
+   * property.
+   */
+  tags?: TTag[];
+  /** A text description of the state node */
+  description?: string;
+  /** A default target for a history state */
+  target?: string | string[] | undefined;
+}
+type Next_StaticTransitionConfig<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject, TActionMap extends Sources['actions'], TActorMap extends Sources['actors'], TGuardMap extends Sources['guards'], TDelayMap extends Sources['delays'], TMeta extends MetaObject> = {
+  matches?: EventPayloadPattern<TExpressionEvent>;
+  target?: string | string[];
+  context?: TransitionContextPatch<TContext> | TransitionContextMapper<TContext, TExpressionEvent, TEvent, TActionMap, TActorMap, TGuardMap, TDelayMap>;
+  description?: string;
+  reenter?: boolean;
+  meta?: TMeta;
+  input?: Record<string, unknown> | ((args: {
+    context: any;
+    event: any;
+  }) => Record<string, unknown>);
+};
+/** @public */
+type Next_TransitionConfigOrTarget<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject, TEmitted extends EventObject, TActionMap extends Sources['actions'], TActorMap extends Sources['actors'], TGuardMap extends Sources['guards'], TDelayMap extends Sources['delays'], TMeta extends MetaObject, TInput = undefined, TChildren extends Record<string, AnyActorRef | undefined> = {}> = undefined | Next_StaticTransitionConfig<TContext, TExpressionEvent, TEvent, TActionMap, TActorMap, TGuardMap, TDelayMap, TMeta> | {
+  matches?: EventPayloadPattern<TExpressionEvent>;
+  to?: TransitionConfigFunction<TContext, TExpressionEvent, TEvent, TEmitted, TActionMap, TActorMap, TGuardMap, TDelayMap, TMeta, TInput, [TContext] extends [never] ? any : TContext, TChildren>;
+  context?: TransitionContextPatch<TContext> | TransitionContextMapper<TContext, TExpressionEvent, TEvent, TActionMap, TActorMap, TGuardMap, TDelayMap>;
+  description?: string;
+  reenter?: boolean;
+  meta?: TMeta;
+  input?: Record<string, unknown> | ((args: {
+    context: any;
+    event: any;
+  }) => Record<string, unknown>);
+} | TransitionConfigFunction<TContext, TExpressionEvent, TEvent, TEmitted, TActionMap, TActorMap, TGuardMap, TDelayMap, TMeta, TInput, [TContext] extends [never] ? any : TContext, TChildren>;
+type WithDefault<T, Default> = IsNever<T> extends true ? Default : T;
+/** @public */
+interface Sources {
+  actions: Record<string, (...args: any[]) => void | {
+    context?: any;
+    children?: any;
+  }>;
+  guards: Record<string, Function>;
+  delays: Record<string, number | Function>;
+  actors: Record<string, AnyActorLogic>;
+}
+/**
+ * Contextually types the entries of a `guards: { ... }` source map. Guards
+ * are plain predicates: they receive only caller-supplied params (no injected
+ * transition args) and are called the same way they are declared.
+ */
+type GuardSourceMap<_TContext extends MachineContext, _TEvent extends EventObject> = Record<string, (...params: any[]) => boolean>;
+/**
+ * Contextually types the entries of a `delays: { ... }` source map. Delay
+ * functions receive `{ context, event, stateNode }` at runtime.
+ */
+type DelaySourceMap<TContext extends MachineContext, TEvent extends EventObject, _TCtx = [TContext] extends [never] ? any : TContext> = Record<string, number | ((args: {
+  context: _TCtx;
+  event: TEvent;
+  stateNode: AnyStateNode;
+}) => number)>;
+type DelayMapFromNames<TDelays extends string, TDelayMap extends Sources['delays']> = string extends TDelays ? Sources['delays'] : { [K in TDelays]: K extends keyof TDelayMap ? TDelayMap[K] : number | ((...args: any[]) => number); };
+type DelayNamesFromConfig<TConfig> = TConfig extends {
+  delays: infer TDelays;
+} ? Extract<keyof TDelays, string> : string;
+type DurationInt = `${bigint}`;
+type DurationFraction = DurationInt | `0${DurationInt}` | `00${DurationInt}`;
+type DurationDecimal = DurationInt | `${DurationInt}.${DurationFraction}` | `.${DurationFraction}`;
+type IsoDateParts = `${DurationInt}W` | `${DurationInt}D` | `${DurationInt}W${DurationInt}D`;
+type IsoSeconds = `${DurationInt}` | `${DurationInt}.${DurationFraction}`;
+type IsoTimeParts = `${DurationInt}H` | `${DurationInt}M` | `${IsoSeconds}S` | `${DurationInt}H${DurationInt}M` | `${DurationInt}H${IsoSeconds}S` | `${DurationInt}M${IsoSeconds}S` | `${DurationInt}H${DurationInt}M${IsoSeconds}S`;
+/**
+ * @public Duration-string `after` keys, which are parsed rather than looked
+ * up: numeric strings (milliseconds), `ms` / `s` suffixes (case-insensitive)
+ * and uppercase ISO 8601 durations (`PT1M30S`, `P1D`, `P1DT12H`).
+ */
+type DelayDurationKey = `${number}` | `${DurationInt}${'ms' | 'MS' | 'Ms' | 'mS'}` | `${DurationDecimal}${'s' | 'S'}` | `P${IsoDateParts}` | `P${IsoDateParts | ''}T${IsoTimeParts}`;
+type InvalidDelayReferences<TConfig, TDelays extends string> = 0 extends 1 & TConfig ? never : (TConfig extends {
+  after: infer TAfter;
+} ? Exclude<Extract<keyof TAfter, string>, TDelays | DelayDurationKey> : never) | (TConfig extends {
+  states: infer TStates;
+} ? TStates extends Record<string, unknown> ? { [K in keyof TStates]: InvalidDelayReferences<TStates[K], TDelays>; }[keyof TStates] : never : never);
+type InvalidDelayReferenceErrors<TConfig, TDelays extends string> = (TConfig extends {
+  after: infer TAfter;
+} ? [Exclude<Extract<keyof TAfter, string>, TDelays | DelayDurationKey>] extends [never] ? {} : {
+  after: { [K in Exclude<Extract<keyof TAfter, string>, TDelays | DelayDurationKey>]: `Delay '${K}' is not declared in delays.`; };
+} : {}) & (TConfig extends {
+  states: infer TStates;
+} ? TStates extends Record<string, unknown> ? {
+  states: { [K in keyof TStates]: InvalidDelayReferenceErrors<TStates[K], TDelays>; };
+} : {} : {});
+/**
+ * @public Rejects `after` keys that are neither a declared delay name, a number nor a
+ * duration string. Only applies when delay names are known; the error is
+ * reported at the offending key.
+ */
+type ValidateDelayNames<TConfig, TDelays extends string> = string extends TDelays ? unknown : [InvalidDelayReferences<TConfig, TDelays>] extends [never] ? unknown : InvalidDelayReferenceErrors<TConfig, TDelays>;
+type ValidateDelayReferences<TConfig> = ValidateDelayNames<TConfig, DelayNamesFromConfig<TConfig>>;
+type UndeclaredEventDescriptors<TConfig, TAllowed extends string> = 0 extends 1 & TConfig ? never : (TConfig extends {
+  on: infer TOn;
+} ? Exclude<Extract<keyof TOn, string>, TAllowed> : never) | (TConfig extends {
+  states: infer TStates;
+} ? TStates extends Record<string, unknown> ? { [K in keyof TStates]: UndeclaredEventDescriptors<TStates[K], TAllowed>; }[keyof TStates] : never : never);
+type UndeclaredEventDescriptorErrors<TConfig, TAllowed extends string> = (TConfig extends {
+  on: infer TOn;
+} ? [Exclude<Extract<keyof TOn, string>, TAllowed>] extends [never] ? {} : {
+  on: { [K in Exclude<Extract<keyof TOn, string>, TAllowed>]: `Event type '${K}' is not declared in schemas.events.`; };
+} : {}) & (TConfig extends {
+  states: infer TStates;
+} ? TStates extends Record<string, unknown> ? {
+  states: { [K in keyof TStates]: UndeclaredEventDescriptorErrors<TStates[K], TAllowed>; };
+} : {} : {});
+/**
+ * @public Rejects `on` keys that match no declared event type. Only applies when the
+ * event union is closed (e.g. `schemas.events` is declared); wildcards,
+ * partial wildcards and reserved `xstate.*` event types are always allowed.
+ * The error is reported at the offending key.
+ */
+type ValidateEventDescriptors<TConfig, TEvent extends EventObject> = string extends TEvent['type'] ? unknown : [UndeclaredEventDescriptors<TConfig, EventDescriptor<TEvent> | `xstate.${string}`>] extends [never] ? unknown : UndeclaredEventDescriptorErrors<TConfig, EventDescriptor<TEvent> | `xstate.${string}`>;
+type IsHistoryStateConfig<TConfig> = TConfig extends {
+  type: 'history';
+} ? true : TConfig extends {
+  history: false | undefined;
+} ? false : TConfig extends {
+  history: unknown;
+} ? true : false;
+type MissingHistoryDefault<TConfig> = 0 extends 1 & TConfig ? never : IsHistoryStateConfig<TConfig> extends true ? TConfig extends {
+  target: string | readonly [string, ...string[]];
+} ? never : true : TConfig extends {
+  states: infer TStates;
+} ? TStates extends Record<string, unknown> ? { [K in keyof TStates]: MissingHistoryDefault<TStates[K]>; }[keyof TStates] : never : never;
+/**
+ * Rejects authored machines containing a history state without its SCXML
+ * default target.
+ */
+type ValidateHistoryDefaults<TConfig> = MissingHistoryDefault<TConfig> extends never ? unknown : never;
+type StatePath = readonly string[];
+type AppendStatePath<TPrefix extends StatePath, TKey extends string> = [...TPrefix, TKey];
+type EscapeStatePathDots<TValue extends string> = TValue extends `${infer THead}.${infer TTail}` ? `${THead}\\.${EscapeStatePathDots<TTail>}` : TValue;
+type ProtectEscapedStatePathDots<TValue extends string> = TValue extends `${infer THead}\\.${infer TTail}` ? `${THead}__XSTATE_ESCAPED_DOT__${ProtectEscapedStatePathDots<TTail>}` : TValue;
+type RestoreEscapedStatePathDots<TValue extends string> = TValue extends `${infer THead}__XSTATE_ESCAPED_DOT__${infer TTail}` ? `${THead}.${RestoreEscapedStatePathDots<TTail>}` : TValue;
+type SplitStatePath<TPath extends string> = ProtectEscapedStatePathDots<TPath> extends (infer TProtected extends string) ? TProtected extends '' ? [] : TProtected extends `${infer THead}.${infer TTail}` ? [RestoreEscapedStatePathDots<THead>, ...SplitStatePath<TTail>] : [RestoreEscapedStatePathDots<TProtected>] : never;
+type ParentStatePath<TPath extends StatePath> = TPath extends readonly [...infer TParent extends string[], string] ? TParent : [];
+type StatePathsFromStates<TStates, TPrefix extends StatePath = []> = TStates extends Record<string, unknown> ? { [K in keyof TStates & string]: AppendStatePath<TPrefix, K> | (0 extends 1 & TStates[K] ? never : TStates[K] extends {
+  states: infer TChildren;
+} ? StatePathsFromStates<TChildren, AppendStatePath<TPrefix, K>> : never); }[keyof TStates & string] : never;
+type AuthoredStatePaths<TConfig> = TConfig extends {
+  states: infer TStates;
+} ? StatePathsFromStates<TStates> : never;
+type OpaqueStatePathsFromStates<TStates, TPrefix extends StatePath = []> = TStates extends Record<string, unknown> ? { [K in keyof TStates & string]: 0 extends 1 & TStates[K] ? AppendStatePath<TPrefix, K> : TStates[K] extends {
+  states: infer TChildren;
+} ? OpaqueStatePathsFromStates<TChildren, AppendStatePath<TPrefix, K>> : never; }[keyof TStates & string] : never;
+type OpaqueStatePaths<TConfig> = TConfig extends {
+  states: infer TStates;
+} ? OpaqueStatePathsFromStates<TStates> : never;
+type IsWithinStatePath<TPath extends StatePath, TAncestor> = TAncestor extends StatePath ? TPath extends readonly [...TAncestor, ...string[]] ? true : false : false;
+type JoinStateTargetString<TPrefix extends string, TKey extends string> = TPrefix extends '' ? TKey : `${TPrefix}.${TKey}`;
+type StateTargetStringsFromStates<TStates, TPrefix extends string = ''> = TStates extends Record<string, unknown> ? { [K in keyof TStates & string]: JoinStateTargetString<TPrefix, EscapeStatePathDots<K>> | (0 extends 1 & TStates[K] ? never : TStates[K] extends {
+  states: infer TChildren;
+} ? StateTargetStringsFromStates<TChildren, JoinStateTargetString<TPrefix, EscapeStatePathDots<K>>> : never); }[keyof TStates & string] : never;
+type IdTargetsForNode<TNode> = TNode extends {
+  id: infer TId extends string;
+} ? string extends TId ? never : TNode extends {
+  states: infer TStates;
+} ? `#${EscapeStatePathDots<TId>}` | `#${EscapeStatePathDots<TId>}.${StateTargetStringsFromStates<TStates>}` : `#${EscapeStatePathDots<TId>}` : never;
+type IdTargetsFromStates<TStates> = TStates extends Record<string, unknown> ? { [K in keyof TStates & string]: IdTargetsForNode<TStates[K]> | (0 extends 1 & TStates[K] ? never : TStates[K] extends {
+  states: infer TChildren;
+} ? IdTargetsFromStates<TChildren> : never); }[keyof TStates & string] : never;
+type AuthoredIdTargets<TConfig> = IdTargetsForNode<TConfig> | (TConfig extends {
+  states: infer TStates;
+} ? IdTargetsFromStates<TStates> : never);
+type ResolveIdTargetAtNode<TNode, TNodePath extends StatePath, TTarget extends string> = TNode extends {
+  id: infer TId extends string;
+} ? string extends TId ? never : TTarget extends `#${EscapeStatePathDots<TId>}` ? TNodePath : TTarget extends `#${EscapeStatePathDots<TId>}.${infer TDescendant}` ? [...TNodePath, ...SplitStatePath<TDescendant>] : never : never;
+type ResolveIdTargetInStates<TStates, TTarget extends string, TPrefix extends StatePath = []> = TStates extends Record<string, unknown> ? { [K in keyof TStates & string]: ResolveIdTargetAtNode<TStates[K], AppendStatePath<TPrefix, K>, TTarget> | (0 extends 1 & TStates[K] ? never : TStates[K] extends {
+  states: infer TChildren;
+} ? ResolveIdTargetInStates<TChildren, TTarget, AppendStatePath<TPrefix, K>> : never); }[keyof TStates & string] : never;
+type ResolveIdTargetPath<TConfig, TTarget extends string> = ResolveIdTargetAtNode<TConfig, [], TTarget> | (TConfig extends {
+  states: infer TStates;
+} ? ResolveIdTargetInStates<TStates, TTarget> : never);
+type ResolveAuthoredTarget<TSourcePath extends StatePath, TTarget extends string> = TTarget extends `#${string}` ? never : TTarget extends '.' ? TSourcePath : TTarget extends `.${infer TDescendant}` ? [...TSourcePath, ...SplitStatePath<TDescendant>] : [...ParentStatePath<TSourcePath>, ...SplitStatePath<TTarget>];
+type StateNodeAtPath<TConfig, TPath extends StatePath> = TConfig extends {
+  states: infer TStates;
+} ? TPath extends readonly [infer THead extends string, ...infer TTail extends string[]] ? THead extends keyof TStates ? TTail extends [] ? TStates[THead] : StateNodeAtPath<TStates[THead], TTail> : never : TConfig : never;
+type CommonStatePathSegments<TLeft extends readonly string[], TRight extends readonly string[], TCommon extends readonly string[] = []> = TLeft extends readonly [infer TLeftHead extends string, ...infer TLeftTail extends string[]] ? TRight extends readonly [infer TRightHead extends string, ...infer TRightTail extends string[]] ? TLeftHead extends TRightHead ? CommonStatePathSegments<TLeftTail, TRightTail, [...TCommon, TLeftHead]> : TCommon : TCommon : TCommon;
+type NearestCommonStatePath<TLeft extends StatePath, TRight extends StatePath> = CommonStatePathSegments<TLeft, TRight>;
+type IsAncestorStatePath<TAncestor extends StatePath, TDescendant extends StatePath> = TDescendant extends readonly [...TAncestor, ...infer TRest] ? TRest extends [] ? false : true : false;
+type IsParallelStatePath<TConfig, TPath extends StatePath> = TPath extends readonly [] ? TConfig extends {
+  type: 'parallel';
+} ? true : false : StateNodeAtPath<TConfig, TPath> extends {
+  type: 'parallel';
+} ? true : false;
+type ResolvedAuthoredTargetPath<TRootConfig, TSourcePath extends StatePath, TTarget> = TTarget extends string ? TTarget extends `#${string}` ? ResolveIdTargetPath<TRootConfig, TTarget> : ResolveAuthoredTarget<TSourcePath, TTarget> : never;
+type InvalidTargetPair<TRootConfig, TLeftPath extends StatePath, TRightPath extends StatePath> = TLeftPath extends TRightPath ? TRightPath extends TLeftPath ? true : never : IsAncestorStatePath<TLeftPath, TRightPath> extends true ? true : IsAncestorStatePath<TRightPath, TLeftPath> extends true ? true : IsParallelStatePath<TRootConfig, NearestCommonStatePath<TLeftPath, TRightPath>> extends true ? never : true;
+type InvalidTargetPairsWithHead<TRootConfig, TSourcePath extends StatePath, THead, TRest extends readonly unknown[]> = TRest extends readonly [infer TNext, ...infer TTail] ? (ResolvedAuthoredTargetPath<TRootConfig, TSourcePath, THead> extends (infer THeadPath extends StatePath) ? ResolvedAuthoredTargetPath<TRootConfig, TSourcePath, TNext> extends (infer TNextPath extends StatePath) ? InvalidTargetPair<TRootConfig, THeadPath, TNextPath> : never : never) | InvalidTargetPairsWithHead<TRootConfig, TSourcePath, THead, TTail> : never;
+type InvalidTargetSet<TRootConfig, TSourcePath extends StatePath, TTargets> = TTargets extends readonly [infer THead, ...infer TRest] ? InvalidTargetPairsWithHead<TRootConfig, TSourcePath, THead, TRest> | InvalidTargetSet<TRootConfig, TSourcePath, TRest> : never;
+type InvalidTargetValue<TRootConfig, TSourcePath extends StatePath, TTarget> = TTarget extends string ? string extends TTarget ? never : TTarget extends `#${string}` ? TTarget extends AuthoredIdTargets<TRootConfig> ? never : TTarget : ResolveAuthoredTarget<TSourcePath, TTarget> extends (infer TResolvedTarget extends StatePath) ? TResolvedTarget extends AuthoredStatePaths<TRootConfig> ? never : true extends IsWithinStatePath<TResolvedTarget, OpaqueStatePaths<TRootConfig>> ? never : TTarget : TTarget : TTarget extends readonly unknown[] ? InvalidTargetValue<TRootConfig, TSourcePath, TTarget[number]> : never;
+type InvalidTransitionTarget<TRootConfig, TSourcePath extends StatePath, TTransition> = 0 extends 1 & TTransition ? never : TTransition extends ((...args: any[]) => any) ? InvalidTransitionTarget<TRootConfig, TSourcePath, ReturnType<TTransition>> : TTransition extends readonly unknown[] ? InvalidTransitionTarget<TRootConfig, TSourcePath, TTransition[number]> : TTransition extends {
+  target: infer TTarget;
+} ? InvalidTargetValue<TRootConfig, TSourcePath, TTarget> | InvalidTargetSet<TRootConfig, TSourcePath, TTarget> : never;
+type InvalidTransitionMapTargets<TRootConfig, TSourcePath extends StatePath, TTransitionMap> = 0 extends 1 & TTransitionMap ? never : TTransitionMap extends Record<string, unknown> ? { [K in keyof TTransitionMap]: InvalidTransitionTarget<TRootConfig, TSourcePath, TTransitionMap[K]>; }[keyof TTransitionMap] : never;
+type InvalidInitialTarget<TRootConfig, TChildStates, TInitialTarget> = TInitialTarget extends string ? string extends TInitialTarget ? never : TInitialTarget extends keyof TChildStates ? never : TInitialTarget extends `#${string}` ? TInitialTarget extends AuthoredIdTargets<TRootConfig> ? never : TInitialTarget : TInitialTarget : never;
+type InvalidInvokeTargets<TRootConfig, TSourcePath extends StatePath, TInvoke> = 0 extends 1 & TInvoke ? never : TInvoke extends {
+  readonly [createdInvokeConfig]: infer TConfig;
+} ? InvalidInvokeTargets<TRootConfig, TSourcePath, TConfig> : TInvoke extends readonly unknown[] ? InvalidInvokeTargets<TRootConfig, TSourcePath, TInvoke[number]> : TInvoke extends Record<string, unknown> ? (TInvoke extends {
+  onDone: infer TOnDone;
+} ? InvalidTransitionTarget<TRootConfig, TSourcePath, TOnDone> : never) | (TInvoke extends {
+  onError: infer TOnError;
+} ? InvalidTransitionTarget<TRootConfig, TSourcePath, TOnError> : never) | (TInvoke extends {
+  onSnapshot: infer TOnSnapshot;
+} ? InvalidTransitionTarget<TRootConfig, TSourcePath, TOnSnapshot> : never) | (TInvoke extends {
+  onTimeout: infer TOnTimeout;
+} ? InvalidTransitionTarget<TRootConfig, TSourcePath, TOnTimeout> : never) : never;
+type InvalidNodeTargets<TRootConfig, TNode, TSourcePath extends StatePath> = 0 extends 1 & TNode ? never : (TNode extends {
+  initial: infer TInitial;
+  states: infer TChildStates;
+} ? (TInitial extends {
+  target: infer TInitialTarget;
+} ? TInitialTarget : TInitial) extends (infer TInitialTarget) ? InvalidInitialTarget<TRootConfig, TChildStates, TInitialTarget> : never : never) | (TNode extends {
+  on: infer TOn;
+} ? InvalidTransitionMapTargets<TRootConfig, TSourcePath, TOn> : never) | (TNode extends {
+  always: infer TAlways;
+} ? InvalidTransitionTarget<TRootConfig, TSourcePath, TAlways> : never) | (TNode extends {
+  choice: infer TChoice;
+} ? InvalidTransitionTarget<TRootConfig, TSourcePath, TChoice> : never) | (TNode extends {
+  after: infer TAfter;
+} ? InvalidTransitionMapTargets<TRootConfig, TSourcePath, TAfter> : never) | (TNode extends {
+  onDone: infer TOnDone;
+} ? InvalidTransitionTarget<TRootConfig, TSourcePath, TOnDone> : never) | (TNode extends {
+  onError: infer TOnError;
+} ? InvalidTransitionTarget<TRootConfig, TSourcePath, TOnError> : never) | (TNode extends {
+  onTimeout: infer TOnTimeout;
+} ? InvalidTransitionTarget<TRootConfig, TSourcePath, TOnTimeout> : never) | (TNode extends {
+  invoke: infer TInvoke;
+} ? InvalidInvokeTargets<TRootConfig, TSourcePath, TInvoke> : never) | (TNode extends {
+  target: infer THistoryTarget;
+} ? InvalidTargetValue<TRootConfig, TSourcePath, THistoryTarget> : never);
+type InvalidTargetsInStates<TRootConfig, TStates, TPrefix extends StatePath = []> = TStates extends Record<string, unknown> ? { [K in keyof TStates & string]: 0 extends 1 & TStates[K] ? never : InvalidNodeTargets<TRootConfig, TStates[K], AppendStatePath<TPrefix, K>> | (TStates[K] extends {
+  states: infer TChildren;
+} ? InvalidTargetsInStates<TRootConfig, TChildren, AppendStatePath<TPrefix, K>> : never); }[keyof TStates & string] : never;
+/**
+ * Rejects authored literal transition targets that do not resolve in the
+ * machine topology.
+ */
+type ValidateStateTargets<TConfig> = 0 extends 1 & TConfig ? unknown : TConfig extends {
+  states: infer TStates;
+} ? (TConfig extends {
+  initial: infer TInitial;
+} ? (TInitial extends {
+  target: infer TInitialTarget;
+} ? TInitialTarget : TInitial) extends (infer TInitialTarget) ? InvalidInitialTarget<TConfig, TStates, TInitialTarget> : never : never) | InvalidNodeTargets<TConfig, TConfig, []> | InvalidTargetsInStates<TConfig, TStates> extends never ? unknown : never : unknown;
+/**
+ * Durable machine snapshot fields that a historical snapshot schema describes.
+ *
+ * @public
+ */
+type PersistedMachineSnapshot = {
+  status: Snapshot<unknown>['status'];
+  output?: unknown;
+  error?: unknown;
+  value: unknown;
+  context: unknown;
+  children: Record<string, unknown>;
+  historyValue: Record<string, unknown>;
+  timers: Record<string, unknown>;
+  _nextActorId?: number;
+  _nextActorIds?: Record<string, number>;
+  _nextTimerId?: number;
+  stateInputs?: Record<string, Record<string, unknown>>;
+  machine?: {
+    id: string;
+    version: string;
+  };
+  version?: string;
+  [key: string]: unknown;
+};
+/**
+ * A Standard Schema for a complete persisted machine snapshot.
+ *
+ * @public
+ */
+type MachineSnapshotSchema = StandardSchemaV1<unknown, PersistedMachineSnapshot>;
+/**
+ * A Standard Schema for a complete persisted event object.
+ *
+ * @public
+ */
+type MachineEventSchema = StandardSchemaV1<unknown, EventObject>;
+/**
+ * Schema-backed capabilities for one machine version.
+ *
+ * @public
+ */
+type MachineVersionDescriptor = {
+  id: string;
+  version: string;
+} & ({
+  snapshotSchema: MachineSnapshotSchema;
+  eventSchema?: MachineEventSchema;
+} | {
+  snapshotSchema?: MachineSnapshotSchema;
+  eventSchema: MachineEventSchema;
+});
+/** @experimental */
+type ActorValidationBoundary = 'input' | 'event' | 'context' | 'state.input' | 'state.context' | 'emitted' | 'output' | 'child';
+/** @experimental */
+type ActorValidationEventOrigin = 'external' | 'actor' | 'raised';
+/** @experimental */
+type ActorValidationRequest = {
+  kind: 'input';
+  logic: AnyActorLogic;
+  input: unknown;
+} | {
+  kind: 'event';
+  logic: AnyActorLogic;
+  event: AnyEventObject;
+  eventOrigin: Exclude<ActorValidationEventOrigin, 'raised'>;
+} | {
+  kind: 'result';
+  logic: AnyActorLogic;
+  snapshot: Snapshot<unknown>;
+  effects: readonly ExecutableActionObject[];
+};
+/**
+ * Runtime schema validator installed on actor logic.
+ *
+ * @experimental
+ */
+interface ActorLogicValidator {
+  check(request: ActorValidationRequest): Error | undefined;
+}
+/**
+ * A record of a single action executed during a transition.
+ *
+ * Carried in {@link TransitionInspectionEvent.actions}, this replaces the v5
+ * standalone `@xstate.action` inspection event.
+ *
+ * @experimental
+ */
+interface ActionRecord {
+  /** The action type (e.g. the action creator name or `'(anonymous)'`). */
+  type: string;
+  /** The resolved params for the action, if any. */
+  params: unknown;
+}
+/**
+ * A record of a single event relayed to another actor during a transition.
+ *
+ * Carried in {@link TransitionInspectionEvent.sent}, this captures the send on
+ * the _sender's_ transition — including delayed/scheduled sends that may never
+ * deliver — distinct from the target actor's own processed-event transition.
+ *
+ * @experimental
+ */
+interface SentRecord {
+  /** The actor the event was sent to. */
+  targetRef: ActorRefLike;
+  /** The `id` of the target actor. */
+  targetId: string;
+  /** The event that was sent. */
+  event: AnyEventObject;
+  /** The delay (ms) for a scheduled send, or `undefined` for an immediate send. */
+  delay?: number | undefined;
+  /** The scheduling id for a scheduled send, used for cancellation. */
+  id?: string | undefined;
+}
+interface BaseInspectionEventProperties {
+  /** The session ID of the root actor. */
+  rootId: string;
+  /**
+   * The relevant actorRef for the inspection event.
+   *
+   * - For `@xstate.actor` events, this is the registered actor.
+   * - For `@xstate.transition` events, this is the actor that transitioned.
+   */
+  actorRef: ActorRefLike;
+}
+/**
+ * Announces that an actor was created in the system (the root actor and every
+ * spawned/invoked child). This is the single topology event — it carries the
+ * actor identity and parent relationship needed to draw the actor graph before
+ * any transitions occur.
+ *
+ * Actor _stop_ is derivable from `snapshot.status` on the actor's final
+ * `@xstate.transition` event, so there is no separate stop event.
+ *
+ * @experimental
+ */
+interface ActorInspectionEvent extends BaseInspectionEventProperties {
+  type: '@xstate.actor';
+  /** The parent actor, or `undefined` for the root actor. */
+  parentRef: ActorRefLike | undefined;
+  /** The `id` of the actor. */
+  id: string;
+  /** The source logic (or its referenced string) the actor was created from. */
+  src: string | AnyActorLogic;
+  /** The initial snapshot of the actor. */
+  snapshot: Snapshot<unknown>;
+}
+/**
+ * Announces an actor transition.
+ *
+ * All facets are flat and always present so consumers can read `event.actions`,
+ * `event.sent`, and `event.microsteps` directly without narrowing on absent
+ * properties. This is a superset of the v5
+ * `@xstate.event`/`@xstate.snapshot`/`@xstate.action`/`@xstate.microstep`
+ * events.
+ *
+ * @experimental
+ */
+interface TransitionInspectionEvent extends BaseInspectionEventProperties {
+  type: '@xstate.transition';
+  eventType: string;
+  /** The event that caused the transition. */
+  event: AnyEventObject;
+  /** The source actor that sent the event, if any. */
+  sourceRef: ActorRefLike | undefined;
+  /** The target actor of the transition (usually the same as `actorRef`). */
+  targetRef: ActorRefLike | undefined;
+  /** The resulting snapshot of the transition. */
+  snapshot: Snapshot<unknown>;
+  /** The microstep transition definitions taken (always present). */
+  microsteps: AnyTransitionDefinition[];
+  /** The actions executed during the transition (always present). */
+  actions: ActionRecord[];
+  /** The events relayed to other actors during the transition (always present). */
+  sent: SentRecord[];
+}
+/**
+ * A lossless inspection protocol:
+ *
+ * - `@xstate.actor` — actor topology (identity + parent), drawable up front.
+ * - `@xstate.transition` — every transition facet: event, snapshot, source,
+ *   microsteps, executed actions, and sent/scheduled events.
+ *
+ * POLICY: the protocol is exactly `@xstate.actor` and `@xstate.transition`. Do
+ * not add event types to this union. Dead letters (undeliverable events) are
+ * not inspection events: observe them with `system.onRejectedEvent`, the
+ * `onRejectedEvent` actor option, the `deadLetter` runtime operation, or the
+ * development warning. The protocol is deliberately
+ * minimal so inspectors can be written against a fixed set. New observable
+ * facets belong as fields on `@xstate.transition` (or on the existing events),
+ * or are derived by the consumer. Examples of derivation: an unhandled event
+ * is a `@xstate.transition` whose `snapshot` is the same reference as the
+ * previous one with no `actions`; actor stop is the final transition's
+ * `snapshot.status`. The `inspection.conformance.v6.test.ts` type test pins
+ * the member list.
+ *
+ * @experimental
+ */
+type InspectionEvent = ActorInspectionEvent | TransitionInspectionEvent;
+interface ScheduledTimer {
+  id: string;
+  scheduledAt: number;
+  dueAt: number;
+  delay: number;
+  source: AnyActor;
+}
+interface Clock {
+  /** Returns the clock's current time in milliseconds. */
+  now?(): number;
+  setTimeout(fn: (...args: any[]) => void, timeout: number): any;
+  clearTimeout(id: any): void;
+}
+interface WallClock {
+  now(): number;
+}
+interface CryptoSource {
+  getRandomValues?(array: Uint32Array<ArrayBuffer>): Uint32Array<ArrayBuffer>;
+  randomUUID?(): string;
+}
+interface Scheduler {
+  schedule(source: AnyActor, id: string, delay: number): void;
+  cancel(source: AnyActor, id: string): void;
+  cancelAll(actor: AnyActor): void;
+}
+/**
+ * Runtime operations used to execute effects.
+ *
+ * XState calculates pure transitions; a runtime executes their effects. The
+ * built-in local runtime is one implementation at the same level as any
+ * other: install a different one via `system.runtime` (for durable hosts,
+ * through `createDurable`'s adapter runtime operations).
+ */
+/**
+ * Why an event was not delivered: `'invalidEvent'` (payload failed its
+ * declared schema), `'internalEvent'` (an internal event type sent from
+ * outside its owning actor), `'stopped'` (the target actor already stopped)
+ * or `'missingTarget'` (`enq.sendTo` received an undefined ref, an unknown
+ * child id, or the `parent` of a root actor). Hosts may report additional
+ * reasons.
+ *
+ * @public
+ */
+type EventRejectionReason = 'invalidEvent' | 'internalEvent' | 'stopped' | 'missingTarget' | (string & {});
+/**
+ * Extra detail attached to a dead letter.
+ *
+ * @public
+ */
+interface DeadLetterDetail {
+  /** Standard Schema issues for `invalidEvent` rejections. */
+  issues?: readonly StandardSchemaV1.Issue[] | undefined;
+  /** The underlying error describing the rejection. */
+  error?: Error | undefined;
+  /**
+   * The unresolved target id for `missingTarget` rejections (the child id
+   * passed to `enq.sendTo`), when one was given.
+   */
+  targetId?: string | undefined;
+}
+/**
+ * Describes an event that was rejected at the delivery boundary instead of
+ * being delivered to its target actor (a dead letter).
+ *
+ * @public
+ */
+interface EventRejection extends DeadLetterDetail {
+  /** The event that was rejected. */
+  event: AnyEventObject;
+  /** The actor the event was addressed to. */
+  targetRef: AnyActor | undefined;
+  /** The `id` of the target actor. */
+  targetId: string | undefined;
+  /** The actor that sent the event, or `undefined` for an external send. */
+  sourceRef: AnyActor | undefined;
+  /** Whether the event came from outside the system or from another actor. */
+  eventOrigin: 'external' | 'actor';
+  reason: EventRejectionReason;
+}
+/** @experimental */
+interface ActorSystemRuntime {
+  /** Publishes a newly created actor to the runtime. */
+  spawnActor(source: AnyActor | undefined, actor: AnyActor): void | PromiseLike<void>;
+  /** Starts an actor. */
+  startActor(actor: AnyActor): void | PromiseLike<void>;
+  /** Stops an actor without producing a completion result. */
+  stopActor(actor: AnyActor): void | PromiseLike<void>;
+  /** Completes or errors an actor and publishes its terminal result. */
+  terminateActor(actor: AnyActor, termination: ActorTermination): void | PromiseLike<void>;
+  /** Delivers an event between actors. */
+  sendEvent(source: AnyActor | undefined, target: AnyActor, event: AnyEventObject): void | PromiseLike<void>;
+  /** Publishes an emitted event. */
+  emitEvent(source: AnyActor, event: EventObject): void | PromiseLike<void>;
+  /** Schedules a logical timer. */
+  scheduleTimer(source: AnyActor, id: string, delay: number): void | PromiseLike<void>;
+  /** Cancels one logical timer. */
+  cancelTimer(source: AnyActor, id: string): void | PromiseLike<void>;
+  /**
+   * Runs an async actor's entire body as one durable unit. The actor is the
+   * natural journal entry: its identity — `address`, string `src` key and
+   * serializable `input` — crosses any boundary, so a host can wrap `exec`
+   * in its own step primitive, or ignore `exec` entirely and re-run the
+   * registered logic on a remote executor from `(src, input)` alone. The
+   * default runs the body in this process, unjournaled.
+   *
+   * Like `runStep`, this is an orchestration frame: it may span external
+   * events and must never be serialized behind other runtime operations.
+   */
+  runLogic(actor: AnyActor, exec: () => PromiseLike<unknown>): PromiseLike<unknown>;
+  /**
+   * Runs one keyed step of an async actor (`enq.step`). The default journals
+   * the result in the actor's own snapshot; a durable host implements this
+   * to journal steps in its own journal instead — memoized results replay
+   * without re-running `exec`.
+   *
+   * Unlike other runtime operations, a step is an orchestration frame that
+   * may itself await runtime operations, so implementations must not
+   * serialize it behind them.
+   */
+  runStep(actor: AnyActor, key: string, exec: () => unknown | PromiseLike<unknown>): unknown | PromiseLike<unknown>;
+  /**
+   * Reports an undeliverable event. Delivery stays at-most-once — this is
+   * observability, not retry. The system always calls its
+   * `onRejectedEvent` listeners first; the default then logs in development.
+   * `detail` carries validation issues and the underlying error for events
+   * rejected at the delivery boundary.
+   */
+  deadLetter(source: AnyActor | undefined, target: AnyActor | undefined, event: AnyEventObject, reason: EventRejectionReason, detail?: DeadLetterDetail): void | PromiseLike<void>;
+  /** Cancels all logical timers owned by an actor. */
+  cancelAllTimers(source: AnyActor): void | PromiseLike<void>;
+}
+/** @public */
+interface ActorSystem<T extends ActorSystemInfo> extends ActorSystemRuntime {
+  get: <K extends keyof T['actors']>(key: K) => T['actors'][K] | undefined;
+  getAll: () => Partial<T['actors']>;
+  inspect: (observer: Observer<InspectionEvent> | ((inspectionEvent: InspectionEvent) => void)) => Subscription;
+  /**
+   * Subscribes to events the system could not deliver (dead letters): sends
+   * to a stopped actor, events rejected at the delivery boundary
+   * and internal events sent from outside their owner. Listeners run in
+   * registration order; a listener that throws does not prevent the others.
+   * The `onRejectedEvent` option on `createActor` registers a listener the
+   * same way.
+   *
+   * @public
+   */
+  onRejectedEvent: (listener: (rejection: EventRejection) => void) => Subscription;
+  scheduler: Scheduler;
+  getSnapshot: () => {
+    _scheduledTimers: Record<string, ScheduledTimer>;
+  };
+  start: () => void;
+  _clock: Clock;
+  _wallClock: WallClock;
+  _logger: (...args: any[]) => void;
+  _reportUnhandledError: (error: unknown) => void;
+  _warn: (message: string) => void;
+  /**
+   * The runtime executing this system's effects. When unset, the built-in
+   * local in-memory runtime runs them; `createActor(machine).start()` is just
+   * that built-in runtime. A host runtime installed here applies to every
+   * actor in the system — snapshot-scoped views and children created later
+   * included — and may implement any subset of operations, with the rest
+   * keeping the built-in behavior.
+   *
+   * An operation that returns a promise owns its own failure handling: the
+   * paths that hand work to a runtime do not await it. `createDurable`
+   * tracks its adapter's operations and fails `executeEffects` when one
+   * rejects.
+   *
+   * Durable hosts should provide this through `createDurable`'s
+   * adapter runtime operations rather than assigning it directly.
+   */
+  runtime?: Partial<ActorSystemRuntime>;
+}
+/** @public */
+type AnyActorSystem = ActorSystem<any>;
+/** @public */
+type AsyncSnapshot<TOutput, TInput, TError = unknown> = Snapshot<TOutput, TError> & {
+  input: TInput | undefined;
+  effects?: Record<string, {
+    status: 'active';
+  } | {
+    status: 'done';
+    output?: unknown;
+  } | {
+    status: 'error';
+    error: unknown;
+  }>;
+};
+/** @public */
+type AsyncActorLogic<TOutput, TInput = unknown, TEmitted extends EventObject = EventObject, TError = unknown> = ActorLogic<AsyncSnapshot<TOutput, TInput, TError>, {
+  type: string;
+  [k: string]: unknown;
+}, TInput, AnyActorSystem, TEmitted>;
+/** @public */
+type AsyncActorRef<TOutput> = ActorRefFromLogic<AsyncActorLogic<TOutput, unknown>>;
+type AsyncActor<TOutput, TInput = unknown, TEmitted extends EventObject = EventObject> = ActorFromLogic<AsyncActorLogic<TOutput, TInput, TEmitted>>;
+/** @public */
+interface LogicArgs<TOutput, TInput> {
+  /** Data that was provided to the async actor. */
+  input: TInput;
+  /** The actor system to which the async actor belongs. */
+  system: AnyActorSystem;
+  /** The async actor. */
+  self: AsyncActor<TOutput, TInput>;
+  /** Aborted when the async actor is stopped or times out. */
+  signal: AbortSignal;
+}
+/** @public */
+interface LogicEnqueue<TEmitted extends EventObject> {
+  /** Emits an event that can be observed with `actor.on(...)`. */
+  emit: (emitted: TEmitted) => void;
+  /**
+   * Executes async work as a durable effect keyed by `key`.
+   *
+   * @experimental The durability semantics (step journaling, replay, and
+   *   resumption across persistence) are not finalized and may change.
+   */
+  step: <TStepOutput>(key: string, exec: () => TStepOutput | PromiseLike<TStepOutput>) => Promise<TStepOutput>;
+}
+/** @public */
+type LogicFunction<TOutput, TInput = NonReducibleUnknown, TEmitted extends EventObject = EventObject> = (args: LogicArgs<TOutput, TInput>, enq: LogicEnqueue<TEmitted>) => PromiseLike<TOutput>;
+type AsyncLogicFunctionOutput<TLogicFunction extends (...args: any[]) => PromiseLike<any>> = Awaited<ReturnType<TLogicFunction>>;
+/** @public */
+interface LogicConfig<TOutput, TInput = NonReducibleUnknown, TEmitted extends EventObject = EventObject, TInputSchema extends StandardSchemaV1 = StandardSchemaV1, TOutputSchema extends StandardSchemaV1 = StandardSchemaV1, TErrorSchema extends StandardSchemaV1 = StandardSchemaV1> {
+  /**
+   * Stable identifier for this async logic. This identifies the logic, not a
+   * particular actor instance.
+   */
+  id?: string | undefined;
+  validator?: ActorLogicValidator | undefined;
+  /** Schemas for inferring async logic types. */
+  schemas?: {
+    input?: TInputSchema;
+    output?: TOutputSchema;
+    /**
+     * Types the error this logic fails with: the `error` snapshot field and
+     * `event.error` in the invoking machine's `onError`. Type-only.
+     */
+    error?: TErrorSchema;
+  } | undefined;
+  /** Maximum time this async logic may run before it is aborted and errors. */
+  timeout?: number | string;
+  /** The async work to execute when the actor starts. */
+  run: LogicFunction<TOutput, TInput, TEmitted>;
+}
+/** @public */
+declare class TimeoutError extends Error {
+  constructor(timeout: number | string);
+}
+/**
+ * The error type of async logic: the `schemas.error` output, plus
+ * {@link TimeoutError} when a `timeout` is configured.
+ *
+ * @public
+ */
+type AsyncLogicError<TErrorSchema extends StandardSchemaV1, TTimeout> = [TTimeout] extends [undefined] ? StandardSchemaV1.InferOutput<TErrorSchema> : StandardSchemaV1.InferOutput<TErrorSchema> | TimeoutError;
+/**
+ * Represents an actor created by `createAsyncLogic`.
+ *
+ * The type of `self` within the actor's logic.
+ *
+ * @example
+ *
+ * ```ts
+ * import { createAsyncLogic, createActor } from '@systemfsoftware/xstate';
+ *
+ * // The actor's resolved output
+ * type Output = string;
+ * // The actor's input.
+ * type Input = { message: string };
+ *
+ * // Actor logic that fetches the url of an image of a cat saying `input.message`.
+ * const logic = createAsyncLogic<Output, Input>({
+ *   run: async ({ input, self }, enq) => {
+ *     self;
+ *     // ^? AsyncActor<Output, Input>
+ *     enq.emit({ type: 'request.start' });
+ *
+ *     const data = await fetch(
+ *       `https://cataas.com/cat/says/${input.message}`
+ *     );
+ *     const url = await data.json();
+ *     return url;
+ *   }
+ * });
+ *
+ * const actor = createActor(logic, { input: { message: 'hello world' } });
+ * //    ^? AsyncActor<Output, Input>
+ * ```
+ *
+ * @see {@link (createAsyncLogic:1)}
+ */
+/**
+ * An actor logic creator which returns async logic as defined by an async
+ * process that resolves or rejects after some time.
+ *
+ * Actors created from async actor logic can:
+ *
+ * - Output the resolved value of the async process
+ * - Error with the rejected value of the async process
+ * - Abort when stopped or timed out
+ *
+ * Sending events to async actors will have no effect.
+ *
+ * @example
+ *
+ * ```ts
+ * const asyncLogic = createAsyncLogic({
+ *   id: 'fetch-user',
+ *   timeout: '30s',
+ *   run: async ({ signal }, enq) => {
+ *     enq.emit({ type: 'request.start' });
+ *     const result = await fetch('https://example.com/...', {
+ *       signal
+ *     }).then((data) => data.json());
+ *
+ *     return result;
+ *   }
+ * });
+ *
+ * const asyncActor = createActor(asyncLogic);
+ * asyncActor.subscribe((snapshot) => {
+ *   console.log(snapshot);
+ * });
+ * asyncActor.start();
+ * // => {
+ * //   output: undefined,
+ * //   status: 'active'
+ * //   ...
+ * // }
+ *
+ * // After promise resolves
+ * // => {
+ * //   output: { ... },
+ * //   status: 'done',
+ * //   ...
+ * // }
+ * ```
+ *
+ * @param asyncLogic A config object with a `run` function which returns a
+ *   Promise, and accepts an object with the following properties:
+ *
+ *   - `input` - Data that was provided to the async actor
+ *   - `self` - The async actor ref
+ *   - `system` - The actor system to which the async actor belongs
+ *   - `signal` - An abort signal for cancellation
+ *
+ *   `run` also receives an `enq` object with the following properties:
+ *
+ *   - `emit` - Emits an event that can be observed with `actor.on(...)`
+ *
+ * @see {@link https://stately.ai/docs/input | Input docs} for more information about how input is passed
+ * @public
+ */
+declare function createAsyncLogic<const TInputSchema extends StandardSchemaV1, const TOutputSchema extends StandardSchemaV1, TEmitted extends EventObject = EventObject, const TErrorSchema extends StandardSchemaV1 = StandardSchemaV1, TTimeout extends number | string | undefined = undefined>(asyncLogic: LogicConfig<StandardSchemaV1.InferOutput<TOutputSchema>, StandardSchemaV1.InferOutput<TInputSchema>, TEmitted, TInputSchema, TOutputSchema, TErrorSchema> & {
+  schemas: {
+    input: TInputSchema;
+    output: TOutputSchema;
+    error?: TErrorSchema;
+  };
+} & {
+  timeout?: TTimeout;
+}): AsyncActorLogic<StandardSchemaV1.InferOutput<TOutputSchema>, StandardSchemaV1.InferOutput<TInputSchema>, TEmitted, AsyncLogicError<TErrorSchema, TTimeout>> & {
+  id?: string;
+};
+declare function createAsyncLogic<const TInputSchema extends StandardSchemaV1, TEmitted extends EventObject = EventObject, TLogicFunction extends LogicFunction<any, StandardSchemaV1.InferOutput<TInputSchema>, TEmitted> = LogicFunction<any, StandardSchemaV1.InferOutput<TInputSchema>, TEmitted>, const TErrorSchema extends StandardSchemaV1 = StandardSchemaV1, TTimeout extends number | string | undefined = undefined>(asyncLogic: Omit<LogicConfig<never, StandardSchemaV1.InferOutput<TInputSchema>, TEmitted, TInputSchema>, 'run' | 'schemas'> & {
+  schemas: {
+    input: TInputSchema;
+    output?: never;
+    error?: TErrorSchema;
+  };
+  run: TLogicFunction;
+} & {
+  timeout?: TTimeout;
+}): AsyncActorLogic<AsyncLogicFunctionOutput<TLogicFunction>, StandardSchemaV1.InferOutput<TInputSchema>, TEmitted, AsyncLogicError<TErrorSchema, TTimeout>> & {
+  id?: string;
+};
+declare function createAsyncLogic<const TOutputSchema extends StandardSchemaV1, TInput = NonReducibleUnknown, TEmitted extends EventObject = EventObject, const TErrorSchema extends StandardSchemaV1 = StandardSchemaV1, TTimeout extends number | string | undefined = undefined>(asyncLogic: LogicConfig<StandardSchemaV1.InferOutput<TOutputSchema>, TInput, TEmitted, StandardSchemaV1, TOutputSchema, TErrorSchema> & {
+  schemas: {
+    input?: never;
+    output: TOutputSchema;
+    error?: TErrorSchema;
+  };
+} & {
+  timeout?: TTimeout;
+}): AsyncActorLogic<StandardSchemaV1.InferOutput<TOutputSchema>, TInput, TEmitted, AsyncLogicError<TErrorSchema, TTimeout>> & {
+  id?: string;
+};
+declare function createAsyncLogic<TOutput, TInput = NonReducibleUnknown, TEmitted extends EventObject = EventObject, const TErrorSchema extends StandardSchemaV1 = StandardSchemaV1, TTimeout extends number | string | undefined = undefined>(asyncLogic: Omit<LogicConfig<TOutput, TInput, TEmitted>, 'schemas'> & {
+  schemas: {
+    input?: never;
+    output?: never;
+    error: TErrorSchema;
+  };
+} & {
+  timeout?: TTimeout;
+}): AsyncActorLogic<TOutput, TInput, TEmitted, AsyncLogicError<TErrorSchema, TTimeout>> & {
+  id?: string;
+};
+declare function createAsyncLogic<TOutput, TInput = NonReducibleUnknown, TEmitted extends EventObject = EventObject>(asyncLogic: Omit<LogicConfig<TOutput, TInput, TEmitted>, 'schemas'> & {
+  schemas?: undefined;
+}): AsyncActorLogic<TOutput, TInput, TEmitted> & {
+  id?: string;
+};
+declare const symbolObservable: typeof Symbol.observable;
+/**
+ * An Actor is a running process that can receive events, send events and change
+ * its behavior based on the events it receives, which can cause effects outside
+ * of the actor. When you run a state machine, it becomes an actor.
+ *
+ * An `Actor` is the concrete runtime instance with lifecycle methods and
+ * system-owned internals. It also satisfies the narrower `ActorRef` contract,
+ * so consumer APIs should accept `ActorRef` when they only need to send events
+ * or read snapshots.
+ *
+ * @public
+ */
+declare class Actor<TLogic extends AnyActorLogic> implements ActorInstance<SnapshotFrom<TLogic>, EventFromLogic<TLogic>, EmittedFrom<TLogic>, SendableEventFromLogic<TLogic>> {
+  logic: TLogic;
+  /** The current internal state of the actor. */
+  private _snapshot;
+  /**
+   * The clock that is responsible for setting and clearing timeouts, such as
+   * delayed events and transitions.
+   */
+  clock: Clock;
+  wallClock: WallClock;
+  options: Readonly<ActorOptions<TLogic>>;
+  /** The unique identifier for this actor relative to its parent. */
+  id: string;
+  private _boundProcess?;
+  private mailbox?;
+  private _mailboxStarted;
+  private observers?;
+  /** Whether a consumer subscribed to this actor's error after it errored. */
+  private _errorObserved;
+  private eventListeners;
+  private logger;
+  private warn;
+  private _forceDeferredActions;
+  _parent?: AnyActor | undefined;
+  ref: ActorRef<SnapshotFrom<TLogic>, EventFromLogic<TLogic>, EmittedFrom<TLogic>, SendableEventFromLogic<TLogic>>;
+  private _actorScope;
+  private _initialEffects;
+  registryKey: string | undefined;
+  /** The globally unique process ID for this invocation. */
+  sessionId: string;
+  private _address?;
+  /**
+   * The deterministic logical address of this actor within its system: the
+   * `/`-joined path of actor ids from the root. Stable across persistence and
+   * restore, unlike `sessionId`, which identifies one incarnation.
+   *
+   * `/` separates segments, so an id containing one (a state name with a
+   * slash reaches its invoked child's id) is percent-encoded to keep the
+   * path unambiguous.
+   */
+  get address(): string;
+  /** The system to which this actor belongs. */
+  system: AnyActorSystem;
+  private _trigger?;
+  get trigger(): ActorTrigger<SendableEventFromLogic<TLogic>>;
+  private _boundSend?;
+  get send(): ActorRef<SnapshotFrom<TLogic>, EventFromLogic<TLogic>, EmittedFrom<TLogic>, SendableEventFromLogic<TLogic>>['send'];
+  src: string | AnyActorLogic;
+  /**
+   * Creates a new actor instance for the given logic with the provided options,
+   * if any.
+   *
+   * @param logic The logic to create an actor from
+   * @param options Actor options
+   */
+  constructor(logic: TLogic, options?: ActorOptions<TLogic>);
+  private _deferred;
+  private _restored;
+  private get self();
+  private get defer();
+  private get stopChild();
+  private get emit();
+  private get actionExecutor();
+  /** Associates each live snapshot with this actor for later pure transitions. */
+  private _setSnapshot;
+  private _setErrorSnapshot;
+  /** Recover via the logic's error event if possible; otherwise error out. */
+  private _recoverOrError;
+  private _tryHandleExecutionError;
+  private _next;
+  private update;
+  private _flushInitialEffects;
+  /**
+   * Subscribe an observer to an actor’s snapshot values.
+   *
+   * @remarks
+   * The observer will receive the actor’s snapshot value when it is emitted.
+   * The observer can be:
+   *
+   * - A plain function that receives the latest snapshot, or
+   * - An observer object whose `.next(snapshot)` method receives the latest
+   *   snapshot
+   *
+   * @example
+   *
+   * ```ts
+   * // Observer as a plain function
+   * const subscription = actor.subscribe((snapshot) => {
+   *   console.log(snapshot);
+   * });
+   * ```
+   *
+   * @example
+   *
+   * ```ts
+   * // Observer as an object
+   * const subscription = actor.subscribe({
+   *   next(snapshot) {
+   *     console.log(snapshot);
+   *   },
+   *   error(err) {
+   *     // ...
+   *   },
+   *   complete() {
+   *     // ...
+   *   }
+   * });
+   * ```
+   *
+   * The return value of `actor.subscribe(observer)` is a subscription object
+   * that has an `.unsubscribe()` method. You can call
+   * `subscription.unsubscribe()` to unsubscribe the observer:
+   *
+   * @example
+   *
+   * ```ts
+   * const subscription = actor.subscribe((snapshot) => {
+   *   // ...
+   * });
+   *
+   * // Unsubscribe the observer
+   * subscription.unsubscribe();
+   * ```
+   *
+   * When the actor is stopped, all of its observers will automatically be
+   * unsubscribed.
+   *
+   * @param observer - Either a plain function that receives the latest
+   *   snapshot, or an observer object whose `.next(snapshot)` method receives
+   *   the latest snapshot
+   */
+  subscribe(observer: Observer<SnapshotFrom<TLogic>>): Subscription;
+  subscribe(nextListener?: (snapshot: SnapshotFrom<TLogic>) => void, errorListener?: (error: any) => void, completeListener?: () => void): Subscription;
+  on<TType extends EmittedFrom<TLogic>['type'] | '*'>(type: TType, handler: (emitted: EmittedFrom<TLogic> & (TType extends '*' ? unknown : {
+    type: TType;
+  })) => void): Subscription;
+  select<TSelected>(selector: (snapshot: SnapshotFrom<TLogic>) => TSelected, equalityFn?: (a: TSelected, b: TSelected) => boolean): Readable<TSelected>;
+  /** Starts the Actor from the initial state */
+  start(): this;
+  private _process;
+  private _warnedUnhandledTypes?;
+  private _reportUnhandledEvent;
+  /** Stops the Actor and unsubscribe all listeners. */
+  stop(): this;
+  private _complete;
+  /**
+   * Reports an unhandled error unless a consumer observes it before the
+   * report runs. An actor can error before its creator has a chance to
+   * subscribe, so the check waits one macrotask for a subscriber with an
+   * `error` callback.
+   */
+  private _reportUnlessObserved;
+  private _error;
+  private _stopProcedure;
+  /**
+   * Sends an event to the running Actor to trigger a transition.
+   *
+   * @param event The event to send
+   */
+  private _sendPublic;
+  /**
+   * Returns the actor's serializable logical identity: its `id`, `address`,
+   * and registered source key (when the actor was created from one).
+   */
+  toJSON(): {
+    xstate$type: string;
+    id: string;
+    address: string;
+    src: string | undefined;
+  };
+  /**
+   * Obtain the internal state of the actor, which can be persisted.
+   *
+   * @remarks
+   * The internal state can be persisted from any actor, not only machines.
+   *
+   * Note that the persisted state is not the same as the snapshot from
+   * {@link Actor.getSnapshot}. Persisted state represents the internal state of
+   * the actor, while snapshots represent the actor's last emitted value.
+   *
+   * Can be restored with {@link ActorOptions.snapshot}
+   * @see https://stately.ai/docs/persistence
+   */
+  getPersistedSnapshot(options?: {
+    /**
+     * Whether persisted machine children embed their own persisted state
+     * (the co-locating runtime's whole-tree checkpoint) or are referenced by
+     * logical address only, leaving each child's state with the runtime that
+     * owns it. Defaults to `true`.
+     */
+    embedChildren?: boolean;
+  }): PersistedSnapshotOf<TLogic>;
+  [symbolObservable](): InteropSubscribable<SnapshotFrom<TLogic>>;
+  /**
+   * Read an actor’s snapshot synchronously.
+   *
+   * @remarks
+   * The snapshot is the last value the actor published, not a query of its
+   * private state: the actor emits a snapshot when it transitions, and this
+   * returns that cached last emission. The read is coherent within one
+   * synchronous transition turn because event processing runs to completion;
+   * across asynchronous boundaries it may be stale, like any observed value.
+   *
+   * Only co-located actors publish full snapshots. A location-transparent
+   * remote handle exposes lifecycle only (`{ status, output?, error? }`): while
+   * the handle exists among its parent's children the child is presumed
+   * `active`, and its terminal result arrives as a completion event.
+   *
+   * Note that some actors, such as callback actors generated with
+   * `createCallbackLogic`, will not emit snapshots.
+   * @see {@link Actor.(subscribe:1)} to subscribe to an actor’s snapshot values.
+   * @see {@link Actor.getPersistedSnapshot} to persist the internal state of an actor (which is more than just a snapshot).
+   */
+  getSnapshot(): SnapshotFrom<TLogic>;
+}
+/**
+ * `'input'` when creating an actor from `TLogic` requires input (its input type
+ * does not accept `undefined`), otherwise `never`.
+ *
+ * @public
+ */
+type RequiredActorOptionsKeys<TLogic extends AnyActorLogic> = undefined extends InputFrom<TLogic> ? never : 'input';
+/**
+ * The options `createActor` (and framework hooks) require for `TLogic`:
+ * `{ input }` or a persisted `{ snapshot }` when
+ * the logic requires input, otherwise nothing.
+ *
+ * @public
+ */
+type RequiredActorOptionsFor<TLogic extends AnyActorLogic> = [RequiredActorOptionsKeys<TLogic>] extends [never] ? {} : { [K in RequiredActorOptionsKeys<TLogic>]: unknown; } | {
+  snapshot: NonNullable<ActorOptions<TLogic>['snapshot']>;
+};
+/** Options accepted by {@link createActor}. */
+type CreateActorOptionsArgs<TLogic extends AnyActorLogic> = [RequiredActorOptionsKeys<TLogic>] extends [never] ? [options?: ActorOptions<TLogic>] : [options: ActorOptions<TLogic> & RequiredActorOptionsFor<TLogic>];
+/**
+ * Creates a new actor instance for the given actor logic with the provided
+ * options, if any.
+ *
+ * @remarks
+ * When you create an actor from actor logic via `createActor(logic)`, you
+ * implicitly create an actor system where the created actor is the root actor.
+ * Any actors spawned from this root actor and its descendants are part of that
+ * actor system.
+ * @example
+ *
+ * ```ts
+ * import { createActor } from '@systemfsoftware/xstate';
+ * import { someActorLogic } from './someActorLogic.ts';
+ *
+ * // Creating the actor, which implicitly creates an actor system with itself as the root actor
+ * const actor = createActor(someActorLogic);
+ *
+ * actor.subscribe((snapshot) => {
+ *   console.log(snapshot);
+ * });
+ *
+ * // Actors must be started by calling `actor.start()`, which will also start the actor system.
+ * actor.start();
+ *
+ * // Actors can receive events
+ * actor.send({ type: 'someEvent' });
+ *
+ * // You can stop root actors by calling `actor.stop()`, which will also stop the actor system and all actors in that system.
+ * actor.stop();
+ * ```
+ *
+ * @param logic - The actor logic to create an actor from. For a state machine
+ *   actor logic creator, see {@link (createMachine:1)}. Other actor logic creators
+ *   include {@link (createCallbackLogic:1)}, {@link (createEventObservableLogic:1)},
+ *   {@link (createObservableLogic:1)}, {@link (createLogic:1)}, and
+ *   {@link (createAsyncLogic:1)}.
+ * @param options - Actor options
+ * @public
+ */
+declare function createActor<TLogic extends AnyActorLogic>(logic: TLogic, ...[options]: CreateActorOptionsArgs<TLogic>): Actor<TLogic>;
+/** @public */
+type Spawner<TSystemRegistry extends SystemRegistry = SystemRegistry> = <TLogic extends AnyActorLogic>(src: TLogic, ...[options]: ConditionalRequired<[options?: {
+  id?: string;
+  registryKey?: RegistryKeyForLogic<TLogic, TSystemRegistry>;
+  input?: InputFrom<TLogic>;
+  syncSnapshot?: boolean;
+} & { [K in RequiredLogicInput<TLogic>]: unknown; }], IsNotNever<RequiredLogicInput<TLogic>>>) => ActorFromLogic<TLogic>;
+interface StateNodeOptions<TStateMeta extends MetaObject, TTransitionMeta extends MetaObject> {
+  _key: string;
+  _parent?: StateNode<any, any, TStateMeta, TTransitionMeta>;
+  _machine: AnyStateMachine;
+}
+/** @public */
+declare class StateNode<TContext extends MachineContext = MachineContext, TEvent extends EventObject = EventObject, TStateMeta extends MetaObject = any, TTransitionMeta extends MetaObject = TStateMeta> {
+  /** The raw config used to create the machine. */
+  config: AnyStateNodeConfig;
+  /**
+   * The relative key of the state node, which represents its location in the
+   * overall state value.
+   */
+  key: string;
+  /** The unique ID of the state node. */
+  id: string;
+  /**
+   * The type of this state node:
+   *
+   * - `'atomic'` - no child state nodes
+   * - `'compound'` - nested child state nodes (XOR)
+   * - `'parallel'` - orthogonal nested child state nodes (AND)
+   * - `'history'` - history state node
+   * - `'choice'` - pure routing decision state node
+   * - `'final'` - final state node
+   */
+  type: 'atomic' | 'compound' | 'parallel' | 'final' | 'history' | 'choice';
+  /** The string path from the root machine node to this node. */
+  path: string[];
+  /** The child state nodes. */
+  states: Record<string, StateNode<TContext, TEvent, TStateMeta, TTransitionMeta>>;
+  /**
+   * The type of history on this state node. Can be:
+   *
+   * - `'shallow'` - recalls only top-level historical state value
+   * - `'deep'` - recalls historical state value at all levels
+   */
+  history: false | 'shallow' | 'deep';
+  /** The action(s) to be executed upon entering the state node. */
+  entry: AnyAction | undefined;
+  /** The action(s) to be executed upon exiting the state node. */
+  exit: AnyAction | undefined;
+  /** The parent state node. */
+  parent?: StateNode<TContext, TEvent, TStateMeta, TTransitionMeta> | undefined;
+  /** The root machine node. */
+  machine: AnyStateMachine;
+  /**
+   * The meta data associated with this state node, which will be returned in
+   * State instances.
+   */
+  meta?: TStateMeta;
+  /**
+   * The output data sent with the `xstate.done.state` event if this is a final
+   * state node.
+   */
+  output?: Mapper<MachineContext, EventObject, unknown, EventObject> | NonReducibleUnknown;
+  /**
+   * The order this state node appears. Corresponds to the implicit document
+   * order.
+   */
+  order: number;
+  description?: string | undefined;
+  schemas: SetupStateSchemas | undefined;
+  tags: string[];
+  transitions: Map<string, TransitionDefinition<any, any, TTransitionMeta>[]>;
+  always?: Array<TransitionDefinition<any, any, TTransitionMeta>> | undefined;
+  invoke: Array<InvokeDefinition<any, any, any, TTransitionMeta, any, any, any, any>>;
+  on: TransitionDefinitionMap<any, any, TTransitionMeta>;
+  after: Array<DelayedTransitionDefinition<any, any, TTransitionMeta>>;
+  events: Array<EventDescriptor<any>>;
+  ownEvents: Array<EventDescriptor<any>>;
+  private _candidateCache?;
+  constructor(
+  /** The raw config used to create the machine. */
+  config: AnyStateNodeConfig, options: StateNodeOptions<TStateMeta, TTransitionMeta>);
+  get initial(): InitialTransitionDefinition<TTransitionMeta>;
+}
+/** @public */
+declare function checkStateIn(stateValue: StateValue): (snapshot: AnyMachineSnapshot) => boolean;
+declare function checkStateIn(snapshot: AnyMachineSnapshot, stateValue: StateValue): boolean;
+/**
+ * Returns the state nodes represented by the current state value.
+ *
+ * @param stateValue The state value or State instance
+ * @public
+ */
+declare function getStateNodes(stateNode: AnyStateNode, stateValue: StateValue): Array<AnyStateNode>;
+type TransitionSelectionResult = {
+  enabled: boolean;
+  result: unknown;
+  reusable: boolean;
+};
+type TransitionSelectionResults = Map<AnyTransitionDefinition, TransitionSelectionResult>;
+/**
+ * Thrown when one macrostep takes more microsteps than the machine's
+ * `options.maxIterations` (default `1000`) without reaching a stable state,
+ * usually because eventless transitions or raised events form a cycle.
+ *
+ * @public
+ */
+declare class InfiniteTransitionError extends Error {
+  /** The id of the actor that was transitioning, if any. */
+  readonly actorId: string | undefined;
+  /** The event being processed. */
+  readonly event: EventObject;
+  /** The microstep bound that was exceeded. */
+  readonly maxIterations: number;
+  /** The last (up to 5) state values visited, oldest first. */
+  readonly states: StateValue[];
+  constructor(actorId: string | undefined, event: EventObject, maxIterations: number, states: StateValue[]);
+}
+type CompatibleProvidedActorSource<TExpected extends AnyActorLogic, TActual extends AnyActorLogic> = IsAny<TActual> extends true ? TActual : [OutputFrom<TActual>] extends [OutputFrom<TExpected>] ? [Omit<SnapshotFrom<TActual>, 'input'>] extends [Omit<SnapshotFrom<TExpected>, 'input'>] ? [InputFrom<TExpected>] extends [InputFrom<TActual>] ? [EventFromLogic<TExpected>] extends [EventFromLogic<TActual>] ? [EmittedFrom<TActual>] extends [EmittedFrom<TExpected>] ? TActual : never : never : never : never : never;
+type ProvidedActors<TExpectedActorMap extends Sources['actors'], TProvidedActorMap extends Partial<Record<keyof TExpectedActorMap & string, AnyActorLogic>>> = { [K in keyof TProvidedActorMap]: K extends keyof TExpectedActorMap ? TProvidedActorMap[K] extends AnyActorLogic ? CompatibleProvidedActorSource<TExpectedActorMap[K], TProvidedActorMap[K]> : never : never; };
+type ProvidedSourceMap<TDeclared, TProvided> = { [K in keyof TDeclared]: K extends keyof TProvided ? {} extends Pick<TProvided, K> ? TDeclared[K] | Exclude<TProvided[K], undefined> : Exclude<TProvided[K], undefined> : TDeclared[K]; };
+type ProvidedActionContracts<T> = { [K in keyof T]: T[K] extends ((...args: infer TArgs) => any) ? (...args: TArgs) => void : never; };
+/** @public */
+declare class StateMachine<TContext extends MachineContext, TEvent extends EventObject, TChildren extends Record<string, AnyActorRef | undefined>, TStateValue extends StateValue, TTag extends string, TInput, TOutput, TEmitted extends EventObject, TMeta extends MetaObject, TConfig extends StateSchema, TActionMap extends Sources['actions'], TActorMap extends Sources['actors'], TGuardMap extends Sources['guards'], TDelayMap extends Sources['delays'], TInternalEvent extends EventObject = never, TTransitionMeta extends MetaObject = TMeta> implements ActorLogic<MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>, TEvent, TInput, AnyActorSystem, TEmitted> {
+  /** The raw config used to create the machine. */
+  config: Next_MachineConfig<any, any, any, any, any, any, any, any, any, any, any, any, any> & {
+    schemas?: AnyMachineSchemas;
+  };
+  validator?: ActorLogicValidator | undefined;
+  /**
+   * Type-only marker for the actor's internal event protocol. `actor.send` and
+   * `actor.trigger` read it to drop internal events from the public protocol,
+   * so it must survive `stripInternal` into the published declarations. Not
+   * `declare` (the build's babel pipeline rejects declare class fields); the
+   * one `undefined` property this emits per machine instance is inert.
+   */
+  readonly _internalEventType: TInternalEvent;
+  /** Type-only marker for transition metadata. Never assigned at runtime. */
+  readonly _transitionMetaType: TTransitionMeta;
+  /**
+   * Type-only marker for the declared input type. `getInitialSnapshot` takes
+   * input optionally, so inferring input from it always adds `undefined`;
+   * `InputFrom` reads this carrier instead. Method-shaped so it stays
+   * bivariant like `getInitialSnapshot`. Never assigned at runtime.
+   */
+  readonly _inputType: {
+    carry(input: TInput): void;
+  }['carry'];
+  /**
+   * Type-level carriers for the machine's source maps and state schema. Type
+   * helpers in integration packages read these to walk a machine's declared
+   * actions, actors and invoked sources. They are never assigned at runtime.
+   */
+  readonly _actionMap: TActionMap;
+  readonly _actorMap: TActorMap;
+  readonly _stateSchema: TConfig;
+  /** The machine's own version. */
+  version: TConfig extends {
+    version: infer TVersion extends string;
+  } ? TVersion : undefined;
+  schemas: AnyMachineSchemas | undefined;
+  /** Standard Schema for snapshots persisted by this machine version. */
+  readonly snapshotSchema: StandardSchemaV1<unknown, Snapshot<unknown> & PersistedMachineSnapshot & {
+    context: TContext;
+  }>;
+  /** Standard Schema for complete events accepted by this machine version. */
+  readonly eventSchema: StandardSchemaV1<unknown, TEvent>;
+  sources: Sources;
+  /** Runtime options for machine execution. */
+  options: MachineOptions;
+  root: StateNode<TContext, TEvent, TMeta, TTransitionMeta>;
+  id: TConfig extends {
+    id: infer TId extends string;
+  } ? TId : '(machine)';
+  states: StateNode<TContext, TEvent, TMeta, TTransitionMeta>['states'];
+  events: Array<EventDescriptor<TEvent>>;
+  internalEventDescriptors: ReadonlyArray<string>;
+  /**
+   * Adapter hooks for actor-local transition evaluation state. Used by
+   * `@xstate/scxml`; not part of the stable API.
+   *
+   * @experimental
+   */
+  _microstepHooks?: AnyStateMachine['_microstepHooks'];
+  constructor(
+  /** The raw config used to create the machine. */
+  config: Next_MachineConfig<any, any, any, any, any, any, any, any, any, any, any, any, any> & {
+    schemas?: AnyMachineSchemas;
+  }, sources?: Sources, validator?: ActorLogicValidator | undefined);
+  /**
+   * Clones this state machine with the provided sources.
+   *
+   * @param sources Options (`actions`, `guards`, `actors`, `delays`) to
+   *   recursively merge with the existing options.
+   * @returns A new `StateMachine` instance with the provided sources.
+   */
+  provide<const TProvidedActorMap extends Partial<Record<keyof TActorMap & string, AnyActorLogic>> = {}, const TProvidedActionMap extends Partial<ProvidedActionContracts<TActionMap>> = {}>(sources: {
+    actions?: TProvidedActionMap & Partial<ProvidedActionContracts<TActionMap>> & Record<Exclude<keyof TProvidedActionMap, keyof TActionMap>, never>;
+    actors?: TProvidedActorMap & ProvidedActors<TActorMap, TProvidedActorMap>;
+    guards?: Partial<TGuardMap> & { [K in keyof TGuardMap]?: GuardSourceMap<TContext, TEvent>[string]; };
+    delays?: { [K in keyof TDelayMap]?: DelaySourceMap<TContext, TEvent>[string]; };
+  }): StateMachine<TContext, TEvent, TChildren, TStateValue, TTag, TInput, TOutput, TEmitted, TMeta, TConfig, ProvidedSourceMap<TActionMap, TProvidedActionMap>, ProvidedSourceMap<TActorMap, TProvidedActorMap>, TGuardMap, TDelayMap, TInternalEvent, TTransitionMeta>;
+  resolveState(config: {
+    value: StateValue;
+    context?: TContext;
+    historyValue?: HistoryValue;
+    status?: SnapshotStatus;
+    output?: TOutput;
+    error?: unknown;
+  } & ([TContext] extends [never] ? {} : Equals<TContext, MachineContext> extends false ? {
+    context: unknown;
+  } : {})): MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>;
+  /**
+   * Determines the next snapshot given the current `snapshot` and received
+   * `event`. Calculates a full macrostep from all microsteps.
+   *
+   * @param snapshot The current snapshot
+   * @param event The received event
+   */
+  transition(snapshot: MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>, event: TEvent, actorScope?: ActorScope<typeof snapshot, TEvent, AnyActorSystem, TEmitted>): ActorLogicTransitionResult<MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>, ExecutableActionObjectFromLogic<this>>;
+  private _collectEffects;
+  private _attachPureActorRef;
+  private _transitionFast;
+  /**
+   * Determines the next state given the current `state` and `event`. Calculates
+   * a microstep.
+   *
+   * @param state The current state
+   * @param event The received event
+   */
+  microstep(snapshot: MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>, event: TEvent, actorScope: AnyActorScope): Array<MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>>;
+  getTransitionData(snapshot: MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>, event: TEvent, actorScope: AnyActorScope, selectionResults?: TransitionSelectionResults): Array<AnyTransitionDefinition>;
+  isInternalEventType(eventType: string): boolean;
+  /**
+   * Returns the initial `State` instance, with reference to `self` as an
+   * `ActorRef`.
+   */
+  getInitialSnapshot(actorScope?: ActorScope<MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>, TEvent, AnyActorSystem, TEmitted>, input?: TInput): MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>;
+  initialTransition(input: TInput | undefined, actorScope?: ActorScope<MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>, TEvent, AnyActorSystem, TEmitted>): ActorLogicTransitionResult<MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>, ExecutableActionObjectFromLogic<this>>;
+  start(snapshot?: MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>, actorScope?: ActorScope<MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>, TEvent, AnyActorSystem, TEmitted>): void;
+  getStateNodeById(stateId: string): StateNode<TContext, TEvent, TMeta, TTransitionMeta>;
+  getPersistedSnapshot(snapshot: MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>, options?: unknown, warn?: (message: string) => void): Snapshot<unknown>;
+  restoreSnapshot(snapshot: Snapshot<unknown>, actorScope?: ActorScope<MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>, TEvent, AnyActorSystem, TEmitted>): MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>;
+}
+declare const builtInActions: {
+  "@xstate.spawn": (actor: AnyActor) => any;
+  "@xstate.start": (actor: AnyActor) => any;
+  "@xstate.raise": (actorScope: AnyActorScope, _event: EventObject, options: {
+    id?: string;
+    delay?: number;
+  }) => void | PromiseLike<void>;
+  "@xstate.sendTo": (actorScope: AnyActorScope, actor: AnyActor, event: EventObject, options: {
+    id?: string;
+    delay?: number;
+  }) => void | PromiseLike<void>;
+  "@xstate.cancel": (actorScope: AnyActorScope, sendId: string) => void | PromiseLike<void>;
+  "@xstate.stop": (actorScope: AnyActorScope, actor: AnyActor) => void | PromiseLike<void>;
+  "@xstate.terminate": (actor: AnyActor, termination: ActorTermination) => any;
+};
+/** @public */
+type HomomorphicOmit<T, K extends keyof any> = { [P in keyof T as Exclude<P, K>]: T[P]; };
+/**
+ * @remarks
+ * `T | unknown` reduces to `unknown` and that can be problematic when it comes
+ * to contextual typing. It especially is a problem when the union has a
+ * function member, like here:
+ *
+ * ```ts
+ * declare function test(
+ *   cbOrVal: ((arg: number) => unknown) | unknown
+ * ): void;
+ * test((arg) => {}); // oops, implicit any
+ * ```
+ *
+ * This type can be used to avoid this problem. This union represents the same
+ * value space as `unknown`.
+ * @public
+ */
+type NonReducibleUnknown = {} | null | undefined;
+/** @public */
+type AnyFunction = (...args: any[]) => any;
+type ReturnTypeOrValue<T> = T extends AnyFunction ? ReturnType<T> : T;
+/** @public */
+type IsNever<T> = [T] extends [never] ? true : false;
+/** @public */
+type IsNotNever<T> = [T] extends [never] ? false : true;
+/** @public */
+type Compute<A> = { [K in keyof A]: A[K]; } & unknown;
+/** @public */
+type Prop<T, K> = K extends keyof T ? T[K] : never;
+/** @public */
+type Equals<A1, A2> = (<A>() => A extends A2 ? true : false) extends (<A>() => (A extends A1 ? true : false)) ? true : false;
+/** @public */
+type IsAny<T> = Equals<T, any>;
+/** @public */
+type Cast<A, B> = A extends B ? A : B;
+/** @public */
+type DoNotInfer<T> = [T][T extends any ? 0 : any];
+/** @public */
+type LowInfer<T> = T & NonNullable<unknown>;
+/** @public */
+type MetaObject = Record<string, any>;
+/** @public */
+type Lazy<T> = () => T;
+/** @public */
+type MaybeLazy<T> = T | Lazy<T>;
+/** @public */
+type EventPayloadPattern<TEvent extends EventObject> = TEvent extends any ? Partial<Omit<TEvent, 'type'>> : never;
+/** @public */
+interface AnyEventObject extends EventObject {
+  [key: string]: any;
+}
+/** @public */
+interface ParameterizedObject {
+  type: string;
+  params?: NonReducibleUnknown;
+}
+/** @public */
+type UnifiedArg<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject> = {
+  context: TContext;
+  event: TExpressionEvent;
+  self: ActorSelf<MachineSnapshot<TContext, TEvent, Record<string, AnyActorRef | undefined>, // TODO: this should be replaced with `TChildren`
+    StateValue, string, unknown, TODO, // TMeta
+    TODO>, TEvent, AnyEventObject>;
+  system: AnyActorSystem;
+} & OutputArg<TExpressionEvent>;
+type DoneEventType = 'xstate.done.actor' | 'xstate.done.state';
+/** @public */
+type OutputArg<TEvent extends EventObject> = TEvent extends {
+  type: DoneEventType;
+  output: infer TOutput;
+} ? {
+  output: TOutput;
+} : {
+  output: undefined;
+};
+/** @public */
+type ActionArgs<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject> = UnifiedArg<TContext, TExpressionEvent, TEvent> & {
+  children: Record<string, AnyActor>;
+};
+/** @public */
+type InputFrom<T> = T extends {
+  _inputType: (input: infer TMachineInput) => void;
+} ? TMachineInput : T extends ActorLogic<infer _TSnapshot, infer _TEvent, infer TInput, infer _TSystem, infer _TEmitted> ? TInput : T extends StateMachine<infer _TContext, infer _TEvent, infer _TChildren, infer _TStateValue, infer _TTag, infer TInput, infer _TOutput, infer _TEmitted, infer _TMeta, infer _TStateSchema, infer _TActionMap, infer _TActorMap, infer _TGuardMap, infer _TDelayMap> ? TInput : never;
+/** @public */
+type OutputFrom<T> = T extends ActorLogic<infer TSnapshot, infer _TEvent, infer _TInput, infer _TSystem, infer _TEmitted> ? (TSnapshot & {
+  status: 'done';
+})['output'] : T extends ActorRef<infer TSnapshot, infer _TEvent, infer _TEmitted> ? (TSnapshot & {
+  status: 'done';
+})['output'] : never;
+type ErrorFromSnapshot<TSnapshot> = TSnapshot extends {
+  error: infer TError;
+} ? Exclude<TError, undefined> : unknown;
+/** @public */
+type ErrorFrom<T> = T extends {
+  transition: (snapshot: infer TSnapshot, ...args: any[]) => any;
+} ? ErrorFromSnapshot<TSnapshot> : T extends ActorRef<infer TSnapshot, infer _TEvent, infer _TEmitted> ? ErrorFromSnapshot<TSnapshot> : never;
+/** @public */
+type ConditionalRequired<T, Condition extends boolean> = Condition extends true ? Required<T> : T;
+/** @public */
+type StateKey = string | AnyMachineSnapshot;
+/** @public */
+interface StateValueMap {
+  [key: string]: StateValue | undefined;
+}
+/**
+ * The string or object representing the state value relative to the parent
+ * state node.
+ *
+ * @remarks
+ * - For a child atomic state node, this is a string, e.g., `"pending"`.
+ * - For complex state nodes, this is an object, e.g.,
+ *   `{ success: "someChildState" }`.
+ * @public
+ */
+type StateValue = string | StateValueMap;
+/** @public */
+type TransitionTarget = SingleOrArray<string>;
+/** @public */
+type TransitionContextPatch<TContext extends MachineContext> = Partial<TContext> & {
+  call?: never;
+  apply?: never;
+  bind?: never;
+};
+/** @public */
+type TransitionContextMapper<TContext extends MachineContext, TCurrentEvent extends EventObject, TEvent extends EventObject, TActionMap extends Sources['actions'], TActorMap extends Sources['actors'], TGuardMap extends Sources['guards'], TDelayMap extends Sources['delays'], _TCtx extends MachineContext = [TContext] extends [never] ? any : TContext> = (args: TransitionFunctionArgs<_TCtx, TCurrentEvent, TEvent, TActionMap, TActorMap, TGuardMap, TDelayMap>) => TransitionContextPatch<_TCtx>;
+/** @public */
+interface TransitionConfig<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject, TEmitted extends EventObject, TMeta extends MetaObject, TActionMap extends Sources['actions'], TActorMap extends Sources['actors'], TGuardMap extends Sources['guards'], TDelayMap extends Sources['delays']> {
+  actions?: never;
+  /** A shallow partial event pattern that must match before guards run. */
+  matches?: EventPayloadPattern<TExpressionEvent>;
+  guard?: unknown;
+  reenter?: boolean;
+  target?: TransitionTarget | undefined;
+  context?: TransitionContextPatch<TContext> | TransitionContextMapper<TContext, TExpressionEvent, TEvent, TActionMap, TActorMap, TGuardMap, TDelayMap>;
+  to?: TransitionConfigFunction<TContext, TExpressionEvent, TEvent, TEmitted, TActionMap, TActorMap, TGuardMap, TDelayMap, TMeta>;
+  meta?: TMeta;
+  description?: string;
+}
+/** @public */
+interface InitialTransitionConfig<TContext extends MachineContext, TEvent extends EventObject, TEmitted extends EventObject, TMeta extends MetaObject, TActionMap extends Sources['actions'], TActorMap extends Sources['actors'], TGuardMap extends Sources['guards'], TDelayMap extends Sources['delays']> extends TransitionConfig<TContext, TEvent, TEvent, TEmitted, TMeta, TActionMap, TActorMap, TGuardMap, TDelayMap> {
+  target: string;
+}
+/** @public */
+type AnyTransitionConfig = TransitionConfig<any, // TContext
+  any, // TExpressionEvent
+  any, // TEvent
+  any, // TEmitted
+  any, // TMeta
+  any, // TActionMap
+  any, // TActorMap
+  any, // TGuardMap
+  any>;
+/** @public */
+interface InvokeDefinition<TContext extends MachineContext, TEvent extends EventObject, TEmitted extends EventObject, TMeta extends MetaObject, TActionMap extends Sources['actions'], TActorMap extends Sources['actors'], TGuardMap extends Sources['guards'], TDelayMap extends Sources['delays']> {
+  id: string;
+  registryKey: string | undefined;
+  logic: string | AnyActorLogic | (({ actors, context, event, self }: {
+    actors: TActorMap;
+    context: TContext;
+    event: TEvent;
+    self: AnyActorRef;
+  }) => string | AnyActorLogic);
+  /** The source of the actor logic to be invoked */
+  src: AnyActorLogic | string;
+  input?: Mapper<TContext, TEvent, NonReducibleUnknown, TEvent> | NonReducibleUnknown;
+  /**
+   * The transition to take upon the invoked child machine reaching its final
+   * top-level state.
+   */
+  onDone?: string | SingleOrArray<TransitionConfig<TContext, DoneActorEvent<unknown>, TEvent, TEmitted, TMeta, TActionMap, TActorMap, TGuardMap, TDelayMap>>;
+  /**
+   * The transition to take upon the invoked child machine sending an error
+   * event.
+   */
+  onError?: string | SingleOrArray<TransitionConfig<TContext, ErrorActorEvent, TEvent, TEmitted, TMeta, TActionMap, TActorMap, TGuardMap, TDelayMap>>;
+  onSnapshot?: string | SingleOrArray<TransitionConfig<TContext, SnapshotEvent, TEvent, TEmitted, TMeta, TActionMap, TActorMap, TGuardMap, TDelayMap>>;
+  /**
+   * The duration (in ms) after which this invocation times out if it has not
+   * completed.
+   */
+  timeout?: number | ((args: {
+    context: TContext;
+    event: TEvent;
+  }) => number);
+  /** The transition to take when the invoke-level `timeout` expires. */
+  onTimeout?: string | SingleOrArray<TransitionConfig<TContext, ActorTimeoutEvent, TEvent, TEmitted, TMeta, TActionMap, TActorMap, TGuardMap, TDelayMap>>;
+}
+/** @public */
+type AnyInvokeDefinition = InvokeDefinition<MachineContext, EventObject, EventObject, any, // TMeta
+  Sources['actions'], Sources['actors'], Sources['guards'], Sources['delays']>;
+type Delay<TDelay extends string> = TDelay | number;
+/** @public */
+type DelayedTransitions<TContext extends MachineContext, TEvent extends EventObject, TEmitted extends EventObject, TMeta extends MetaObject, TActionMap extends Sources['actions'], TActorMap extends Sources['actors'], TGuardMap extends Sources['guards'], TDelayMap extends Sources['delays']> = { [K in Delay<keyof TDelayMap & string>]?: string | SingleOrArray<TransitionConfig<TContext, TEvent, TEvent, TEmitted, TMeta, TActionMap, TActorMap, TGuardMap, TDelayMap>> | TransitionConfigFunction<TContext, TEvent, TEvent, TODO, any, any, any, any, any>; };
+/** @public */
+type StateTypes = 'atomic' | 'compound' | 'parallel' | 'final' | 'choice' | 'history' | ({} & string);
+/** @public */
+type SingleOrArray<T> = readonly T[] | T;
+/** @public */
+type StateNodesConfig<TContext extends MachineContext, TEvent extends EventObject> = { [K in string]: StateNode<TContext, TEvent>; };
+/** @public */
+type TransitionConfigTarget = string | undefined;
+type LegacyTransitionConfigOrTarget<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject, TEmitted extends EventObject, TMeta extends MetaObject, TActionMap extends Sources['actions'], TActorMap extends Sources['actors'], TGuardMap extends Sources['guards'], TDelayMap extends Sources['delays']> = SingleOrArray<TransitionConfigTarget | TransitionConfig<TContext, TExpressionEvent, TEvent, TEmitted, TMeta, TActionMap, TActorMap, TGuardMap, TDelayMap> | TransitionConfigFunction<TContext, TExpressionEvent, TEvent, TEmitted, TActionMap, TActorMap, TGuardMap, TDelayMap, TMeta>>;
+/** @public */
+type TransitionConfigFunction<TContext extends MachineContext, TCurrentEvent extends EventObject, TEvent extends EventObject, TEmitted extends EventObject, TActionMap extends Sources['actions'], TActorMap extends Sources['actors'], TGuardMap extends Sources['guards'], TDelayMap extends Sources['delays'], TMeta extends MetaObject, TInput = undefined, _TCtx extends MachineContext = [TContext] extends [never] ? any : TContext, TChildren extends Record<string, AnyActorRef | undefined> = {}> = (args: TransitionFunctionArgs<_TCtx, TCurrentEvent, TEvent, TActionMap, TActorMap, TGuardMap, TDelayMap, TChildren> & {
+  input: TInput;
+}, enq: EnqueueObject<TEvent, TEmitted, SystemRegistry, Compute<CallbackActors<TActorMap>>, TChildren>) => {
+  target?: string | string[];
+  context?: TransitionContextPatch<_TCtx>;
+  reenter?: boolean;
+  meta?: TMeta;
+  input?: Record<string, unknown>;
+} | void;
+declare const sendableEvent: unique symbol;
+type SendableEventCarrier<TEvent extends EventObject> = {
+  readonly [sendableEvent]?: TEvent;
+};
+/**
+ * The actor-logic surface available in inline callbacks. The outer `Compute`
+ * at each use site is necessary: otherwise declaration emit repeats the
+ * registered machine's structural type in every callback signature.
+ *
+ * @public
+ */
+type CallbackActors<T extends Sources['actors']> = { [K in keyof T]: ActorLogic<OpaqueMachineSnapshot<SnapshotFrom<T[K]>>, EventFromLogic<T[K]>, InputFrom<T[K]>, AnyActorSystem, EmittedFrom<T[K]>> & SendableEventCarrier<SendableEventFromLogic<T[K]>>; };
+type TransitionFunctionArgs<TContext, TCurrentEvent extends EventObject, TEvent extends EventObject, TActionMap extends Sources['actions'], TActorMap extends Sources['actors'], TGuardMap extends Sources['guards'], TDelayMap extends Sources['delays'], TChildren extends Record<string, AnyActorRef | undefined> = Record<string, AnyActor>> = {
+  context: TContext;
+  event: TCurrentEvent;
+  self: ActorSelf<MachineSnapshot<TContext & MachineContext, TEvent, TODO, TODO, TODO, TODO, TODO, TODO>, TEvent>;
+  parent: UnknownActorRef | undefined;
+  value: StateValue;
+  children: TChildren;
+  system: AnyActorSystem;
+  actions: TActionMap;
+  actors: Compute<CallbackActors<TActorMap>>;
+  guards: TGuardMap;
+  delays: TDelayMap;
+} & OutputArg<TCurrentEvent>;
+/** @public */
+type AnyTransitionConfigFunction = TransitionConfigFunction<any, any, any, any, any, any, any, any, any, any, any, // _TCtx
+  any>;
+/** @public */
+type TransitionsConfig<TContext extends MachineContext, TEvent extends EventObject, TEmitted extends EventObject, TMeta extends MetaObject, TActionMap extends Sources['actions'], TActorMap extends Sources['actors'], TGuardMap extends Sources['guards'], TDelayMap extends Sources['delays']> = { [K in EventDescriptor<TEvent>]?: LegacyTransitionConfigOrTarget<TContext, ExtractEvent<TEvent, K>, TEvent, TEmitted, TMeta, TActionMap, TActorMap, TGuardMap, TDelayMap>; };
+type PartialEventDescriptor<TEventType extends string> = TEventType extends `${infer TLeading}.${infer TTail}` ? `${TLeading}.*` | `${TLeading}.${PartialEventDescriptor<TTail>}` : never;
+/** @public */
+type EventDescriptor<TEvent extends EventObject> = TEvent['type'] | PartialEventDescriptor<TEvent['type']> | '*';
+/** @public */
+type NormalizeDescriptor<TDescriptor extends string> = TDescriptor extends '*' ? string : TDescriptor extends `${infer TLeading}.*` ? `${TLeading}.${string}` : TDescriptor;
+type EventTypeMatchesDescriptor<TEventType extends string, TDescriptor extends string> = TEventType extends NormalizeDescriptor<TDescriptor> ? true : false;
+type IsInternalEventType<TEventType extends string, TDescriptors extends string> = string extends TDescriptors ? false : true extends (TDescriptors extends any ? EventTypeMatchesDescriptor<TEventType, TDescriptors> : never) ? true : false;
+type ExcludeInternalEvents<TEvent extends EventObject, TDescriptors extends string> = TEvent extends any ? IsInternalEventType<TEvent['type'], TDescriptors> extends true ? never : TEvent : never;
+type InternalEventTypes<TInternalEvent extends EventObject> = TInternalEvent extends any ? TInternalEvent['type'] : never;
+type SendableEventFromMachine<TEvent extends EventObject, TInternalEvent extends EventObject> = IsAny<TInternalEvent> extends true ? TEvent : ExcludeInternalEvents<TEvent, InternalEventTypes<TInternalEvent>>;
+/** @public */
+type IsLiteralString<T extends string> = string extends T ? false : true;
+type ActorsBySrc<TActor extends ProvidedActor> = { [A in TActor as A['src']]: A['logic']; };
+type DistributeActors<TContext extends MachineContext, TEvent extends EventObject, TActor extends ProvidedActor, _TAction extends ParameterizedObject, _TGuard extends ParameterizedObject, _TDelay extends string, TEmitted extends EventObject, TMeta extends MetaObject, TSpecificActor extends ProvidedActor> = TSpecificActor extends {
+  src: infer TSrc;
+} ? Compute<{
+  registryKey?: string;
+  /** The source of the machine to be invoked, or the machine itself. */
+  src: TSrc | (({ actors, context, event, self }: {
+    actors: ActorsBySrc<TActor>;
+    context: TContext;
+    event: TEvent;
+    self: AnyActorRef;
+  }) => TSrc | TSpecificActor['logic']);
+  /**
+   * The unique identifier for the invoked machine. If not specified,
+   * this will be the machine's own `id`, or the URL (from `src`).
+   */
+  id?: TSpecificActor['id'];
+  input?: Mapper<TContext, TEvent, InputFrom<TSpecificActor['logic']>, TEvent> | InputFrom<TSpecificActor['logic']>;
+  /**
+   * The transition to take upon the invoked child machine reaching
+   * its final top-level state.
+   */
+  onDone?: string | SingleOrArray<LegacyTransitionConfigOrTarget<TContext, DoneActorEvent<OutputFrom<TSpecificActor['logic']>>, TEvent, TEmitted, TMeta, any, any, any, any>>;
+  /**
+   * The transition to take upon the invoked child machine sending an
+   * error event.
+   */
+  onError?: string | SingleOrArray<LegacyTransitionConfigOrTarget<TContext, ErrorActorEvent, TEvent, TEmitted, TMeta, any, any, any, any>>;
+  onSnapshot?: string | SingleOrArray<LegacyTransitionConfigOrTarget<TContext, SnapshotEvent<SnapshotFrom<TSpecificActor['logic']>>, TEvent, TEmitted, TMeta, any, any, any, any>>;
+  timeout?: number | ((args: {
+    context: TContext;
+    event: TEvent;
+  }) => number);
+  onTimeout?: string | SingleOrArray<LegacyTransitionConfigOrTarget<TContext, ActorTimeoutEvent, TEvent, TEmitted, TMeta, any, any, any, any>>;
+} & { [K in RequiredActorOptions<TSpecificActor>]: unknown; }> | {
+  id?: never;
+  registryKey?: string;
+  src: string | AnyActorLogic | (({ actors, context, event, self }: {
+    actors: ActorsBySrc<TActor>;
+    context: TContext;
+    event: TEvent;
+    self: AnyActorRef;
+  }) => string | AnyActorLogic);
+  input?: Mapper<TContext, TEvent, NonReducibleUnknown, TEvent> | NonReducibleUnknown;
+  onDone?: string | SingleOrArray<LegacyTransitionConfigOrTarget<TContext, DoneActorEvent<unknown>, TEvent, TEmitted, TMeta, any, any, any, any>>;
+  onError?: string | SingleOrArray<LegacyTransitionConfigOrTarget<TContext, ErrorActorEvent, TEvent, TEmitted, TMeta, any, any, any, any>>;
+  onSnapshot?: string | SingleOrArray<LegacyTransitionConfigOrTarget<TContext, SnapshotEvent, TEvent, TEmitted, TMeta, any, any, any, any>>;
+  timeout?: number | ((args: {
+    context: TContext;
+    event: TEvent;
+  }) => number);
+  onTimeout?: string | SingleOrArray<LegacyTransitionConfigOrTarget<TContext, ActorTimeoutEvent, TEvent, TEmitted, TMeta, any, any, any, any>>;
+} : never;
+type LegacyInvokeConfig<TContext extends MachineContext, TEvent extends EventObject, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string, TEmitted extends EventObject, TMeta extends MetaObject> = IsLiteralString<TActor['src']> extends true ? DistributeActors<TContext, TEvent, TActor, TAction, TGuard, TDelay, TEmitted, TMeta, TActor> : {
+  /**
+   * The unique identifier for the invoked machine. If not specified, this
+   * will be the machine's own `id`, or the URL (from `src`).
+   */
+  id?: string;
+  registryKey?: string;
+  /** The source of the machine to be invoked, or the machine itself. */
+  src: string | AnyActorLogic | (({ actors, context, event, self }: {
+    actors: ActorsBySrc<TActor>;
+    context: TContext;
+    event: TEvent;
+    self: AnyActorRef;
+  }) => string | AnyActorLogic);
+  input?: Mapper<TContext, TEvent, NonReducibleUnknown, TEvent> | NonReducibleUnknown;
+  /**
+   * The transition to take upon the invoked child machine reaching its
+   * final top-level state.
+   */
+  onDone?: string | SingleOrArray<LegacyTransitionConfigOrTarget<TContext, DoneActorEvent<unknown>, TEvent, TEmitted, TMeta, any, any, any, any>>;
+  /**
+   * The transition to take upon the invoked child machine sending an
+   * error event.
+   */
+  onError?: string | SingleOrArray<LegacyTransitionConfigOrTarget<TContext, ErrorActorEvent, TEvent, TEmitted, TMeta, any, any, any, any>>;
+  onSnapshot?: string | SingleOrArray<LegacyTransitionConfigOrTarget<TContext, SnapshotEvent, TEvent, TEmitted, TMeta, any, any, any, any>>;
+  timeout?: number | ((args: {
+    context: TContext;
+    event: TEvent;
+  }) => number);
+  onTimeout?: string | SingleOrArray<LegacyTransitionConfigOrTarget<TContext, ActorTimeoutEvent, TEvent, TEmitted, TMeta, any, any, any, any>>;
+};
+/** @public */
+type AnyInvokeConfig = LegacyInvokeConfig<any, any, any, any, any, any, any, any>;
+/** @public */
+type AnyStateNodeConfig = Next_StateNodeConfig<any, any, any, any, any, any, any, any, any, any, any, any, any, // TInput
+  any, // TInputMap
+  any, // TSystemRegistry
+  any, // TChildOutput
+  any>;
+/** @public */
+type AnyStateNode = StateNode<any, any> | StateNode<never, EventObject> | StateNode<any, EventObject> | StateNode<never, any>;
+type LoosenMachineSnapshot<TSnapshot> = TSnapshot extends MachineSnapshot<any, any, any, any, any, any, any, any> ? Omit<TSnapshot, 'matches' | 'can'> & {
+  matches(partialStateValue: StateValue): boolean;
+  can(event: any): boolean;
+} : never;
+/** @public */
+type AnyMachineSnapshot = LoosenMachineSnapshot<MachineSnapshot<any, any, any, any, any, any, any, any>>;
+/** @public */
+interface AnyStateMachine extends AnyActorLogic {
+  id: string;
+  root: AnyStateNode;
+  /**
+   * Adapter hooks for actor-local transition evaluation state. Used by
+   * `@xstate/scxml`; not part of the stable API.
+   *
+   * @experimental
+   */
+  _microstepHooks?: {
+    begin(self: AnyActor): void;
+    drain(self: AnyActor): AnyEventObject[];
+  } | undefined;
+  options?: {
+    maxIterations?: number;
+  };
+  states: StateNodesConfig<any, any>;
+  events: Array<EventDescriptor<any>>;
+  sources: Sources;
+  config: any;
+  version?: string | undefined;
+  schemas?: AnyMachineSchemas | undefined;
+  snapshotSchema: MachineSnapshotSchema;
+  eventSchema: MachineEventSchema;
+  provide(sources: any): AnyStateMachine;
+  resolveState(config: any): any;
+  getTransitionData(snapshot: any, event: any, actorScope: AnyActorScope, selectionResults?: Map<AnyTransitionDefinition, unknown>): AnyTransitionDefinition[];
+  getStateNodeById(stateId: string): AnyStateNode;
+  getPersistedSnapshot(snapshot: any, options?: unknown): Snapshot<unknown>;
+}
+/** @public */
+type AnyStateConfig = StateConfig<any, AnyEventObject>;
+/** @public */
+type DelayConfig<TContext extends MachineContext, TExpressionEvent extends EventObject> = number | DelayExpr<TContext, TExpressionEvent>;
+/** @public */
+type InitialContext<TContext extends MachineContext, TActorMap extends Sources['actors'], TInput, TEvent extends EventObject> = TContext | ContextFactory<TContext, TActorMap, TInput, TEvent>;
+/** @public */
+type ContextFactory<TContext extends MachineContext, TActorMap extends Sources['actors'], TInput, TEvent extends EventObject = EventObject> = ({ spawn, actors, input, self }: {
+  spawn: Spawner;
+  actors: TActorMap;
+  input: TInput;
+  self: ActorSelf<MachineSnapshot<[TContext] extends [never] ? any : TContext, TEvent, Record<string, AnyActorRef | undefined>, // TODO: this should be replaced with `TChildren`
+    StateValue, string, unknown, TODO, // TMeta
+    TODO>, TEvent, AnyEventObject>;
+}) => [TContext] extends [never] ? MachineContext : TContext;
+/** @public */
+interface ProvidedActor {
+  src: string;
+  logic: UnknownActorLogic;
+  id?: string | undefined;
+}
+/** @public */
+interface SetupTypes<TContext extends MachineContext, TEvent extends EventObject, TChildrenMap extends Record<string, string>, TTag extends string, TInput, TOutput, TEmitted extends EventObject, TMeta extends MetaObject> {
+  context?: TContext;
+  events?: TEvent;
+  children?: TChildrenMap;
+  tags?: TTag;
+  input?: TInput;
+  output?: TOutput;
+  emitted?: TEmitted;
+  meta?: TMeta;
+}
+/** @public */
+interface MachineTypes<TContext extends MachineContext, TEvent extends EventObject, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string, TTag extends string, TInput, TOutput, TEmitted extends EventObject, TMeta extends MetaObject> extends SetupTypes<TContext, TEvent, never, TTag, TInput, TOutput, TEmitted, TMeta> {
+  actors?: TActor;
+  actions?: TAction;
+  guards?: TGuard;
+  delays?: TDelay;
+  meta?: TMeta;
+}
+/** @public */
+interface HistoryStateNode<TContext extends MachineContext> extends StateNode<TContext> {
+  history: 'shallow' | 'deep';
+  target: string | undefined;
+}
+/** @public */
+type HistoryValue = Record<string, Array<AnyStateNode>>;
+/** @public */
+type PersistedHistoryValue = Record<string, Array<{
+  id: string;
+}>>;
+/** @public */
+type AnyHistoryValue = HistoryValue;
+/** @public */
+type StateFrom<T extends AnyStateMachine | ((...args: any[]) => AnyStateMachine)> = T extends AnyStateMachine ? StateSnapshotFromMachine<T> : T extends ((...args: any[]) => AnyStateMachine) ? StateSnapshotFromMachine<ReturnType<T>> : never;
+/** @public */
+type StateValueFromStateSchema<T extends StateSchema> = StateSchema extends T ? StateValue : ToStateValue<T> extends (infer TStateValue) ? TStateValue extends StateValue ? TStateValue : StateValue : StateValue;
+type MatchingStateValueForStateFrom<TStateValue extends StateValue, TTestStateValue extends StateValue> = TStateValue extends unknown ? TTestStateValue extends string ? TStateValue extends string ? TTestStateValue extends TStateValue ? TTestStateValue : Extract<TStateValue, TTestStateValue> : TStateValue extends StateValueMap ? TStateValue & Record<TTestStateValue, StateValue | undefined> : never : TTestStateValue extends StateValueMap ? TStateValue extends StateValueMap ? MatchingStateValueMapForStateFrom<TStateValue, TTestStateValue> : never : never : never;
+type MatchingStateValueMapForStateFrom<TStateValue extends StateValueMap, TTestStateValue extends StateValueMap> = false extends { [K in keyof TTestStateValue & string]: K extends keyof TStateValue ? IsNever<MatchingStateValueForStateFrom<NonNullable<TStateValue[K]>, NonNullable<TTestStateValue[K]>>> extends true ? false : true : false; }[keyof TTestStateValue & string] ? never : { [K in keyof TStateValue]: K extends keyof TTestStateValue ? MatchingStateValueForStateFrom<NonNullable<TStateValue[K]>, NonNullable<TTestStateValue[K]>> : TStateValue[K]; };
+type StateSnapshotFromStateValue<TContext extends MachineContext, TEvent extends EventObject, TChildren extends Record<string, AnyActorRef | undefined>, TStateValue extends StateValue, TTag extends string, TOutput, TMeta extends MetaObject, TStateSchema extends StateSchema, TAllStateValue extends StateValue = TStateValue> = TStateValue extends unknown ? Omit<MachineSnapshot<StateContextFromStateValue<TStateSchema, TContext, TStateValue>, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TStateSchema>, 'matches'> & {
+  matches<const TTestStateValue extends string>(partialStateValue: TTestStateValue, ...args: string extends TTestStateValue ? [never] : []): this is StateSnapshotFromStateValue<StateContextFromStateValue<TStateSchema, TContext, TTestStateValue>, TEvent, TChildren, MatchingStateValueForStateFrom<TAllStateValue, TTestStateValue>, TTag, TOutput, TMeta, TStateSchema, TAllStateValue>;
+  matches<const TTestStateValue extends StateValueMap>(partialStateValue: TTestStateValue, ...args: string extends keyof TTestStateValue ? [never] : []): this is StateSnapshotFromStateValue<StateContextFromStateValue<TStateSchema, TContext, TTestStateValue>, TEvent, TChildren, MatchingStateValueForStateFrom<TAllStateValue, TTestStateValue>, TTag, TOutput, TMeta, TStateSchema, TAllStateValue>;
+  matches(partialStateValue: StateValue): boolean;
+} : never;
+type StateSnapshotFromMachine<T extends AnyStateMachine> = SnapshotFrom<T> extends MachineSnapshot<infer TContext, infer TEvent, infer TChildren, infer _TStateValue, infer TTag, infer TOutput, infer TMeta, infer TStateSchema> ? StateSnapshotFromStateValue<TContext, TEvent, TChildren, StateValueFromStateSchema<TStateSchema>, TTag, TOutput, TMeta, TStateSchema, StateValueFromStateSchema<TStateSchema>> : SnapshotFrom<T>;
+/** @public */
+interface DoneActorEvent<TOutput = unknown, TId extends string = string> extends EventObject {
+  type: 'xstate.done.actor';
+  output: TOutput;
+  actorId: TId;
+  sessionId: string;
+}
+/** @public */
+interface ErrorActorEvent<TErrorData = unknown, TId extends string = string> extends EventObject {
+  type: 'xstate.error.actor';
+  error: TErrorData;
+  actorId: TId;
+  sessionId: string;
+}
+/** @public */
+interface ErrorPlatformEvent<TErrorData = unknown, TKind extends string = string> extends EventObject {
+  type: `xstate.error.${TKind}`;
+  error: TErrorData;
+}
+/** @public */
+type ErrorEvent = ErrorActorEvent | ErrorPlatformEvent;
+/** @public */
+interface SnapshotEvent<TSnapshot extends Snapshot<unknown> = Snapshot<unknown>> extends EventObject {
+  type: 'xstate.snapshot.actor';
+  actorId: string;
+  sessionId: string;
+  snapshot: TSnapshot;
+}
+/** @public */
+interface DoneStateEvent<TOutput = unknown, TId extends string = string> extends EventObject {
+  type: 'xstate.done.state';
+  stateId: TId;
+  output: TOutput;
+}
+/** @public */
+interface AfterEvent extends EventObject {
+  type: 'xstate.after';
+  delay: number | string;
+  stateId: string;
+}
+/** @public */
+interface TimeoutEvent extends EventObject {
+  type: 'xstate.timeout';
+  stateId: string;
+}
+/** @public */
+interface ActorTimeoutEvent extends EventObject {
+  type: 'xstate.timeout.actor';
+  actorId: string;
+  sessionId?: string | undefined;
+}
+/** @public */
+declare enum SpecialTargets {
+  Internal = "#_internal"
+}
+/** @public */
+type Mapper<TContext extends MachineContext, TExpressionEvent extends EventObject, TResult, TEvent extends EventObject, _TCtx = [TContext] extends [never] ? any : TContext> = (args: {
+  context: _TCtx;
+  event: TExpressionEvent;
+  input?: Record<string, unknown>;
+  self: ActorSelf<MachineSnapshot<_TCtx & MachineContext, TEvent, Record<string, AnyActorRef>, // TODO: this should be replaced with `TChildren`
+    StateValue, string, unknown, TODO, // TMeta
+    TODO>, TEvent, AnyEventObject>;
+} & OutputArg<TExpressionEvent>) => TResult;
+/** @public */
+interface TransitionDefinition<TContext extends MachineContext, TEvent extends EventObject, TMeta extends MetaObject = any> extends Omit<TransitionConfig<TContext, TEvent, TEvent, TODO, TMeta, TODO, TODO, TODO, TODO>, 'target' | 'to'> {
+  target: ReadonlyArray<AnyStateNode> | undefined;
+  source: AnyStateNode;
+  reenter: boolean;
+  eventType: EventDescriptor<TEvent>;
+  to?: ((...args: any[]) => any) | undefined;
+  input?: Record<string, unknown> | ((args: {
+    context: any;
+    event: any;
+    output: any;
+  }) => Record<string, unknown>);
+}
+/** @public */
+type AnyTransitionDefinition = TransitionDefinition<any, any>;
+/** @public */
+type InitialTransitionDefinition<TMeta extends MetaObject = any> = {
+  source: AnyStateNode;
+  target: AnyStateNode[] | undefined;
+  reenter?: boolean;
+  eventType?: EventDescriptor<any>;
+  meta?: TMeta;
+  description?: string | undefined;
+  input?: Record<string, unknown> | ((args: {
+    context: MachineContext;
+    event: EventObject;
+  }) => Record<string, unknown>);
+  to?: ((...args: any[]) => any) | undefined;
+};
+/** @public */
+type TransitionDefinitionMap<TContext extends MachineContext, TEvent extends EventObject, TMeta extends MetaObject = any> = { [K in EventDescriptor<TEvent>]: Array<TransitionDefinition<TContext, ExtractEvent<TEvent, K>, TMeta>>; };
+/** @public */
+type DelayExpr<TContext extends MachineContext, TEvent extends EventObject> = (args: {
+  context: [TContext] extends [never] ? any : TContext;
+  event: TEvent;
+  stateNode: AnyStateNode;
+}) => number;
+/** @public */
+interface DelayedTransitionDefinition<TContext extends MachineContext, TEvent extends EventObject, TMeta extends MetaObject = any> extends TransitionDefinition<TContext, TEvent, TMeta> {
+  delay: number | string | DelayExpr<TContext, TEvent>;
+}
+/** @public */
+interface StateLike<TContext extends MachineContext> {
+  value: StateValue;
+  context: TContext;
+  event: EventObject;
+}
+/** @public */
+interface StateConfig<TContext extends MachineContext, TEvent extends EventObject> {
+  context: TContext;
+  historyValue?: HistoryValue | undefined;
+  children: Record<string, AnyActorRef | undefined>;
+  timers?: Record<string, LogicalTimer>;
+  status: SnapshotStatus;
+  output?: any;
+  error?: unknown;
+  machine?: StateMachine<TContext, TEvent, any, any, any, any, any, any, any, any, any, any, any, any>;
+}
+/**
+ * A deterministic delayed-delivery declaration owned by a logic snapshot.
+ *
+ * @public
+ */
+interface LogicalTimer {
+  id: string;
+  delay: number;
+  type: '@xstate.raise' | '@xstate.sendTo';
+  event: EventObject;
+  /** `self` or the logical actor that will receive `event`. */
+  target: 'self' | AnyActor;
+  /**
+   * The timer's absolute start in milliseconds, persisted from a running
+   * wall-clock actor or a successfully scheduled durable timer. Carried
+   * through restore so re-persisting keeps the original deadline.
+   */
+  startedAt?: number;
+}
+/**
+ * The logical input delivered to a timer's source when its runtime delay ends.
+ *
+ * @public
+ */
+interface TimerEvent extends EventObject {
+  type: 'xstate.timer';
+  id: string;
+}
+declare const persistedSnapshotLogic: unique symbol;
+type PersistedSnapshotLogicIdentity<TLogic> = TLogic extends {
+  readonly id: infer TId extends string;
+} ? {
+  readonly id: TId;
+  readonly version: TLogic extends {
+    readonly version: infer TVersion extends string;
+  } ? TVersion : string;
+} : never;
+/**
+ * A persisted snapshot tied to a versioned actor logic identity.
+ *
+ * @remarks
+ * This is a _brand only_: it carries the machine `id`/`version` identity used
+ * to constrain which persisted snapshots may be restored into which logic, and
+ * says nothing about the snapshot's shape. To annotate a value produced by
+ * {@link Actor.getPersistedSnapshot}, use {@link PersistedSnapshotFrom}
+ * instead.
+ * @public
+ */
+type PersistedSnapshotFor<TLogic> = {
+  readonly [persistedSnapshotLogic]: PersistedSnapshotLogicIdentity<TLogic>;
+};
+/**
+ * The identity stamp persisted by a machine that declares a `version`.
+ *
+ * @public
+ */
+type PersistedMachineIdentity<TMachine extends AnyStateMachine = AnyStateMachine> = {
+  id: TMachine['id'];
+  version: NonNullable<TMachine['version']>;
+};
+/**
+ * The persisted snapshot produced by `actor.getPersistedSnapshot()` for a given
+ * state machine:
+ *
+ * ```ts
+ * const persisted: PersistedSnapshotFrom<typeof machine> =
+ *   actor.getPersistedSnapshot();
+ * ```
+ *
+ * @remarks
+ * The `machine` identity field is only present for machines that declare a
+ * `version`; unversioned machines persist no identity stamp.
+ *
+ * Unlike {@link PersistedSnapshotFor}, which is only the restore-time identity
+ * brand, this describes the persisted snapshot's actual shape.
+ */
+/**
+ * One entry in a persisted snapshot's `children`.
+ *
+ * @remarks
+ * An embedded child carries its own persisted `snapshot` — the co-locating
+ * runtime's whole-tree checkpoint. A child persisted by address
+ * (`getPersistedSnapshot({ embedChildren: false })`) and a remote handle carry
+ * `remote: true` instead, leaving each child's state with the runtime that
+ * owns it.
+ * @public
+ */
+type PersistedActorRef = {
+  /** The child's logical address, stable across incarnations. */
+  address?: string;
+  /** The registered source key the child is restored from. */
+  src: string;
+  registryKey?: string;
+  syncSnapshot?: boolean;
+} & ({
+  snapshot: unknown;
+  remote?: undefined;
+} | {
+  snapshot?: undefined;
+  remote: true;
+  incarnation?: string;
+});
+/** @public */
+type PersistedSnapshotFrom<TMachine extends AnyStateMachine> = Snapshot<unknown> & PersistedSnapshotFor<TMachine> & {
+  context: ContextFrom<TMachine>;
+  children: Record<string, PersistedActorRef>;
+  [key: string]: unknown;
+} & (undefined extends TMachine['version'] ? {
+  machine?: PersistedMachineIdentity<TMachine>;
+} : {
+  machine: PersistedMachineIdentity<TMachine>;
+});
+/**
+ * The persisted snapshot produced by `actor.getPersistedSnapshot()`.
+ *
+ * @public
+ */
+type PersistedSnapshotOf<TLogic extends AnyActorLogic> = TLogic extends AnyStateMachine ? PersistedSnapshotFrom<TLogic> : Snapshot<unknown> & PersistedSnapshotFor<TLogic>;
+/**
+ * A persisted snapshot restorable into the given actor logic: any snapshot
+ * created by logic with the same machine `id` is accepted, regardless of
+ * version (version mismatches are handled at runtime, e.g. by `migrate`).
+ *
+ * @public
+ */
+type RestorablePersistedSnapshotFor<TLogic> = {
+  readonly [persistedSnapshotLogic]: TLogic extends {
+    readonly id: infer TId extends string;
+  } ? {
+    readonly id: TId;
+    readonly version: string;
+  } : never;
+};
+/** @public */
+interface ActorOptions<TLogic extends AnyActorLogic> {
+  /**
+   * The clock that is responsible for setting and clearing timeouts, such as
+   * delayed events and transitions.
+   *
+   * @remarks
+   * You can create your own “clock”. The clock interface supports these
+   * methods:
+   *
+   * - `now` - optional; returns the current time in milliseconds
+   * - `setTimeout` - same arguments as `window.setTimeout(fn, timeout)`
+   * - `clearTimeout` - same arguments as `window.clearTimeout(id)`
+   *
+   * By default, `Date.now`, native `setTimeout`, and native `clearTimeout` are
+   * used.
+   *
+   * For testing, XState provides `SimulatedClock`.
+   * @see `Clock`
+   * @see {@link (SimulatedClock:class)}
+   */
+  clock?: Clock;
+  wallClock?: WallClock;
+  crypto?: CryptoSource;
+  /**
+   * Specifies the logger to be used for `log(...)` actions. Defaults to the
+   * native `console.log(...)` method.
+   */
+  logger?: (...args: any[]) => void;
+  reportUnhandledError?: (error: unknown) => void;
+  warn?: (message: string) => void;
+  parent?: AnyActor;
+  /** The custom `id` for referencing this service. */
+  id?: string;
+  /** @deprecated Use `inspect` instead. */
+  devTools?: never;
+  /** The registry key to register this actor under. */
+  registryKey?: string | undefined;
+  /** The input data to pass to the actor. */
+  input?: InputFrom<TLogic>;
+  /**
+   * Initializes actor logic from a specific persisted internal state.
+   *
+   * @remarks
+   * If the state is compatible with the actor logic, when the actor is started
+   * it will be at that persisted state. Actions from machine actors will not be
+   * re-executed, because they are assumed to have been already executed.
+   * However, invocations will be restarted, and spawned actors will be restored
+   * recursively.
+   *
+   * Can be generated with {@link Actor.getPersistedSnapshot}.
+   * @see https://stately.ai/docs/persistence
+   */
+  snapshot?: Snapshot<unknown> & Partial<RestorablePersistedSnapshotFor<DoNotInfer<TLogic>>>;
+  /** The source actor logic. */
+  src?: string | AnyActorLogic;
+  /**
+   * A callback function or observer object which can be used to inspect actor
+   * system updates.
+   *
+   * @remarks
+   * If a callback function is provided, it can accept an inspection event
+   * argument. The inspection protocol has two event types:
+   *
+   * - `@xstate.actor` - An actor ref was created in the system (announces actor
+   *   topology: identity + parent).
+   * - `@xstate.transition` - An actor transitioned. Carries every facet of the
+   *   transition with flat, always-present fields: `event`, `snapshot`,
+   *   `sourceRef`, `microsteps`, executed `actions`, and `sent`/scheduled
+   *   events.
+   *
+   * Undelivered events (dead letters) are not inspection events; observe them
+   * with `onRejectedEvent`.
+   *
+   * @example
+   *
+   * ```ts
+   * import { createMachine } from '@systemfsoftware/xstate';
+   *
+   * const machine = createMachine({
+   *   // ...
+   * });
+   *
+   * const actor = createActor(machine, {
+   *   inspect: (inspectionEvent) => {
+   *     if (inspectionEvent.actorRef === actor) {
+   *       // This event is for the root actor
+   *     }
+   *
+   *     if (inspectionEvent.type === '@xstate.actor') {
+   *       console.log(inspectionEvent.actorRef, inspectionEvent.parentRef);
+   *     }
+   *
+   *     if (inspectionEvent.type === '@xstate.transition') {
+   *       console.log(inspectionEvent.sourceRef);
+   *       console.log(inspectionEvent.actorRef);
+   *       console.log(inspectionEvent.event);
+   *       console.log(inspectionEvent.snapshot);
+   *       // flat, always-present facets — no narrowing required
+   *       console.log(inspectionEvent.actions);
+   *       console.log(inspectionEvent.sent);
+   *       console.log(inspectionEvent.microsteps);
+   *     }
+   *   }
+   * });
+   * ```
+   *
+   * Alternately, an observer object (`{ next?, error?, complete? }`) can be
+   * provided:
+   *
+   * @example
+   *
+   * ```ts
+   * const actor = createActor(machine, {
+   *   inspect: {
+   *     next: (inspectionEvent) => {
+   *       if (inspectionEvent.actorRef === actor) {
+   *         // This event is for the root actor
+   *       }
+   *
+   *       if (inspectionEvent.type === '@xstate.actor') {
+   *         console.log(
+   *           inspectionEvent.actorRef,
+   *           inspectionEvent.parentRef
+   *         );
+   *       }
+   *
+   *       if (inspectionEvent.type === '@xstate.transition') {
+   *         console.log(inspectionEvent.sourceRef);
+   *         console.log(inspectionEvent.actorRef);
+   *         console.log(inspectionEvent.event);
+   *         console.log(inspectionEvent.snapshot);
+   *         console.log(inspectionEvent.actions);
+   *         console.log(inspectionEvent.sent);
+   *         console.log(inspectionEvent.microsteps);
+   *       }
+   *     }
+   *   }
+   * });
+   * ```
+   */
+  inspect?: Observer<InspectionEvent> | ((inspectionEvent: InspectionEvent) => void);
+  /**
+   * A dead-letter hook called whenever an event is rejected at the delivery
+   * boundary of this actor system — an invalid external event payload or an
+   * internal event type sent from outside its owning actor. Rejected events
+   * are never delivered and never error the target actor.
+   *
+   * Registers the listener with `actor.system.onRejectedEvent(...)`, which
+   * also accepts listeners added later. Ignored when this actor has a parent.
+   */
+  onRejectedEvent?: (rejection: EventRejection) => void;
+  /**
+   * Called when this state machine actor processes an event that no
+   * transition handled: the snapshot is unchanged and no effects ran.
+   * Internal `xstate.*` events are not reported.
+   *
+   * @param event The unhandled event.
+   * @param snapshot The actor's (unchanged) snapshot.
+   */
+  onUnhandledEvent?: (event: EventFromLogic<TLogic>, snapshot: SnapshotFrom<TLogic>) => void;
+}
+/** @public */
+type AnyActor = ActorInstance<any, any, any, any>;
+/** @public */
+type Observer<T> = {
+  next?: ((value: T) => void) | undefined;
+  error?: ((err: unknown) => void) | undefined;
+  complete?: (() => void) | undefined;
+  /**
+   * Marks an observer that only tracks the actor's lifecycle, such as one
+   * installed by a runtime integration. A passive observer does not count as
+   * an error handler: an unhandled actor error is still reported when every
+   * observer with an `error` callback is passive.
+   */
+  passive?: boolean;
+};
+/** @public */
+interface Subscription {
+  unsubscribe(): void;
+}
+/** @public */
+interface Readable<T> extends Subscribable<T> {
+  get: () => T;
+}
+/** @public */
+interface InteropObservable<T> {
+  [Symbol.observable]: () => InteropSubscribable<T>;
+}
+/** @public */
+interface InteropSubscribable<T> {
+  subscribe(observer: Observer<T>): Subscription;
+}
+/** @public */
+interface Subscribable<T> extends InteropSubscribable<T> {
+  subscribe(observer: Observer<T>): Subscription;
+  subscribe(next: (value: T) => void, error?: (error: any) => void, complete?: () => void): Subscription;
+}
+type EventDescriptorMatches<TEventType extends string, TNormalizedDescriptor> = TEventType extends TNormalizedDescriptor ? true : TNormalizedDescriptor extends TEventType ? true : false;
+type LiteralEventMatching<TEvent extends EventObject, TDescriptor> = TEvent extends any ? string extends TEvent['type'] ? never : TEvent['type'] extends TDescriptor ? TEvent : never : never;
+/**
+ * A catch-all event union (`{ type: string }` plus literal members, e.g.
+ * declared children's completion events) narrows an exact descriptor to its
+ * literal members, falling back to the catch-all members when none match
+ * (and for the `string` index key of `on`). Wildcard descriptors keep the
+ * whole union.
+ */
+type ExtractEventFromCatchAll<TEvent extends EventObject, TDescriptor> = TDescriptor extends `${string}*` ? TEvent : string extends TDescriptor ? CatchAllEvent<TEvent> : LiteralEventMatching<TEvent, TDescriptor> extends (infer TLiteral extends TEvent) ? [TLiteral] extends [never] ? CatchAllEvent<TEvent> : TLiteral : never;
+type CatchAllEvent<TEvent extends EventObject> = TEvent extends any ? string extends TEvent['type'] ? TEvent : never : never;
+/** @public */
+type ExtractEvent<TEvent extends EventObject, TDescriptor extends EventDescriptor<TEvent>> = string extends TEvent['type'] ? ExtractEventFromCatchAll<TEvent, TDescriptor> : NormalizeDescriptor<TDescriptor> extends (infer TNormalizedDescriptor) ? TEvent extends any ? true extends EventDescriptorMatches<TEvent['type'], TNormalizedDescriptor> ? TEvent : never : never : never;
+/** @public */
+interface BaseActorRef<TEvent extends EventObject> {
+  send: (event: TEvent) => void;
+}
+/** @public */
+interface ActorLike<TCurrent, TEvent extends EventObject> extends Subscribable<TCurrent> {
+  send: (event: TEvent) => void;
+}
+/**
+ * A consumer-facing actor handle.
+ *
+ * `ActorRef` describes the contract a consumer needs: which events can be sent
+ * to the actor, which snapshot it publishes for observation, and which emitted
+ * events can be listened to. It intentionally does not expose lifecycle control
+ * or runtime internals. A concrete `Actor` satisfies this interface, so APIs
+ * should accept `ActorRef` whenever they only need to send events, read
+ * snapshots, or listen to emitted events.
+ *
+ * @public
+ */
+interface ActorRef<TSnapshot extends Snapshot<unknown>, TEvent extends EventObject, TEmitted extends EventObject = EventObject, TSendEvent extends EventObject = TEvent> extends Subscribable<TSnapshot>, InteropObservable<TSnapshot> {
+  send: (event: TSendEvent) => void;
+  getSnapshot: () => TSnapshot;
+  on: <TType extends TEmitted['type'] | '*'>(type: TType, handler: (emitted: TEmitted & (TType extends '*' ? unknown : {
+    type: TType;
+  })) => void) => Subscription;
+}
+type EventPayload<TEvent extends EventObject, TType extends TEvent['type']> = HomomorphicOmit<ExtractEvent<TEvent, TType>, 'type'>;
+/** @public */
+type ActorTrigger<TEvent extends EventObject> = { [K in TEvent['type']]: {} extends EventPayload<TEvent, K> ? () => void : (payload: EventPayload<TEvent, K>) => void; };
+/**
+ * Runtime-only actor capabilities.
+ *
+ * These members are needed by the interpreter, scheduler, inspection, and child
+ * management code. Public consumer APIs should prefer `ActorRef` unless they
+ * genuinely need lifecycle control such as starting, stopping, or accessing
+ * system-owned runtime state.
+ *
+ * @public
+ */
+interface ActorRuntime<TSnapshot extends Snapshot<unknown>, TEvent extends EventObject, _TEmitted extends EventObject = EventObject, TSendEvent extends EventObject = TEvent> {
+  /** The unique identifier for this actor relative to its parent. */
+  id: string;
+  /**
+   * The deterministic logical address of this actor within its system: the
+   * `/`-joined path of actor ids from the root. Stable across persistence and
+   * restore, unlike `sessionId`.
+   */
+  readonly address: string;
+  /**
+   * The globally unique process ID for this invocation.
+   *
+   * @remarks
+   * This is only defined once the actor is started.
+   */
+  sessionId: string | undefined;
+  start: () => this;
+  getPersistedSnapshot: () => Snapshot<unknown>;
+  stop: () => void;
+  toJSON?: () => any;
+  _parent?: any;
+  system: any;
+  src: string | AnyActorLogic;
+  /** Registry key used by the actor system receptionist. */
+  registryKey?: string | undefined;
+  trigger: ActorTrigger<TSendEvent>;
+  select<TSelected>(selector: (snapshot: TSnapshot) => TSelected, equalityFn?: (a: TSelected, b: TSelected) => boolean): Readable<TSelected>;
+}
+/**
+ * A concrete actor instance type.
+ *
+ * `ActorInstance` combines the consumer `ActorRef` contract with runtime
+ * lifecycle capabilities. Values returned by `createActor(...)` and
+ * `spawn(...)` naturally satisfy narrower `ActorRef` contracts.
+ *
+ * @public
+ */
+interface ActorInstance<TSnapshot extends Snapshot<unknown>, TEvent extends EventObject, TEmitted extends EventObject = EventObject, TSendEvent extends EventObject = TEvent> extends ActorRuntime<TSnapshot, TEvent, TEmitted, TSendEvent>, ActorRef<TSnapshot, TEvent, TEmitted, TSendEvent> {}
+/**
+ * The actor's own full self handle.
+ *
+ * Internals and action/guard sources receive this shape because `self` can
+ * participate in runtime-owned behavior while still being usable wherever an
+ * `ActorRef` is expected.
+ *
+ * @public
+ */
+type ActorSelf<TSnapshot extends Snapshot<unknown>, TEvent extends EventObject, TEmitted extends EventObject = EventObject, TSendEvent extends EventObject = TEvent> = ActorRuntime<TSnapshot, TEvent, TEmitted, TSendEvent> & ActorRef<TSnapshot, TEvent, TEmitted, TSendEvent>;
+type MachineContextOf<T> = T extends {
+  root: StateNode<infer TContext, any, any, any>;
+} ? TContext : never;
+/** @public */
+type ActorRefFrom<T> = T extends StateMachine<any, infer TEvent, infer TChildren, infer TStateValue, infer TTag, infer _TInput, infer TOutput, infer TEmitted, infer TMeta, infer _TConfig, infer _TActionMap, infer _TActorMap, infer _TGuardMap, infer _TDelayMap, infer TInternalEvent> ? ActorRef<MachineSnapshot<MachineContextOf<T>, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, any>, TEvent, TEmitted, SendableEventFromMachine<TEvent, TInternalEvent>> : T extends Promise<infer U> ? ActorRefFrom<AsyncActorLogic<U>> : T extends ActorLogic<infer TSnapshot, infer TEvent, infer _TInput, infer _TSystem, infer TEmitted> ? ActorRef<TSnapshot, TEvent, TEmitted, SendableEventFromLogic<T>> : never;
+/** @public */
+type SendableEventFromLogic<TLogic extends AnyActorLogic> = TLogic extends StateMachine<infer _TContext, infer TEvent, infer _TChildren, infer _TStateValue, infer _TTag, infer _TInput, infer _TOutput, infer _TEmitted, infer _TMeta, infer _TConfig, infer _TActionMap, infer _TActorMap, infer _TGuardMap, infer _TDelayMap, infer TInternalEvent> ? SendableEventFromMachine<TEvent, TInternalEvent> : TLogic extends SendableEventCarrier<infer TSendableEvent> ? TSendableEvent : EventFromLogic<TLogic>;
+type OpaqueMachineSnapshot<TSnapshot extends Snapshot<unknown>> = TSnapshot extends MachineSnapshot<infer TContext, infer TEvent, infer TChildren, infer TStateValue, infer TTag, infer TOutput, infer TMeta, infer _TStateSchema> ? MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, any> : TSnapshot;
+/** @public */
+type ActorRefFromLogic<T extends AnyActorLogic> = ActorRef<OpaqueMachineSnapshot<SnapshotFrom<T>>, EventFromLogic<T>, EmittedFrom<T>, SendableEventFromLogic<T>>;
+/** @public */
+interface AnyActorRef extends Subscribable<any>, InteropObservable<any> {
+  send(event: any): void;
+  getSnapshot(): any;
+  on(type: string, handler: (emitted: any) => void): Subscription;
+}
+/**
+ * The concrete actor instance type produced from actor logic.
+ *
+ * @public
+ */
+type ActorFromLogic<T extends AnyActorLogic> = ActorInstance<SnapshotFrom<T>, EventFromLogic<T>, EmittedFrom<T>, SendableEventFromLogic<T>>;
+type SendableEventFromActorRef<TActorRef, TFallback extends EventObject = AnyEventObject> = [NonNullable<TActorRef>] extends [never] ? TFallback : NonNullable<TActorRef> extends (infer TNonNullableActorRef) ? TNonNullableActorRef extends {
+  send: (event: infer TEvent) => void;
+} ? [TEvent] extends [never] ? TFallback : TEvent extends EventObject ? TEvent : TFallback : never : never;
+/** @public */
+type ActorRefLike = Pick<AnyActor, 'sessionId' | 'send' | 'getSnapshot'>;
+/** @public */
+type UnknownActorRef = ActorRef<Snapshot<unknown>, EventObject>;
+/** @public */
+type DevToolsAdapter = (service: AnyActor) => void;
+/** @public */
+type MachineSourcesFrom<T extends AnyStateMachine | ((...args: any[]) => AnyStateMachine)> = T extends StateMachine<infer _TContext, infer _TEvent, infer _TChildren, infer _TStateValue, infer _TTag, infer _TInput, infer _TOutput, infer _TEmitted, infer _TMeta, infer _TConfig, infer TActionMap, infer TActorMap, infer TGuardMap, infer TDelayMap> ? {
+  actions: TActionMap;
+  actors: TActorMap;
+  guards: TGuardMap;
+  delays: TDelayMap;
+} : never;
+/** @public */
+interface ActorScope<TSnapshot extends Snapshot<unknown>, TEvent extends EventObject, TSystem extends AnyActorSystem = AnyActorSystem, TEmitted extends EventObject = EventObject, TSendEvent extends EventObject = TEvent> {
+  self: ActorSelf<TSnapshot, TEvent, TEmitted, TSendEvent>;
+  id: string;
+  sessionId: string;
+  logger: (...args: any[]) => void;
+  warn: (message: string) => void;
+  defer: (fn: () => void) => void;
+  emit: (event: TEmitted) => void | PromiseLike<void>;
+  system: TSystem;
+  stopChild: (child: AnyActor) => void;
+  actionExecutor: ActionExecutor;
+}
+/** @public */
+type AnyActorScope = ActorScope<any, // TSnapshot
+  any, // TEvent
+  AnyActorSystem, any, // TEmitted
+  any>;
+/** @public */
+type SnapshotStatus = 'active' | 'done' | 'error' | 'stopped';
+/** @public */
+type Snapshot<TOutput, TError = unknown> = {
+  status: 'active';
+  output: undefined;
+  error: undefined;
+} | {
+  status: 'done';
+  output: TOutput;
+  error: undefined;
+} | {
+  status: 'error';
+  output: undefined;
+  error: TError;
+} | {
+  status: 'stopped';
+  output: undefined;
+  error: undefined;
+};
+/** @public */
+type ActorLogicTransitionResult<TSnapshot extends Snapshot<unknown>, TEffect = ExecutableActionObject> = [nextSnapshot: TSnapshot, effects: TEffect[]];
+/**
+ * Represents logic which can be used by an actor.
+ *
+ * @template TSnapshot - The type of the snapshot.
+ * @template TEvent - The type of the event object.
+ * @template TInput - The type of the input.
+ * @template TSystem - The type of the actor system.
+ * @public
+ */
+interface ActorLogic<in out TSnapshot extends Snapshot<unknown>, // it's invariant because it's also part of `ActorScope["self"]["getSnapshot"]`
+  in out TEvent extends EventObject, // it's invariant because it's also part of `ActorScope["self"]["send"]`
+  in TInput = NonReducibleUnknown, TSystem extends AnyActorSystem = AnyActorSystem, in out TEmitted extends EventObject = EventObject> {
+  /** The initial setup/configuration used to create the actor logic. */
+  config?: unknown;
+  /** Optional runtime validator for pure calculation boundaries. */
+  validator?: ActorLogicValidator | undefined;
+  /**
+   * Transition function that processes the current state and an incoming event
+   * to produce a new state and effects.
+   *
+   * @param snapshot - The current state.
+   * @param event - The incoming event.
+   * @param actorScope - The actor scope.
+   * @returns A tuple of the next state and effects.
+   */
+  transition: (snapshot: TSnapshot, event: TEvent, actorScope: ActorScope<TSnapshot, TEvent, TSystem, TEmitted>) => ActorLogicTransitionResult<TSnapshot>;
+  /**
+   * Transition function that produces the initial state and effects.
+   *
+   * @param actorScope - The actor scope.
+   * @param input - The input for the initial state.
+   * @returns A tuple of the initial state and effects.
+   */
+  initialTransition: (input: TInput, actorScope: ActorScope<TSnapshot, TEvent, TSystem, TEmitted>) => ActorLogicTransitionResult<TSnapshot>;
+  /**
+   * Called to provide the initial state of the actor.
+   *
+   * @param actorScope - The actor scope.
+   * @param input - The input for the initial state.
+   * @returns The initial state.
+   */
+  getInitialSnapshot: (actorScope: ActorScope<TSnapshot, TEvent, TSystem, TEmitted>, input: TInput) => TSnapshot;
+  /**
+   * Called when Actor is created to restore the internal state of the actor
+   * given a persisted state. The persisted state can be created by
+   * `getPersistedSnapshot`.
+   *
+   * @param persistedState - The persisted state to restore from.
+   * @param actorScope - The actor scope.
+   * @returns The restored state.
+   */
+  restoreSnapshot?: (persistedState: Snapshot<unknown>, actorScope: ActorScope<TSnapshot, TEvent, AnyActorSystem, TEmitted>) => TSnapshot;
+  /**
+   * Called when the actor is started.
+   *
+   * @param snapshot - The starting state.
+   * @param actorScope - The actor scope.
+   * @param options - Start metadata, including whether the snapshot was
+   *   restored.
+   */
+  start?: (snapshot: TSnapshot, actorScope: ActorScope<TSnapshot, TEvent, AnyActorSystem, TEmitted>, options?: {
+    restored: boolean;
+  }) => void;
+  /**
+   * Obtains the internal state of the actor in a representation which can be be
+   * persisted. The persisted state can be restored by `restoreSnapshot`.
+   *
+   * @param snapshot - The current state.
+   * @returns The a representation of the internal state to be persisted.
+   */
+  getPersistedSnapshot: (snapshot: TSnapshot, options?: unknown, warn?: (message: string) => void) => Snapshot<unknown>;
+  /**
+   * Returns an event that the actor should transition with to recover from an
+   * execution error, or `undefined` if the given snapshot cannot handle it.
+   * Actor logic without error-recovery semantics can omit this.
+   */
+  getExecutionErrorEvent?: (snapshot: TSnapshot, error: unknown) => TEvent | undefined;
+}
+/** @public */
+interface AnyActorLogic {
+  config?: unknown;
+  validator?: ActorLogicValidator | undefined;
+  transition(snapshot: any, event: any, actorScope: any): ActorLogicTransitionResult<any>;
+  initialTransition(input: any, actorScope: any): ActorLogicTransitionResult<any>;
+  getInitialSnapshot(actorScope: any, input: any): any;
+  restoreSnapshot?(persistedState: Snapshot<unknown>, actorScope: any): any;
+  start?(snapshot: any, actorScope: any, options?: {
+    restored: boolean;
+  }): void;
+  getPersistedSnapshot(snapshot: any, options?: unknown, warn?: (message: string) => void): Snapshot<unknown>;
+  getExecutionErrorEvent?(snapshot: any, error: unknown): any;
+}
+/** @public */
+type UnknownActorLogic = ActorLogic<any, // snapshot
+  any, // event
+  any, // input
+  AnyActorSystem, any>;
+/** @public */
+type SnapshotFrom<T> = ReturnTypeOrValue<T> extends (infer R) ? R extends ActorRef<infer TSnapshot, infer _, infer __> ? TSnapshot : R extends Actor<infer TLogic> ? SnapshotFrom<TLogic> : R extends ActorLogic<infer TSnapshot, infer _TEvent, infer _TInput, infer _TSystem, infer _TEmitted> ? TSnapshot : R extends ActorScope<infer TSnapshot, infer _TEvent, infer _TEmitted, infer _TSystem> ? TSnapshot : never : never;
+/** @public */
+type EventFromLogic<TLogic extends AnyActorLogic> = TLogic extends ActorLogic<infer _TSnapshot, infer TEvent, infer _TInput, infer _TSystem, infer _TEmitted> ? TEvent : never;
+/** @public */
+type EmittedFrom<TLogic extends AnyActorLogic> = TLogic extends StateMachine<infer _TContext, infer _TEvent, infer _TChildren, infer _TStateValue, infer _TTag, infer _TInput, infer _TOutput, infer TEmitted, infer _TMeta, infer _TStateSchema, infer _TActionMap, infer _TActorMap, infer _TGuardMap, infer _TDelayMap> ? TEmitted : [TLogic] extends [AnyStateMachine] ? AnyEventObject : TLogic extends ActorLogic<infer _TSnapshot, infer _TEvent, infer _TInput, infer _TSystem, infer TEmitted> ? TEmitted : AnyEventObject;
+type ResolveEventType<T> = T extends (infer R) ? R extends StateMachine<infer _TContext, infer TEvent, infer _TChildren, infer _TStateValue, infer _TTag, infer _TInput, infer _TOutput, infer _TEmitted, infer _TMeta, infer _TConfig, infer _TActionMap, infer _TActorMap, infer _TGuardMap, infer _TDelayMap> ? TEvent : R extends MachineSnapshot<infer _TContext, infer TEvent, infer _TChildren, infer _TStateValue, infer _TTag, infer _TOutput, infer _TMeta, infer _TStateSchema> ? TEvent : R extends ActorRef<infer _TSnapshot, infer TEvent, infer _TEmitted> ? TEvent : never : never;
+/** @public */
+type EventFrom<T, K extends Prop<TEvent, 'type'> = never, TEvent extends EventObject = ResolveEventType<T>> = IsNever<K> extends true ? TEvent : ExtractEvent<TEvent, K>;
+/** @public */
+type ContextFrom<T> = T extends StateMachine<any, infer _TEvent, infer _TChildren, infer _TStateValue, infer _TTag, infer _TInput, infer _TOutput, infer _TEmitted, infer _TMeta, infer _TConfig, infer _TActionMap, infer _TActorMap, infer _TGuardMap, infer _TDelayMap> ? MachineContextOf<T> : T extends MachineSnapshot<infer TContext, infer _TEvent, infer _TChildren, infer _TStateValue, infer _TTag, infer _TOutput, infer _TMeta, infer _TStateSchema> ? TContext : T extends Actor<infer TActorLogic> ? TActorLogic extends AnyStateMachine ? ContextFrom<TActorLogic> : never : never;
+/** @public */
+type InferEvent<E extends EventObject> = { [T in E['type']]: {
+  type: T;
+} & Extract<E, {
+  type: T;
+}>; }[E['type']];
+/** @public */
+type TODO = any;
+/** @public */
+type StateValueFrom<TMachine extends AnyStateMachine> = Parameters<StateFrom<TMachine>['matches']>[0];
+/** @public */
+type TagsFrom<TMachine extends AnyStateMachine> = Parameters<StateFrom<TMachine>['hasTag']>[0];
+/** @public */
+interface ActorSystemInfo {
+  actors: Record<string, AnyActorRef>;
+}
+/** @public */
+type SystemRegistry = Record<string, AnyActorLogic>;
+/** @public */
+type RegistryKeyForLogic<TLogic extends AnyActorLogic, TSystemRegistry extends SystemRegistry> = string extends keyof TSystemRegistry ? string : Values$1<{ [K in keyof TSystemRegistry & string]: ActorRefFromLogic<TLogic> extends ActorRefFromLogic<TSystemRegistry[K]> ? K : never; }>;
+/** @public */
+type RequiredActorOptions<TActor extends ProvidedActor> = (undefined extends TActor['id'] ? never : 'id') | (undefined extends InputFrom<TActor['logic']> ? never : 'input');
+/** @public */
+type RequiredLogicInput<TLogic extends AnyActorLogic> = undefined extends InputFrom<TLogic> ? never : 'input';
+type ExtractLiteralString<T extends string | undefined> = T extends string ? string extends T ? never : T : never;
+type ToConcreteChildren<TActor extends ProvidedActor> = { [A in TActor as ExtractLiteralString<A['id']>]?: ActorFromLogic<A['logic']>; };
+type NonConcreteActors<TActor extends ProvidedActor> = TActor extends any ? ExtractLiteralString<TActor['id']> extends never ? TActor : never : never;
+/** @public */
+type ToChildren<TActor extends ProvidedActor> = string extends TActor['src'] ? Record<string, AnyActor> : Compute<ToConcreteChildren<TActor> & {
+  include: {
+    [id: string]: NonConcreteActors<TActor> extends never ? AnyActor | undefined : NonConcreteActors<TActor> extends any ? ActorFromLogic<NonConcreteActors<TActor>['logic']> | undefined : never;
+  };
+  exclude: unknown;
+}[NonConcreteActors<TActor> extends never ? 'exclude' : 'include']>;
+/** @public */
+type StateSchema = {
+  id?: string | undefined;
+  route?: unknown;
+  states?: Record<string, StateSchema> | undefined;
+  contextSchema?: StandardSchemaV1 | undefined;
+  outputSchema?: StandardSchemaV1 | undefined;
+  input?: unknown;
+  initial?: unknown;
+  type?: unknown;
+  history?: unknown;
+  target?: unknown;
+  invoke?: unknown;
+  on?: unknown;
+  entry?: unknown;
+  exit?: unknown;
+  onDone?: unknown;
+  onError?: unknown;
+  timeout?: unknown;
+  onTimeout?: unknown;
+  after?: unknown;
+  always?: unknown;
+  choice?: unknown;
+  meta?: unknown;
+  output?: unknown;
+  tags?: unknown;
+  description?: unknown;
+};
+/** @public */
+type StateSchemaFrom<T extends AnyStateMachine> = T extends StateMachine<infer _TContext, infer _TEvent, infer _TChildren, infer _TStateValue, infer _TTag, infer _TInput, infer _TOutput, infer _TEmitted, infer _TMeta, infer TStateSchema, infer _TActionMap, infer _TActorMap, infer _TGuardMap, infer _TDelayMap> ? TStateSchema : never;
+/** @public */
+type StateId<TSchema extends StateSchema, TKey extends string = '(machine)', TParentKey extends string | null = null> = (TSchema extends {
+  id: string;
+} ? TSchema['id'] : TParentKey extends null ? TKey : `${TParentKey}.${TKey}`) | (TSchema['states'] extends Record<string, any> ? Values$1<{ [K in keyof TSchema['states'] & string]: StateId<TSchema['states'][K], K, TParentKey extends string ? `${TParentKey}.${TKey}` : TSchema['id'] extends string ? TSchema['id'] : TKey>; }> : never);
+/**
+ * Maps state IDs to their input types based on the StateSchema.
+ *
+ * @public
+ */
+type StateIdInputs<TSchema extends StateSchema, TKey extends string = '(machine)', TParentKey extends string | null = null> = { [K in TSchema extends {
+  id: string;
+} ? TSchema['id'] : TParentKey extends null ? TKey : `${TParentKey}.${TKey}`]: TSchema['input'] extends undefined ? undefined : TSchema['input']; } & (TSchema['states'] extends Record<string, StateSchema> ? UnionToIntersection<Values$1<{ [K in keyof TSchema['states'] & string]: StateIdInputs<TSchema['states'][K], K, TParentKey extends string ? `${TParentKey}.${TKey}` : TSchema['id'] extends string ? TSchema['id'] : TKey>; }>> : {});
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
+type ContextFromStateSchema<TSchema extends StateSchema, TFallbackContext extends MachineContext> = TSchema['contextSchema'] extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<TSchema['contextSchema']> & TFallbackContext & MachineContext : TFallbackContext;
+type ContextFromChildStateValue<TChildSchema extends StateSchema, TFallbackContext extends MachineContext, TChildValue> = ContextFromStateSchema<TChildSchema, TFallbackContext> & StateContextFromStateValue<TChildSchema, ContextFromStateSchema<TChildSchema, TFallbackContext>, TChildValue>;
+/** @public */
+type StateContextFromStateValue<TSchema extends StateSchema, TFallbackContext extends MachineContext, TStateValue> = (TSchema['states'] extends Record<string, StateSchema> ? TStateValue extends keyof TSchema['states'] & string ? ContextFromStateSchema<TSchema['states'][TStateValue], TFallbackContext> : TStateValue extends Record<string, unknown> ? UnionToIntersection<Values$1<{ [K in keyof TStateValue & keyof TSchema['states'] & string]: ContextFromChildStateValue<TSchema['states'][K], TFallbackContext, NonNullable<TStateValue[K]>>; }>> : TFallbackContext : TFallbackContext) & MachineContext;
+/** @public */
+type RoutableStateId<TSchema extends StateSchema> = (TSchema extends {
+  route: any;
+  id: string;
+} ? `#${TSchema['id']}` : never) | (TSchema['states'] extends Record<string, any> ? Values$1<{ [K in keyof TSchema['states'] & string]: RoutableStateId<TSchema['states'][K]>; }> : never);
+/** @public */
+interface StateMachineTypes {
+  context: MachineContext;
+  events: EventObject;
+  actors: ProvidedActor;
+  actions: ParameterizedObject;
+  guards: ParameterizedObject;
+  delays: string;
+  tags: string;
+  emitted: EventObject;
+}
+type _GroupStateKeys<T extends StateSchema, S extends keyof T['states']> = S extends any ? T['states'][S] extends {
+  type: 'history';
+} ? [never, never] : T extends {
+  type: 'parallel';
+} ? [S, never] : T['states'][S] extends {
+  states: Record<string, StateSchema>;
+} ? [S, never] : [never, S] : never;
+type GroupStateKeys<T extends StateSchema, S extends keyof T['states']> = {
+  nonLeaf: _GroupStateKeys<T, S & string>[0];
+  leaf: _GroupStateKeys<T, S & string>[1];
+};
+/** @public */
+type ToStateValue<T extends StateSchema> = T extends {
+  states: Record<infer S, any>;
+} ? IsNever<S> extends true ? {} : GroupStateKeys<T, S>['leaf'] | (IsNever<GroupStateKeys<T, S>['nonLeaf']> extends false ? T extends {
+  type: 'parallel';
+} ? { [K in GroupStateKeys<T, S>['nonLeaf']]: ToStateValue<T['states'][K]>; } : Compute<Values$1<{ [K in GroupStateKeys<T, S>['nonLeaf']]: { [StateKey in K]: ToStateValue<T['states'][K]>; }; }>> : never) : {};
+/** @public */
+interface BaseExecutableActionObject {
+  params: NonReducibleUnknown;
+  args: unknown[];
+  exec(runtime?: Partial<ActorSystemRuntime>): void | PromiseLike<void> | undefined;
+}
+/**
+ * The terminal result published when an actor completes or errors.
+ *
+ * @public
+ */
+type ActorTermination = {
+  status: 'done';
+  output: unknown;
+  error: undefined;
+} | {
+  status: 'error';
+  output: undefined;
+  error: unknown;
+};
+/** @public */
+interface CustomExecutableActionObject<TType extends string = string & {}> extends BaseExecutableActionObject {
+  kind: 'action';
+  type: TType;
+  action: ((...args: any[]) => void | PromiseLike<void>) | undefined;
+}
+/** @public */
+interface EmitExecutableActionObject<TType extends string = string & {}> extends BaseExecutableActionObject {
+  kind: 'emit';
+  type: TType;
+  source: AnyActor;
+  event: EventObject & {
+    type: TType;
+  };
+}
+/** @public */
+interface SpawnExecutableActionObject extends BaseExecutableActionObject {
+  kind: 'builtin';
+  type: '@xstate.spawn';
+  source: AnyActor | undefined;
+  actor: AnyActor;
+  id: string;
+  logic: AnyActorLogic;
+  src: string | AnyActorLogic;
+  input: unknown;
+  args: Parameters<(typeof builtInActions)['@xstate.spawn']>;
+}
+/** @public */
+interface StartExecutableActionObject extends BaseExecutableActionObject {
+  kind: 'builtin';
+  type: '@xstate.start';
+  source: AnyActor | undefined;
+  actor: AnyActor;
+  id: string;
+  args: Parameters<(typeof builtInActions)['@xstate.start']>;
+}
+/** @public */
+interface RaiseExecutableActionObject extends BaseExecutableActionObject {
+  kind: 'builtin';
+  type: '@xstate.raise';
+  source: AnyActor;
+  event: EventObject;
+  id: string | undefined;
+  delay: number | undefined;
+  args: Parameters<(typeof builtInActions)['@xstate.raise']>;
+}
+/** @public */
+interface SendToExecutableActionObject extends BaseExecutableActionObject {
+  kind: 'builtin';
+  type: '@xstate.sendTo';
+  source: AnyActor;
+  target: AnyActor;
+  event: EventObject;
+  id: string | undefined;
+  delay: number | undefined;
+  args: Parameters<(typeof builtInActions)['@xstate.sendTo']>;
+}
+/** @public */
+interface CancelExecutableActionObject extends BaseExecutableActionObject {
+  kind: 'builtin';
+  type: '@xstate.cancel';
+  source: AnyActor;
+  id: string;
+  args: Parameters<(typeof builtInActions)['@xstate.cancel']>;
+}
+/** @public */
+interface StopExecutableActionObject extends BaseExecutableActionObject {
+  kind: 'builtin';
+  type: '@xstate.stop';
+  source: AnyActor;
+  actor: AnyActor;
+  id: string;
+  args: Parameters<(typeof builtInActions)['@xstate.stop']>;
+}
+/**
+ * An executable effect that publishes an actor's terminal result.
+ *
+ * @public
+ */
+type TerminateExecutableActionObject = BaseExecutableActionObject & {
+  kind: 'builtin';
+  type: '@xstate.terminate';
+  source: AnyActor;
+  actor: AnyActor;
+  id: string;
+  args: Parameters<(typeof builtInActions)['@xstate.terminate']>;
+} & ActorTermination;
+/**
+ * An executable effect that reports an event rejected at the delivery boundary
+ * (a dead letter). The snapshot paired with this effect is unchanged.
+ *
+ * @public
+ */
+interface DeadLetterExecutableActionObject extends BaseExecutableActionObject {
+  kind: 'builtin';
+  type: '@xstate.deadLetter';
+  /** The actor that sent the event, or `undefined` for an external send. */
+  source: AnyActor | undefined;
+  /**
+   * The actor that rejected the event, or `undefined` when the send target
+   * was missing (`reason: 'missingTarget'`).
+   */
+  target: AnyActor | undefined;
+  /** The rejected event. */
+  event: AnyEventObject;
+  /** Why the event was rejected, such as `'invalidEvent'`. */
+  reason: EventRejectionReason;
+  detail?: DeadLetterDetail | undefined;
+  args: [];
+}
+/** @public */
+type BuiltInExecutableActionObject = Values$1<{
+  '@xstate.spawn': SpawnExecutableActionObject;
+  '@xstate.start': StartExecutableActionObject;
+  '@xstate.raise': RaiseExecutableActionObject;
+  '@xstate.sendTo': SendToExecutableActionObject;
+  '@xstate.cancel': CancelExecutableActionObject;
+  '@xstate.stop': StopExecutableActionObject;
+  '@xstate.terminate': TerminateExecutableActionObject;
+  '@xstate.deadLetter': DeadLetterExecutableActionObject;
+}>;
+/** @public */
+type SpecialExecutableAction = BuiltInExecutableActionObject;
+type TransitionExecutableActionObject<TType extends string = never> = BuiltInExecutableActionObject | EmitExecutableActionObject | CustomExecutableActionObject<TType | (string & {})>;
+type KnownSourceKeys<TSourceMap> = string extends keyof TSourceMap ? never : Extract<keyof TSourceMap, string>;
+/** @public */
+type ExecutableActionObjectFromLogic<T extends AnyActorLogic> = T extends StateMachine<any, any, any, any, any, any, any, any, any, any, infer TActionMap, any, any, any> ? TransitionExecutableActionObject<KnownSourceKeys<TActionMap>> : ExecutableActionObject;
+/** @public */
+type ExecutableActionObject<TType extends string = string & {}> = BuiltInExecutableActionObject | EmitExecutableActionObject | CustomExecutableActionObject<TType>;
+/** @public */
+interface ToExecutableAction<T extends ParameterizedObject> extends CustomExecutableActionObject<T['type']> {
+  type: T['type'];
+  params: T['params'];
+  action: undefined;
+}
+/** @public */
+type ActionExecutor = (actionToExecute: ExecutableActionObject) => void;
+/**
+ * Mappers for subscribeTo - maps lifecycle events to machine events
+ *
+ * @public
+ */
+interface SubscribeToMappers<TSnapshot extends Snapshot<unknown>, TOutput, TMappedEvent extends EventObject> {
+  snapshot?: (snapshot: TSnapshot) => TMappedEvent;
+  done?: (output: TOutput) => TMappedEvent;
+  error?: (error: unknown) => TMappedEvent;
+}
+type EnqueueSpawnOptions<TLogic extends AnyActorLogic, TSystemRegistry extends SystemRegistry> = {
+  input?: InputFrom<TLogic>;
+  id?: string;
+  syncSnapshot?: boolean;
+  registryKey?: RegistryKeyForLogic<TLogic, TSystemRegistry>;
+};
+type EnqueueSpawnArgs<TLogic extends AnyActorLogic, TSystemRegistry extends SystemRegistry> = ConditionalRequired<[options?: EnqueueSpawnOptions<TLogic, TSystemRegistry> & { [K in RequiredLogicInput<TLogic>]: unknown; }], IsNotNever<RequiredLogicInput<TLogic>>>;
+type EnqueueSpawner<TActorMap extends Sources['actors'], TSystemRegistry extends SystemRegistry> = {
+  <TSource extends keyof TActorMap & string>(src: TSource, ...[options]: EnqueueSpawnArgs<TActorMap[TSource], TSystemRegistry>): ActorFromLogic<TActorMap[TSource]>;
+  <TLogic extends AnyActorLogic>(logic: TLogic, ...[options]: EnqueueSpawnArgs<TLogic, TSystemRegistry>): ActorFromLogic<TLogic>;
+};
+/** @public */
+type EnqueueObject<TEvent extends EventObject, TEmittedEvent extends EventObject, TSystemRegistry extends SystemRegistry = SystemRegistry, TActorMap extends Sources['actors'] = Sources['actors'], TChildren extends Record<string, AnyActorRef | undefined> = {}> = {
+  cancel: (id: string) => void;
+  raise: (ev: TEvent, options?: {
+    id?: string;
+    delay?: number;
+  }) => void;
+  /**
+   * Spawns a child actor from a registered source key or logic. Without an
+   * explicit `id`, the child gets a deterministic src-keyed id (`worker:0`,
+   * `worker:1`, …) allocated from the parent snapshot's own counters, so ids
+   * replay identically and persist with the parent.
+   */
+  spawn: EnqueueSpawner<TActorMap, TSystemRegistry>;
+  emit: (emittedEvent: TEmittedEvent) => void;
+  <T extends (...args: any[]) => any>(fn: T, ...args: Parameters<T>): void;
+  log: (...args: any[]) => void;
+  sendTo: <TTarget extends {
+    send: (...args: any[]) => void;
+  } | undefined | (keyof TChildren & string)>(target: TTarget, event: SendableEventFromActorRef<DoNotInfer<TTarget extends keyof TChildren & string ? TChildren[TTarget] : TTarget>>, options?: {
+    id?: string;
+    delay?: number;
+  }) => void;
+  stop: (actor?: AnyActorRef) => void;
+  /**
+   * Listen to emitted events from an actor. Returns a listener actor that can
+   * be stopped via `enq.stop()`.
+   *
+   * @param actor - The actor to listen to
+   * @param eventType - The emitted event type to listen for (supports
+   *   wildcards: 'event._', '_')
+   * @param mapper - Function to transform emitted events into machine events
+   */
+  listen: <TEmitted extends EventObject, TMappedEvent extends TEvent>(actor: AnyActorRef, eventType: string, mapper: (event: TEmitted) => TMappedEvent) => AnyActor;
+  /**
+   * Subscribe to lifecycle events (done/error/snapshot) from an actor. Returns
+   * a subscription actor that can be stopped via `enq.stop()`.
+   *
+   * @param actor - The actor to subscribe to
+   * @param mappers - Object with done/error/snapshot mappers, or a single
+   *   snapshot mapper function
+   */
+  subscribeTo: <TActor extends AnyActorRef, TMappedEvent extends TEvent>(actor: TActor, mappers: SubscribeToMappers<SnapshotFrom<TActor>, OutputFrom<TActor>, TMappedEvent> | ((snapshot: SnapshotFrom<TActor>) => TMappedEvent)) => AnyActor;
+};
+/** @public */
+type Action<TContext extends MachineContext, TEvent extends EventObject, TEmittedEvent extends EventObject, TActionMap extends Sources['actions'], TActorMap extends Sources['actors'], TGuardMap extends Sources['guards'], TDelayMap extends Sources['delays'], TParams = Record<string, unknown> | undefined, _TCtx = [TContext] extends [never] ? any : TContext> = (_: {
+  context: _TCtx;
+  event: TEvent;
+  parent: AnyActorRef | undefined;
+  self: ActorSelf<MachineSnapshot<_TCtx & MachineContext, TEvent, TODO, TODO, TODO, TODO, TODO, TODO>, TEvent>;
+  children: Record<string, AnyActor | undefined>;
+  actions: TActionMap;
+  actors: TActorMap;
+  guards: TGuardMap;
+  delays: TDelayMap;
+  system?: AnyActorSystem;
+  params: TParams;
+}, enqueue: EnqueueObject<TEvent, TEmittedEvent, SystemRegistry, TActorMap>) => {
+  context?: Partial<_TCtx>;
+  children?: Record<string, AnyActor | undefined>;
+} | void;
+/** @public */
+type AnyAction = Action<MachineContext, EventObject, EventObject, Sources['actions'], Sources['actors'], Sources['guards'], Sources['delays']> | {
+  action: (...args: any[]) => any;
+  args: any[];
+} | AnyEventObject;
+export { DelayExpr as $, TransitionConfigFunction as $n, DelayMapFromNames as $r, PersistedSnapshotFor as $t, AnyInvokeConfig as A, StateMachineTypes as An, ActorSystemRuntime as Ar, InteropSubscribable as At, BaseActorRef as B, Subscribable as Bn, InspectionEvent as Br, MachineTypes as Bt, AnyActor as C, ValidateStateTargets as Ci, StateConfig as Cn, LogicArgs as Cr, HomomorphicOmit as Ct, AnyEventObject as D, createdInvokeConfig as Di, StateIdInputs as Dn, TimeoutError as Dr, InitialTransitionDefinition as Dt, AnyActorScope as E, WithDefault as Ei, StateId as En, LogicFunction as Er, InitialTransitionConfig as Et, AnyStateNode as F, StateValue as Fn, EventRejection as Fr, IsNotNever as Ft, Cast as G, TagsFrom as Gn, ActorValidationEventOrigin as Gr, NormalizeDescriptor as Gt, BuiltInExecutableActionObject as H, Subscription as Hn, TransitionInspectionEvent as Hr, MaybeLazy as Ht, AnyStateNodeConfig as I, StateValueFrom as In, EventRejectionReason as Ir, Lazy as It, ContextFactory as J, TimerEvent as Jn, MachineSnapshotSchema as Jr, OutputFrom as Jt, Compute as K, TerminateExecutableActionObject as Kn, ActorValidationRequest as Kr, Observer as Kt, AnyTransitionConfig as L, StateValueFromStateSchema as Ln, WallClock as Lr, LogicalTimer as Lt, AnyMachineSnapshot as M, StateSchema as Mn, Clock as Mr, IsAny as Mt, AnyStateConfig as N, StateSchemaFrom as Nn, CryptoSource as Nr, IsLiteralString as Nt, AnyFunction as O, MachineSnapshot as Oi, StateKey as On, createAsyncLogic as Or, InputFrom as Ot, AnyStateMachine as P, StateTypes as Pn, DeadLetterDetail as Pr, IsNever as Pt, DelayConfig as Q, TransitionConfig as Qn, DelayDurationKey as Qr, PersistedMachineIdentity as Qt, AnyTransitionConfigFunction as R, StateValueMap as Rn, ActionRecord as Rr, LowInfer as Rt, AnyAction as S, ValidateHistoryDefaults as Si, StartExecutableActionObject as Sn, AsyncSnapshot as Sr, HistoryValue as St, AnyActorRef as T, WidenLiterals as Ti, StateFrom as Tn, LogicEnqueue as Tr, InitialContext as Tt, CallbackActors as U, SystemRegistry as Un, ActorLogicValidator as Ur, MetaObject as Ut, BaseExecutableActionObject as V, SubscribeToMappers as Vn, SentRecord as Vr, Mapper as Vt, CancelExecutableActionObject as W, TODO as Wn, ActorValidationBoundary as Wr, NonReducibleUnknown as Wt, CustomExecutableActionObject as X, ToExecutableAction as Xn, PersistedMachineSnapshot as Xr, PersistedActorRef as Xt, ContextFrom as Y, ToChildren as Yn, MachineVersionDescriptor as Yr, ParameterizedObject as Yt, DeadLetterExecutableActionObject as Z, ToStateValue as Zn, ChildCompletionEvents as Zr, PersistedHistoryValue as Zt, ActorSystemInfo as _, SchemaOrConfigOutput as _i, SnapshotFrom as _n, RequiredActorOptionsFor as _r, EventPayloadPattern as _t, ActorInstance as a, InferGuards as ai, Readable as an, TransitionTarget as ar, DoneStateEvent as at, ActorTrigger as b, ValidateDelayReferences as bi, SpecialExecutableAction as bn, AsyncActorLogic as br, ExtractEvent as bt, ActorLogicTransitionResult as c, InvokeInputArgs as ci, RequiredLogicInput as cn, UnknownActorLogic as cr, EnqueueObject as ct, ActorRefFrom as d, Next_InvokeConfigBase as di, SendToExecutableActionObject as dn, InfiniteTransitionError as dr, ErrorEvent as dt, DelaySourceMap as ei, PersistedSnapshotFrom as en, TransitionConfigTarget as er, DelayedTransitionDefinition as et, ActorRefFromLogic as f, Next_MachineConfig as fi, SendableEventFromLogic as fn, getStateNodes as fr, ErrorFrom as ft, ActorSelf as g, OutputFromConfig as gi, SnapshotEvent as gn, Actor as gr, EventFromLogic as gt, ActorScope as h, Next_TransitionConfigOrTarget as hi, Snapshot as hn, Spawner as hr, EventFrom as ht, ActorFromLogic as i, InferChildren as ii, RaiseExecutableActionObject as in, TransitionDefinitionMap as ir, DoneActorEvent as it, AnyInvokeDefinition as j, StateNodesConfig as jn, AnyActorSystem as jr, InvokeDefinition as jt, AnyHistoryValue as k, isMachineSnapshot as ki, StateLike as kn, ActorSystem as kr, InteropObservable as kt, ActorOptions as l, Next_ChoiceStateNodeConfig as li, RestorablePersistedSnapshotFor as ln, UnknownActorRef as lr, Equals as lt, ActorRuntime as m, Next_StateNodeConfig as mi, SingleOrArray as mn, StateNode as mr, EventDescriptor as mt, ActionArgs as n, GuardSourceMap as ni, Prop as nn, TransitionContextPatch as nr, DevToolsAdapter as nt, ActorLike as o, InferMachineInput as oi, RegistryKeyForLogic as on, TransitionsConfig as or, EmitExecutableActionObject as ot, ActorRefLike as p, Next_RegularStateNodeConfig as pi, SetupTypes as pn, checkStateIn as pr, ErrorPlatformEvent as pt, ConditionalRequired as q, TimeoutEvent as qn, MachineEventSchema as qr, OutputArg as qt, ActionExecutor as r, InferActions as ri, ProvidedActor as rn, TransitionDefinition as rr, DoNotInfer as rt, ActorLogic as s, InferOutput as si, RequiredActorOptions as sn, UnifiedArg as sr, EmittedFrom as st, Action as t, FinalStateConfigOutput as ti, PersistedSnapshotOf as tn, TransitionContextMapper as tr, DelayedTransitions as tt, ActorRef as u, Next_InvokeConfig as ui, RoutableStateId as un, StateMachine as ur, ErrorActorEvent as ut, ActorTermination as v, Sources as vi, SnapshotStatus as vn, RequiredActorOptionsKeys as vr, ExecutableActionObject as vt, AnyActorLogic as w, ValidateTopLevelFinalOutputs as wi, StateContextFromStateValue as wn, LogicConfig as wr, InferEvent as wt, AfterEvent as x, ValidateEventDescriptors as xi, SpecialTargets as xn, AsyncActorRef as xr, HistoryStateNode as xt, ActorTimeoutEvent as y, ValidateDelayNames as yi, SpawnExecutableActionObject as yn, createActor as yr, ExecutableActionObjectFromLogic as yt, AnyTransitionDefinition as z, StopExecutableActionObject as zn, ActorInspectionEvent as zr, MachineSourcesFrom as zt };