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

package/dist/index-CKUyiMZC.d.ts

@@ -0,0 +1,1832 @@
+import "./index-DDWoKIF5.js";
+import { $r as DelayMapFromNames, Ar as ActorSystemRuntime, Br as InspectionEvent, C as AnyActor, Ci as ValidateStateTargets, D as AnyEventObject, Di as createdInvokeConfig, Ei as WithDefault, Er as LogicFunction, F as AnyStateNode, Fn as StateValue, G as Cast, Hn as Subscription, Jr as MachineSnapshotSchema, Jt as OutputFrom, K as Compute, Kt as Observer, Ln as StateValueFromStateSchema, M as AnyMachineSnapshot, Mn as StateSchema, Mr as Clock, Oi as MachineSnapshot, Ot as InputFrom, P as AnyStateMachine, Qr as DelayDurationKey, Si as ValidateHistoryDefaults, Sr as AsyncSnapshot, T as AnyActorRef, Ti as WidenLiterals, U as CallbackActors, Un as SystemRegistry, Ur as ActorLogicValidator, Ut as MetaObject, Wt as NonReducibleUnknown, Y as ContextFrom, Yn as ToChildren, Yr as MachineVersionDescriptor, Zr as ChildCompletionEvents, _i as SchemaOrConfigOutput, _n as SnapshotFrom, _r as RequiredActorOptionsFor, ai as InferGuards, at as DoneStateEvent, bi as ValidateDelayReferences, bn as SpecialExecutableAction, br as AsyncActorLogic, bt as ExtractEvent, ci as InvokeInputArgs, ct as EnqueueObject, di as Next_InvokeConfigBase, dt as ErrorEvent, ei as DelaySourceMap, en as PersistedSnapshotFrom, f as ActorRefFromLogic, fi as Next_MachineConfig, ft as ErrorFrom, gi as OutputFromConfig, gn as SnapshotEvent, gr as Actor, gt as EventFromLogic, hi as Next_TransitionConfigOrTarget, hn as Snapshot, ht as EventFrom, ii as InferChildren, it as DoneActorEvent, jr as AnyActorSystem, l as ActorOptions, mi as Next_StateNodeConfig, mn as SingleOrArray, mt as EventDescriptor, ni as GuardSourceMap, oi as InferMachineInput, on as RegistryKeyForLogic, qn as TimeoutEvent, qr as MachineEventSchema, qt as OutputArg, ri as InferActions, rn as ProvidedActor, rt as DoNotInfer, si as InferOutput, ti as FinalStateConfigOutput, ui as Next_InvokeConfig, un as RoutableStateId, ur as StateMachine, ut as ErrorActorEvent, v as ActorTermination, vi as Sources, vr as RequiredActorOptionsKeys, vt as ExecutableActionObject, w as AnyActorLogic, wi as ValidateTopLevelFinalOutputs, x as AfterEvent, xi as ValidateEventDescriptors, y as ActorTimeoutEvent, yi as ValidateDelayNames, yt as ExecutableActionObjectFromLogic, z as AnyTransitionDefinition } from "./types-B2EAwOk-.js";
+import { a as InferInternalEvents, c as SetupStateSchema, d as SetupStateSchemas, f as StandardSchemaV1, i as InferEvents, l as SetupStateType, n as EventObject, o as MachineContext, r as GuardSchemas, s as SetupSchemas, t as ActionSchemas } from "./base.types-DF8ZPiXj.js";
+import "./effectDescriptor-EvNuy6U3.js";
+/**
+ * Asserts that an event is of the given type or types, narrowing it, and
+ * throws when it is not. Given only the types, returns the assertion as a
+ * function.
+ * @public
+ */
+declare function assertEvent<TEvent extends EventObject, TAssertedDescriptor extends EventDescriptor<TEvent>>(event: TEvent, type: TAssertedDescriptor | readonly TAssertedDescriptor[]): asserts event is ExtractEvent<TEvent, TAssertedDescriptor>;
+declare function assertEvent<TEvent extends EventObject, TAssertedDescriptor extends EventDescriptor<TEvent>>(type: TAssertedDescriptor | readonly TAssertedDescriptor[]): (event: TEvent) => asserts event is ExtractEvent<TEvent, TAssertedDescriptor>;
+type MergeChildren<TChildren extends Record<string, AnyActorRef | undefined>, TActor extends ProvidedActor> = [keyof TChildren] extends [never] ? Compute<ToChildren<TActor>> : Compute<TChildren>;
+type MachineIdentity<TConfig> = {
+  readonly id: TConfig extends {
+    id: infer TId extends string;
+  } ? TId : '(machine)';
+  readonly version: TConfig extends {
+    version: infer TVersion extends string;
+  } ? TVersion : undefined;
+};
+type TransitionMetaFromSchemas<TMetaSchema extends StandardSchemaV1, TTransitionMetaSchema extends StandardSchemaV1> = StandardSchemaV1 extends TTransitionMetaSchema ? InferOutput<TMetaSchema, MetaObject> : InferOutput<TTransitionMetaSchema, MetaObject>;
+/**
+ * Creates a state machine (statechart) with the given configuration.
+ *
+ * The state machine represents the pure logic of a state machine actor.
+ *
+ * @example
+ *
+ * ```ts
+ * import { createMachine } from '@systemfsoftware/xstate';
+ *
+ * const lightMachine = createMachine({
+ *   id: 'light',
+ *   initial: 'green',
+ *   states: {
+ *     green: {
+ *       on: {
+ *         TIMER: { target: 'yellow' }
+ *       }
+ *     },
+ *     yellow: {
+ *       on: {
+ *         TIMER: { target: 'red' }
+ *       }
+ *     },
+ *     red: {
+ *       on: {
+ *         TIMER: { target: 'green' }
+ *       }
+ *     }
+ *   }
+ * });
+ *
+ * const lightActor = createActor(lightMachine);
+ * lightActor.start();
+ *
+ * lightActor.send({ type: 'TIMER' });
+ * ```
+ *
+ * @param config The state machine configuration.
+ * @param options DEPRECATED: use `setup({ ... })` or `machine.provide({ ... })`
+ *   to provide machine sources instead.
+ * @public
+ */
+declare function createMachine<TContextSchema extends StandardSchemaV1, const TEventSchemaMap extends Record<string, StandardSchemaV1>, const TInternalEventSchemaMap extends Record<string, StandardSchemaV1>, TEmittedSchemaMap extends Record<string, StandardSchemaV1>, TInputSchema extends StandardSchemaV1, const TOutputSchema extends StandardSchemaV1, TMetaSchema extends StandardSchemaV1, TTransitionMetaSchema extends StandardSchemaV1, TTagSchema extends StandardSchemaV1, const TChildrenSchemaMap extends Record<string, StandardSchemaV1>, _TEvent extends EventObject, TActor extends ProvidedActor, TActionMap extends Sources['actions'], TActorMap extends Sources['actors'], TGuardMap extends Sources['guards'], TDelayMap extends Sources['delays'], TDelays extends string, TTag extends StandardSchemaV1.InferOutput<TTagSchema> & string, _TInput, const TSS extends StateSchema>(config: TSS & ValidateDelayReferences<TSS> & ValidateHistoryDefaults<TSS> & ValidateStateTargets<TSS> & ValidateEventDescriptors<TSS, NoInfer<InferEvents<TEventSchemaMap> | InferInternalEvents<TInternalEventSchemaMap>>> & Next_MachineConfig<TContextSchema, TEventSchemaMap, TInternalEventSchemaMap, TEmittedSchemaMap, TInputSchema, TOutputSchema, TMetaSchema, TTransitionMetaSchema, TTagSchema, TChildrenSchemaMap, InferOutput<TContextSchema, MachineContext>, InferEvents<TEventSchemaMap> | InferInternalEvents<TInternalEventSchemaMap> | ChildCompletionEvents<Cast<MergeChildren<InferChildren<TChildrenSchemaMap>, TActor>, Record<string, AnyActorRef | undefined>>>, Cast<MergeChildren<InferChildren<TChildrenSchemaMap>, TActor>, Record<string, AnyActorRef | undefined>>, TDelays, TTag, TActionMap, TActorMap, TGuardMap, TDelayMap> & {
+  schemas: {
+    context: TContextSchema;
+    children?: TChildrenSchemaMap;
+  };
+} & ValidateTopLevelFinalOutputs<TSS, InferOutput<TContextSchema, MachineContext>, InferEvents<TEventSchemaMap> | InferInternalEvents<TInternalEventSchemaMap>>): [TSS] extends [never] ? AnyStateMachine : StateMachine<InferOutput<TContextSchema, MachineContext>, (InferEvents<TEventSchemaMap> | InferInternalEvents<TInternalEventSchemaMap>) | ([RoutableStateId<TSS>] extends [never] ? never : {
+  type: 'xstate.route';
+  to: RoutableStateId<TSS>;
+}), Cast<MergeChildren<InferChildren<TChildrenSchemaMap>, TActor>, Record<string, AnyActorRef | undefined>>, StateValueFromStateSchema<TSS>, TTag & string, InferMachineInput<TInputSchema>, SchemaOrConfigOutput<TOutputSchema, TSS>, WithDefault<InferEvents<TEmittedSchemaMap>, AnyEventObject>, InferOutput<TMetaSchema, MetaObject>, // TMeta
+  TSS, // TStateSchema
+  TActionMap, TActorMap, TGuardMap, DelayMapFromNames<TDelays, TDelayMap>, InferInternalEvents<TInternalEventSchemaMap>, TransitionMetaFromSchemas<TMetaSchema, TTransitionMetaSchema>> & {
+  states: TSS;
+} & MachineIdentity<TSS>;
+declare function createMachine<TContext extends MachineContext = never, const TEventSchemaMap extends Record<string, StandardSchemaV1> = Record<string, StandardSchemaV1>, TEmittedSchemaMap extends Record<string, StandardSchemaV1> = Record<string, StandardSchemaV1>, TInputSchema extends StandardSchemaV1 = StandardSchemaV1, const TOutputSchema extends StandardSchemaV1 = StandardSchemaV1, TMetaSchema extends StandardSchemaV1 = StandardSchemaV1, TTransitionMetaSchema extends StandardSchemaV1 = TMetaSchema, TTagSchema extends StandardSchemaV1 = StandardSchemaV1, const TChildrenSchemaMap extends Record<string, StandardSchemaV1> = Record<string, StandardSchemaV1>, const TInternalEventSchemaMap extends Record<string, StandardSchemaV1> = {}, _TEvent extends EventObject = EventObject, TActor extends ProvidedActor = ProvidedActor, TActionMap extends Sources['actions'] = Sources['actions'], TActorMap extends Sources['actors'] = Sources['actors'], TGuardMap extends Sources['guards'] = Sources['guards'], TDelayMap extends Sources['delays'] = Sources['delays'], TDelays extends string = string, TTag extends StandardSchemaV1.InferOutput<TTagSchema> & string = StandardSchemaV1.InferOutput<TTagSchema> & string, _TInput = unknown, const TSS extends StateSchema = StateSchema>(config: TSS & ValidateDelayReferences<TSS> & ValidateHistoryDefaults<TSS> & ValidateStateTargets<TSS> & ValidateEventDescriptors<TSS, NoInfer<InferEvents<TEventSchemaMap> | InferInternalEvents<TInternalEventSchemaMap>>> & Next_MachineConfig<StandardSchemaV1, TEventSchemaMap, TInternalEventSchemaMap, TEmittedSchemaMap, TInputSchema, TOutputSchema, TMetaSchema, TTransitionMetaSchema, TTagSchema, TChildrenSchemaMap, WidenLiterals<TContext>, InferEvents<TEventSchemaMap> | InferInternalEvents<TInternalEventSchemaMap> | ChildCompletionEvents<Cast<MergeChildren<InferChildren<TChildrenSchemaMap>, TActor>, Record<string, AnyActorRef | undefined>>>, Cast<MergeChildren<InferChildren<TChildrenSchemaMap>, TActor>, Record<string, AnyActorRef | undefined>>, TDelays, TTag, TActionMap, TActorMap, TGuardMap, TDelayMap, false> & {
+  schemas?: {
+    context?: never;
+  };
+  context?: TContext | ((_: {
+    spawn: any;
+    actors: TActorMap;
+    input: InferOutput<TInputSchema, unknown>;
+    self: any;
+  }) => TContext);
+} & ValidateTopLevelFinalOutputs<TSS, WidenLiterals<TContext>, InferEvents<TEventSchemaMap> | InferInternalEvents<TInternalEventSchemaMap>>): [TSS] extends [never] ? AnyStateMachine : StateMachine<WidenLiterals<TContext>, (InferEvents<TEventSchemaMap> | InferInternalEvents<TInternalEventSchemaMap>) | ([RoutableStateId<TSS>] extends [never] ? never : {
+  type: 'xstate.route';
+  to: RoutableStateId<TSS>;
+}), Cast<MergeChildren<InferChildren<TChildrenSchemaMap>, TActor>, Record<string, AnyActorRef | undefined>>, StateValueFromStateSchema<TSS>, TTag & string, InferMachineInput<TInputSchema>, SchemaOrConfigOutput<TOutputSchema, TSS>, WithDefault<InferEvents<TEmittedSchemaMap>, AnyEventObject>, InferOutput<TMetaSchema, MetaObject>, // TMeta
+  TSS, // TStateSchema
+  TActionMap, TActorMap, TGuardMap, DelayMapFromNames<TDelays, TDelayMap>, InferInternalEvents<TInternalEventSchemaMap>, TransitionMetaFromSchemas<TMetaSchema, TTransitionMetaSchema>> & {
+  states: TSS;
+} & MachineIdentity<TSS>;
+/**
+ * Builds a machine from a config produced by a compiler (JSON, SCXML) without
+ * running the author-config v5 diagnostics.
+ *
+ * @experimental Used by `@xstate/scxml`; not part of the stable API.
+ */
+declare function createMachineFromCompiledConfig(config: any): any;
+/** @public */
+declare function createStateConfig<TContextSchema extends StandardSchemaV1, TEventSchema extends StandardSchemaV1, TEmittedSchema extends StandardSchemaV1, _TInputSchema extends StandardSchemaV1, const TOutputSchema extends StandardSchemaV1, TMetaSchema extends StandardSchemaV1, TTransitionMetaSchema extends StandardSchemaV1, TTagSchema extends StandardSchemaV1, _TEvent extends StandardSchemaV1.InferOutput<TEventSchema> & EventObject, // TODO: consider using a stricter `EventObject` here
+  _TActor extends ProvidedActor, TActionMap extends Sources['actions'], TActorMap extends Sources['actors'], TGuardMap extends Sources['guards'], TDelayMap extends Sources['delays'], TDelays extends string, _TTag extends StandardSchemaV1.InferOutput<TTagSchema> & string, _TInput, const TSS extends StateSchema>(config: TSS & Next_StateNodeConfig<InferOutput<TContextSchema, MachineContext>, DoNotInfer<StandardSchemaV1.InferOutput<TEventSchema> & EventObject>, DoNotInfer<TDelays>, DoNotInfer<StandardSchemaV1.InferOutput<TTagSchema> & string>, DoNotInfer<StandardSchemaV1.InferOutput<TOutputSchema>>, DoNotInfer<StandardSchemaV1.InferOutput<TEmittedSchema> & EventObject>, DoNotInfer<InferOutput<TMetaSchema, MetaObject>>, DoNotInfer<Record<string, AnyActorRef | undefined>>, DoNotInfer<TActionMap>, DoNotInfer<TActorMap>, DoNotInfer<TGuardMap>, DoNotInfer<TDelayMap>, any, any, any, any, DoNotInfer<TransitionMetaFromSchemas<TMetaSchema, TTransitionMetaSchema>>>): typeof config;
+interface RaiseJSON {
+  type: '@xstate.raise';
+  event: EventObject;
+  id?: string;
+  delay?: number;
+}
+interface CancelJSON {
+  type: '@xstate.cancel';
+  id: string;
+}
+interface LogJSON {
+  type: '@xstate.log';
+  args: any[];
+}
+interface EmitJSON {
+  type: '@xstate.emit';
+  event: AnyEventObject;
+}
+interface AssignJSON {
+  type: '@xstate.assign';
+  context: MachineContext;
+}
+type BuiltInActionJSON = RaiseJSON | CancelJSON | LogJSON | EmitJSON | AssignJSON;
+interface CustomActionJSON {
+  type: string;
+  params?: unknown;
+}
+/** @public */
+type ActionJSON = CustomActionJSON | BuiltInActionJSON | ExpressionJSON | CodeJSON;
+/** @public */
+interface GuardJSON {
+  type: string;
+  params?: unknown;
+}
+interface ExpressionJSON {
+  '@expr': string;
+  '@lang'?: string;
+}
+interface CodeJSON {
+  '@code': string;
+  '@lang'?: string;
+}
+type ResolvableJSON = ExpressionJSON | CodeJSON;
+type ConditionJSON = GuardJSON | ResolvableJSON;
+interface ChoiceBranchJSON {
+  when?: ConditionJSON;
+  target: string | string[];
+  context?: MachineContext;
+  input?: unknown;
+  description?: string;
+  reenter?: boolean;
+  meta?: MetaObject;
+}
+/** @public */
+interface InvokeJSON {
+  id?: string;
+  registryKey?: string;
+  src: string;
+  input?: unknown;
+  onDone?: TransitionConfigJSON | TransitionConfigJSON[];
+  onError?: TransitionConfigJSON | TransitionConfigJSON[];
+  onSnapshot?: TransitionConfigJSON | TransitionConfigJSON[];
+  timeout?: number | string | ResolvableJSON;
+  onTimeout?: TransitionConfigJSON | TransitionConfigJSON[];
+}
+/** @public */
+interface TransitionJSON {
+  target?: string | string[];
+  matches?: Record<string, unknown>;
+  context?: MachineContext;
+  actions?: ActionJSON[];
+  guard?: ConditionJSON;
+  description?: string;
+  reenter?: boolean;
+  meta?: MetaObject;
+  input?: unknown;
+}
+type TransitionConfigJSON = TransitionJSON | ResolvableJSON;
+/** @public */
+interface StateNodeJSON {
+  id?: string;
+  key?: string;
+  type?: 'atomic' | 'compound' | 'parallel' | 'final' | 'history' | 'choice';
+  initial?: string;
+  states?: Record<string, StateNodeJSON>;
+  on?: Record<string, TransitionConfigJSON | TransitionConfigJSON[]>;
+  onError?: TransitionConfigJSON | TransitionConfigJSON[];
+  after?: Record<string, TransitionConfigJSON | TransitionConfigJSON[]>;
+  always?: TransitionConfigJSON | TransitionConfigJSON[];
+  choice?: ChoiceBranchJSON[] | ResolvableJSON;
+  route?: {
+    description?: string;
+    reenter?: boolean;
+    meta?: MetaObject;
+    guard?: string;
+    input?: Record<string, unknown>;
+  } | ResolvableJSON;
+  invoke?: InvokeJSON | InvokeJSON[];
+  entry?: ActionJSON | ActionJSON[];
+  exit?: ActionJSON | ActionJSON[];
+  meta?: MetaObject;
+  description?: string;
+  tags?: string[];
+  input?: unknown;
+  timeout?: number | string | ResolvableJSON;
+  onTimeout?: TransitionConfigJSON | TransitionConfigJSON[];
+  history?: 'shallow' | 'deep';
+  target?: string | [string, ...string[]];
+  output?: unknown;
+  context?: Record<string, unknown>;
+}
+/** @public */
+interface MachineJSON extends StateNodeJSON {
+  '@exprLang'?: string;
+  version?: string;
+  actions?: Record<string, ActionJSON | ActionJSON[]>;
+  guards?: Record<string, {
+    when: ConditionJSON;
+  }>;
+  actors?: Record<string, unknown>;
+  delays?: Record<string, number | string | {
+    duration: number | string | ResolvableJSON;
+  }>;
+  schemas?: Record<string, unknown>;
+  /**
+   * Event types that only the machine itself (and its children) may send;
+   * external senders are rejected with reason `internalEvent`.
+   */
+  internalEvents?: string[];
+}
+type EvaluatorSlot = 'context' | 'guard' | 'choice' | 'action' | 'actionParams' | 'transition' | 'input' | 'output' | 'delay' | 'transitionContext' | 'unknown';
+type EvaluatorKind = 'expr' | 'code';
+interface EvaluatorArgs {
+  source: string;
+  kind: EvaluatorKind;
+  slot: EvaluatorSlot;
+  scope: Record<string, unknown>;
+  path: string;
+}
+interface MachineSources {
+  actions?: Record<string, (...args: any[]) => unknown>;
+  guards?: Record<string, (...args: any[]) => boolean>;
+  actors?: Record<string, AnyActorLogic>;
+  delays?: Record<string, number | ((...args: any[]) => number)>;
+  evaluators?: Record<string, (args: EvaluatorArgs) => unknown>;
+}
+/** @public */
+declare function createMachineFromConfig(json: MachineJSON, sources?: MachineSources): AnyStateMachine;
+type VersionedStateMachine = AnyStateMachine & {
+  version: string;
+  snapshotSchema: MachineSnapshotSchema;
+  eventSchema: MachineEventSchema;
+};
+type VersionEntry = MachineVersionDescriptor;
+/** @public */
+type PersistedSnapshotDataFrom<TMachine extends AnyStateMachine> = Snapshot<unknown> & {
+  context: ContextFrom<TMachine>;
+  [key: string]: unknown;
+};
+/** @public */
+type ParsedPersistedSnapshot<TEntries extends readonly VersionEntry[]> = { [K in keyof TEntries]: TEntries[K] extends VersionEntry ? TEntries[K] extends VersionedStateMachine ? {
+  source: TEntries[K];
+  machine: TEntries[K];
+  snapshot: PersistedSnapshotFromEntry<TEntries[K]>;
+} : {
+  source: TEntries[K];
+  snapshot: PersistedSnapshotFromEntry<TEntries[K]>;
+} : never; }[number];
+/** @public */
+type MachineVersionsOptions<TEntries extends readonly VersionEntry[]> = {
+  unversioned?: SnapshotSourceVersion<TEntries>;
+};
+type MaybePromise<T> = T | PromiseLike<T>;
+type MachineVersion<TEntries extends readonly VersionEntry[]> = Extract<TEntries[number], VersionedStateMachine>['version'];
+type SnapshotSourceVersion<TEntries extends readonly VersionEntry[]> = { [K in keyof TEntries]: TEntries[K] extends VersionedStateMachine | {
+  snapshotSchema: MachineSnapshotSchema;
+} ? TEntries[K]['version'] : never; }[number];
+type EventSourceVersion<TEntries extends readonly VersionEntry[]> = { [K in keyof TEntries]: TEntries[K] extends VersionedStateMachine | {
+  eventSchema: MachineEventSchema;
+} ? TEntries[K]['version'] : never; }[number];
+type MachineForVersion<TEntries extends readonly VersionEntry[], TVersion extends string> = { [K in keyof TEntries]: TEntries[K] extends VersionedStateMachine ? TEntries[K]['version'] extends TVersion ? TEntries[K] : never : never; }[number];
+type SnapshotEntryForVersion<TEntries extends readonly VersionEntry[], TVersion extends string> = { [K in keyof TEntries]: TEntries[K] extends VersionedStateMachine | {
+  snapshotSchema: MachineSnapshotSchema;
+} ? TEntries[K]['version'] extends TVersion ? TEntries[K] : never : never; }[number];
+type EventEntryForVersion<TEntries extends readonly VersionEntry[], TVersion extends string> = { [K in keyof TEntries]: TEntries[K] extends VersionedStateMachine | {
+  eventSchema: MachineEventSchema;
+} ? TEntries[K]['version'] extends TVersion ? TEntries[K] : never : never; }[number];
+type PersistedSnapshotFromEntry<TEntry extends VersionEntry> = TEntry extends {
+  snapshotSchema: infer TSchema extends MachineSnapshotSchema;
+} ? StandardSchemaV1.InferOutput<TSchema> : TEntry extends VersionedStateMachine ? PersistedSnapshotFrom<TEntry> : never;
+type EventFromEntry<TEntry extends VersionEntry> = TEntry extends {
+  eventSchema: infer TSchema extends MachineEventSchema;
+} ? StandardSchemaV1.InferOutput<TSchema> : TEntry extends VersionedStateMachine ? EventFrom<TEntry> : never;
+/** @public */
+type PersistedSnapshotSource = {
+  id?: string | undefined;
+  version?: string | undefined;
+};
+/** @public */
+type SnapshotMigrationHandlers<TEntries extends readonly VersionEntry[], TTarget extends VersionedStateMachine> = { [TVersion in Exclude<SnapshotSourceVersion<TEntries>, TTarget['version']>]?: (snapshot: PersistedSnapshotFromEntry<SnapshotEntryForVersion<TEntries, TVersion>>) => MaybePromise<PersistedSnapshotDataFrom<TTarget>>; } & {
+  '*'?: (snapshot: unknown, source: PersistedSnapshotSource) => MaybePromise<PersistedSnapshotDataFrom<TTarget>>;
+};
+/** @public */
+type MigrateSnapshotOptions<TEntries extends readonly VersionEntry[], TTargetVersion extends MachineVersion<TEntries>> = {
+  to: TTargetVersion;
+  migrations: SnapshotMigrationHandlers<TEntries, MachineForVersion<TEntries, TTargetVersion>>;
+};
+/** @public */
+type EventHistorySource = {
+  id?: string;
+  version?: string;
+};
+/** @public */
+type EventAdapterHandlers<TEntries extends readonly VersionEntry[], TTarget extends VersionedStateMachine> = { [TVersion in Exclude<EventSourceVersion<TEntries>, TTarget['version']>]?: (events: readonly EventFromEntry<EventEntryForVersion<TEntries, TVersion>>[]) => MaybePromise<readonly EventFrom<TTarget>[]>; } & {
+  '*'?: (events: readonly unknown[], source: EventHistorySource) => MaybePromise<readonly EventFrom<TTarget>[]>;
+};
+/** @public */
+type AdaptEventsOptions<TEntries extends readonly VersionEntry[], TTargetVersion extends MachineVersion<TEntries>> = {
+  from: EventHistorySource;
+  to: TTargetVersion;
+  adapters: EventAdapterHandlers<TEntries, MachineForVersion<TEntries, TTargetVersion>>;
+};
+/**
+ * Creates migration and adaptation utilities for versions of one machine.
+ *
+ * @public
+ */
+declare function machineVersions<const TEntries extends readonly [VersionEntry, ...VersionEntry[]]>(entries: TEntries, options?: MachineVersionsOptions<TEntries>): {
+  parseSnapshot: (raw: unknown) => Promise<ParsedPersistedSnapshot<TEntries>>;
+  adaptEvents<TTargetVersion extends MachineVersion<TEntries>>(events: readonly unknown[], adaptationOptions: AdaptEventsOptions<TEntries, TTargetVersion>): Promise<EventFrom<MachineForVersion<TEntries, TTargetVersion>>[]>;
+  migrateSnapshot<TTargetVersion extends MachineVersion<TEntries>>(raw: unknown, migrationOptions: MigrateSnapshotOptions<TEntries, TTargetVersion>): Promise<PersistedSnapshotFrom<MachineForVersion<TEntries, TTargetVersion>>>;
+};
+type StateSchemaFromSnapshot<TSnapshot extends AnyMachineSnapshot> = TSnapshot extends MachineSnapshot<infer _TContext, infer _TEvent, infer _TChildren, infer _TStateValue, infer _TTag, infer _TOutput, infer _TMeta, infer TStateSchema extends StateSchema> ? TStateSchema : StateSchema;
+/**
+ * A mapper object that defines how to transform a snapshot based on its state.
+ * Can be nested to match the state hierarchy of the machine.
+ */
+type StateSchemaMapper<TSnapshot extends AnyMachineSnapshot, T extends StateSchema, TResult> = {
+  /** Maps the snapshot to a value when this state is active. */
+  map?: (snapshot: TSnapshot) => TResult;
+  /** Nested mappers for child states. */
+  states?: { [K in keyof T['states']]?: T['states'][K] extends StateSchema ? StateSchemaMapper<TSnapshot, T['states'][K], TResult> : never; };
+};
+/**
+ * Maps a machine snapshot to an array of result objects based on active states.
+ *
+ * Collects results from the `map` functions in the mapper object for every
+ * active state node. Each state comes before its ancestors (most specific
+ * state first); otherwise results follow the order the states are declared in
+ * the machine. Called with the mapper alone, it returns a function that takes
+ * the snapshot.
+ *
+ * @public
+ */
+declare function mapState<T extends AnyMachineSnapshot, TResult>(mapper: StateSchemaMapper<T, StateSchemaFromSnapshot<T>, TResult>): (snapshot: T) => {
+  stateNode: AnyStateNode;
+  result: TResult;
+}[];
+declare function mapState<T extends AnyMachineSnapshot, TResult>(snapshot: T, mapper: StateSchemaMapper<T, StateSchemaFromSnapshot<T>, TResult>): {
+  stateNode: AnyStateNode;
+  result: TResult;
+}[];
+/** @public */
+interface CodeExpression {
+  '@code': string;
+  '@lang': 'ts';
+}
+/**
+ * Returns the JSON-serializable definition of a machine.
+ *
+ * Inline functions are represented as `{ "@code": string, "@lang": "ts" }`. A
+ * machine created via `createMachineFromConfig` returns its original JSON
+ * config (lossless round-trip):
+ *
+ * ```ts
+ * import { serializeMachine, createMachineFromConfig } from '@systemfsoftware/xstate';
+ *
+ * const json = serializeMachine(machine);
+ * const revived = createMachineFromConfig(
+ *   JSON.parse(JSON.stringify(json))
+ * );
+ * ```
+ *
+ * @public
+ */
+declare function serializeMachine(machine: AnyStateMachine): Record<string, unknown>;
+/**
+ * Converts a machine config (as passed to `createMachine`) to its JSON-safe
+ * definition.
+ *
+ * @public
+ */
+declare function machineConfigToJSON(config: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Switches a running machine actor to another version of its machine, for
+ * development hot reloading. The live snapshot is carried over in memory and
+ * never serialized, so context may hold values that `getPersistedSnapshot()`
+ * cannot represent (DOM nodes, cycles).
+ *
+ * Children whose logic is unchanged by identity keep running; other children
+ * are stopped and restarted from the new machine's logic. Returns `false`,
+ * leaving the actor unchanged, when the actor is not a running machine actor
+ * with the same machine id, a state or history id does not exist on the new
+ * machine, a child's logic cannot be resolved statically, context or a pending
+ * timer references a child that would restart, or the new machine's validator
+ * rejects the snapshot.
+ *
+ * @experimental Used by framework integrations; not part of the stable API.
+ */
+declare function hotSwapActorLogic(actorRef: AnyActorRef, machine: AnyStateMachine): boolean;
+/** @public */
+type SetupConfig<TSchemas extends SetupSchemas, TStates extends Record<string, SetupStateSchema>, TActionMap extends Sources['actions'], TActorMap extends Sources['actors'], TGuardMap extends Sources['guards'], TDelayMap extends Sources['delays'], TValidator extends ActorLogicValidator | undefined = ActorLogicValidator | undefined> = {
+  validator?: TValidator;
+  schemas?: TSchemas;
+  states?: TStates;
+  actions?: TActionMap;
+  actors?: TActorMap;
+  guards?: TGuardMap & SetupGuardSources<NoInfer<TSchemas>>;
+  delays?: TDelayMap & SetupDelaySources<NoInfer<TSchemas>>;
+};
+/**
+ * Contextual types for guard/delay source maps passed to `setup()`, derived
+ * from the same call's `schemas` (context/events). These intersect the
+ * inferred source-map type parameters so inline functions get typed args
+ * without hand-annotating.
+ */
+type SetupGuardSources<TSchemas> = GuardSourceMap<SetupContext<TSchemas, StandardSchemaV1>, SetupEvents<TSchemas, Record<string, StandardSchemaV1>>>;
+type SetupDelaySources<TSchemas> = DelaySourceMap<SetupContext<TSchemas, StandardSchemaV1>, SetupEvents<TSchemas, Record<string, StandardSchemaV1>>>;
+/**
+ * Contextual companion for the whole-config `setup()` overload: gives inline
+ * `guards`/`delays` functions typed args from the config's own `schemas`.
+ */
+type SetupSourceCompanions<TSchemas> = {
+  guards?: SetupGuardSources<TSchemas>;
+  delays?: SetupDelaySources<TSchemas>;
+};
+type MergeRecord<TBase, TExtend> = Omit<TBase, keyof TExtend> & TExtend;
+/**
+ * Mirrors the runtime `mergeSchemas`: scalar schema keys (`context`, `input`,
+ * ...) are overridden whole, while map-valued keys (`events`, `emitted`,
+ * `children`, `actions`, `guards`) are merged entry-by-entry with extension
+ * entries winning, so base-declared entries stay visible to extension sources.
+ */
+type MergedSetupSchemas<TBaseSchemas, TExtendSchemas> = { [K in keyof TBaseSchemas | keyof TExtendSchemas]: K extends 'events' | 'emitted' | 'children' | 'actions' | 'guards' ? MergeRecord<K extends keyof TBaseSchemas ? NonNullable<TBaseSchemas[K]> : {}, K extends keyof TExtendSchemas ? NonNullable<TExtendSchemas[K]> : {}> : K extends keyof TExtendSchemas ? TExtendSchemas[K] : K extends keyof TBaseSchemas ? TBaseSchemas[K] : never; };
+/** @public */
+type AnySetupConfig = SetupConfig<SetupSchemas, Record<string, SetupStateSchema>, Sources['actions'], Sources['actors'], Sources['guards'], Sources['delays'], ActorLogicValidator | undefined>;
+interface RuntimeValidationDoesNotSupportTransformingSchemas {
+  readonly __xstate_error: 'Runtime validation does not support schemas with different input and output types';
+}
+type IsAny<T> = 0 extends 1 & T ? true : false;
+type AssertNonTransformingSchema<TSchema extends StandardSchemaV1> = IsAny<StandardSchemaV1.InferInput<TSchema>> extends true ? TSchema : IsAny<StandardSchemaV1.InferOutput<TSchema>> extends true ? TSchema : [StandardSchemaV1.InferInput<TSchema>, StandardSchemaV1.InferOutput<TSchema>] extends [StandardSchemaV1.InferOutput<TSchema>, StandardSchemaV1.InferInput<TSchema>] ? TSchema : RuntimeValidationDoesNotSupportTransformingSchemas;
+type ValidateSchemaMap<TMap> = TMap extends Record<string, StandardSchemaV1> ? { [K in keyof TMap]: TMap[K] extends StandardSchemaV1 ? AssertNonTransformingSchema<TMap[K]> : TMap[K]; } : TMap;
+type ValidateSetupSchemas<TSchemas> = TSchemas extends SetupSchemas ? { [K in keyof TSchemas]: K extends 'events' | 'internalEvents' | 'emitted' | 'children' ? ValidateSchemaMap<TSchemas[K]> : K extends 'context' | 'input' | 'output' ? TSchemas[K] extends StandardSchemaV1 ? AssertNonTransformingSchema<TSchemas[K]> : TSchemas[K] : TSchemas[K]; } : TSchemas;
+type ValidateSetupStates<TStates> = TStates extends Record<string, SetupStateSchema> ? { [K in keyof TStates]: TStates[K] extends SetupStateSchema ? Omit<TStates[K], 'schemas' | 'states'> & {
+  schemas?: TStates[K]['schemas'] extends SetupStateSchemas ? { [P in keyof TStates[K]['schemas']]: TStates[K]['schemas'][P] extends StandardSchemaV1 ? AssertNonTransformingSchema<TStates[K]['schemas'][P]> : TStates[K]['schemas'][P]; } : TStates[K]['schemas'];
+  states?: TStates[K]['states'] extends Record<string, SetupStateSchema> ? ValidateSetupStates<TStates[K]['states']> : TStates[K]['states'];
+} : TStates[K]; } : TStates;
+type RuntimeValidationConstraint<TSchemas, TStates, TValidator> = [TValidator] extends [ActorLogicValidator] ? {
+  schemas?: ValidateSetupSchemas<TSchemas>;
+  states?: ValidateSetupStates<TStates>;
+} : unknown;
+type RuntimeValidationCompatibility<TSchemas, TStates, TValidator> = [TValidator] extends [ActorLogicValidator] ? [TSchemas] extends [ValidateSetupSchemas<TSchemas>] ? [TStates] extends [ValidateSetupStates<TStates>] ? unknown : RuntimeValidationDoesNotSupportTransformingSchemas : RuntimeValidationDoesNotSupportTransformingSchemas : unknown;
+declare const inheritedValidator: unique symbol;
+type InheritedValidator = typeof inheritedValidator;
+type ResolveExtendedValidator<TBase, TExtension> = [TExtension] extends [InheritedValidator] ? TBase : Exclude<TExtension, InheritedValidator>;
+type ExtendValidatorConfig<TExtension> = [TExtension] extends [InheritedValidator] ? {
+  validator?: never;
+} : {
+  validator: TExtension;
+};
+type SetupExtensionConfig<TBaseSchemas, TBaseStates, TBaseValidator, TExtendSchemas extends SetupSchemas, TExtendStates extends Record<string, SetupStateSchema>, TExtendActionMap extends Sources['actions'], TExtendActorMap extends Sources['actors'], TExtendGuardMap extends Sources['guards'], TExtendDelayMap extends Sources['delays'], TExtendValidator extends ActorLogicValidator | undefined | InheritedValidator> = Omit<SetupConfig<TExtendSchemas, TExtendStates, TExtendActionMap, TExtendActorMap, TExtendGuardMap, TExtendDelayMap>, 'validator' | 'guards' | 'delays'> & {
+  guards?: TExtendGuardMap & SetupGuardSources<NoInfer<MergedSetupSchemas<TBaseSchemas, TExtendSchemas>>>;
+  delays?: TExtendDelayMap & SetupDelaySources<NoInfer<MergedSetupSchemas<TBaseSchemas, TExtendSchemas>>>;
+} & ExtendValidatorConfig<TExtendValidator> & RuntimeValidationCompatibility<NoInfer<TBaseSchemas>, NoInfer<TBaseStates>, ResolveExtendedValidator<TBaseValidator, TExtendValidator>> & RuntimeValidationConstraint<NoInfer<TExtendSchemas>, NoInfer<TExtendStates>, ResolveExtendedValidator<TBaseValidator, TExtendValidator>>;
+type InlineMachineSchemas<TContextSchema, TEventSchemaMap, TInternalEventSchemaMap, TEmittedSchemaMap, TActionSchemaMap, TGuardSchemaMap, TInputSchema, TOutputSchema, TMetaSchema, TTransitionMetaSchema, TTagSchema, TChildrenSchemaMap> = {
+  context?: TContextSchema;
+  events?: TEventSchemaMap;
+  internalEvents?: TInternalEventSchemaMap;
+  emitted?: TEmittedSchemaMap;
+  actions?: TActionSchemaMap;
+  guards?: TGuardSchemaMap;
+  input?: TInputSchema;
+  output?: TOutputSchema;
+  meta?: TMetaSchema;
+  transitionMeta?: TTransitionMetaSchema;
+  tags?: TTagSchema;
+  children?: TChildrenSchemaMap;
+};
+type MachineConfigStates<TConfig> = TConfig extends {
+  states?: infer TStates;
+} ? TStates : {};
+type MachineConfigSchemas<TConfig> = TConfig extends {
+  schemas?: infer TSchemas;
+} ? TSchemas : {};
+/** @public */
+type SystemConfig<TSystemRegistry extends SystemRegistry> = {
+  registry?: TSystemRegistry;
+};
+/** @public */
+type SystemActorMap<TSystemRegistry extends SystemRegistry> = { [K in keyof TSystemRegistry & string]: ActorRefFromLogic<TSystemRegistry[K]>; };
+type SetupMachineIdentity<TConfig> = {
+  readonly id: TConfig extends {
+    id: infer TId extends string;
+  } ? TId : '(machine)';
+  readonly version: TConfig extends {
+    version: infer TVersion extends string;
+  } ? TVersion : undefined;
+};
+/** @public */
+type SystemRuntime<TSystemRegistry extends SystemRegistry> = Omit<AnyActorSystem, 'get' | 'getAll'> & {
+  get<K extends keyof SystemActorMap<TSystemRegistry> & string>(key: K): SystemActorMap<TSystemRegistry>[K] | undefined;
+  getAll(): Partial<SystemActorMap<TSystemRegistry>>;
+};
+type LogicMatchesRegistryKey<TLogic, TSystemLogic> = TLogic extends AnyActorLogic ? TSystemLogic extends AnyActorLogic ? [TLogic] extends [TSystemLogic] ? true : [TSystemLogic] extends [TLogic] ? true : ActorRefFromLogic<TLogic> extends ActorRefFromLogic<TSystemLogic> ? true : false : false : false;
+type RegistryKeyMatchesSrc<TKey extends string, TSrc, TSystemRegistry extends SystemRegistry, TActorMap extends Sources['actors']> = TKey extends keyof TSystemRegistry & string ? TSrc extends keyof TActorMap & string ? LogicMatchesRegistryKey<TActorMap[TSrc], TSystemRegistry[TKey]> : TSrc extends AnyActorLogic ? LogicMatchesRegistryKey<TSrc, TSystemRegistry[TKey]> : true : false;
+type ValidateSystemInvoke<TInvoke, TSystemRegistry extends SystemRegistry, TActorMap extends Sources['actors']> = TInvoke extends readonly unknown[] ? { [K in keyof TInvoke]: TInvoke[K] & ValidateSystemInvoke<TInvoke[K], TSystemRegistry, TActorMap>; } : TInvoke extends {
+  registryKey: infer TKey;
+} ? TKey extends string ? TInvoke extends {
+  src: infer TSrc;
+} ? RegistryKeyMatchesSrc<TKey, TSrc, TSystemRegistry, TActorMap> extends true ? unknown : {
+  registryKey: never;
+} : TKey extends keyof TSystemRegistry & string ? unknown : {
+  registryKey: never;
+} : {
+  registryKey: never;
+} : unknown;
+type ValidateRegistryKeys<TConfig, TSystemRegistry extends SystemRegistry, TActorMap extends Sources['actors']> = string extends keyof TSystemRegistry ? unknown : (TConfig extends {
+  invoke: infer TInvoke;
+} ? {
+  invoke: TInvoke & ValidateSystemInvoke<TInvoke, TSystemRegistry, TActorMap>;
+} : unknown) & (TConfig extends {
+  states: infer TStates;
+} ? {
+  states: { [K in keyof TStates]: TStates[K] & ValidateRegistryKeys<TStates[K], TSystemRegistry, TActorMap>; };
+} : unknown);
+type SetupSchema<TSchemas, TKey extends keyof SetupSchemas> = TKey extends keyof TSchemas ? TSchemas[TKey] extends StandardSchemaV1 ? TSchemas[TKey] : never : never;
+type SetupSchemaMap<TSchemas, TKey extends 'events' | 'internalEvents' | 'emitted' | 'children'> = TKey extends keyof TSchemas ? TSchemas[TKey] extends Record<string, StandardSchemaV1> ? TSchemas[TKey] : never : never;
+type SetupActionSchemaMap<TSchemas> = 'actions' extends keyof TSchemas ? TSchemas['actions'] extends ActionSchemas ? TSchemas['actions'] : never : never;
+type SetupGuardSchemaMap<TSchemas> = 'guards' extends keyof TSchemas ? TSchemas['guards'] extends GuardSchemas ? TSchemas['guards'] : never : never;
+type SetupOrConfigSchema<TSchemas, TKey extends Exclude<keyof SetupSchemas, 'events' | 'actions' | 'guards' | 'emitted' | 'children'>, TConfigSchema extends StandardSchemaV1> = [SetupSchema<TSchemas, TKey>] extends [never] ? TConfigSchema : SetupSchema<TSchemas, TKey>;
+type SetupOrConfigSchemaMap<TSchemas, TKey extends 'events' | 'internalEvents' | 'emitted' | 'children', TConfigSchemaMap extends Record<string, StandardSchemaV1>> = [SetupSchemaMap<TSchemas, TKey>] extends [never] ? TConfigSchemaMap : SetupSchemaMap<TSchemas, TKey>;
+type SetupStateKeys<TStateSchemas extends Record<string, SetupStateSchema>> = keyof TStateSchemas & string;
+type HasExplicitSetupStateContracts<TStateSchemas extends Record<string, SetupStateSchema>> = string extends keyof TStateSchemas ? false : [keyof TStateSchemas] extends [never] ? false : true;
+type UncheckedSetupStateSchema = {
+  schemas?: never;
+  states?: never;
+};
+type UncheckedSetupStateSchemas = Record<string, UncheckedSetupStateSchema>;
+type SetupStateKey<TStateSchemas extends Record<string, SetupStateSchema>> = string extends SetupStateKeys<TStateSchemas> ? string : [SetupStateKeys<TStateSchemas>] extends [never] ? string : SetupStateKeys<TStateSchemas>;
+type StrictSetupStatePaths<TStateSchemas extends Record<string, SetupStateSchema>> = [SetupStateKeys<TStateSchemas>] extends [never] ? never : StatePaths<TStateSchemas>;
+type SetupRelativeStateTarget<TStateSchemas extends Record<string, SetupStateSchema>> = string extends SetupStateKeys<TStateSchemas> ? `.${string}` : [SetupStateKeys<TStateSchemas>] extends [never] ? '.' : '.' | `.${StatePaths<TStateSchemas> & string}`;
+type SetupStateTarget<TStateSchemas extends Record<string, SetupStateSchema>> = TStateSchemas extends StrictSetupStateTargetsFlag ? StrictSetupStatePaths<TStateSchemas> | SetupRelativeStateTarget<RelativeSetupStateSchemas<TStateSchemas>> | `#${string}` : string extends SetupStateKeys<TStateSchemas> ? string : [SetupStateKeys<TStateSchemas>] extends [never] ? string : StatePaths<TStateSchemas> | `.${string}` | `#${string}`;
+type KnownSetupStateTarget<TStateSchemas extends Record<string, SetupStateSchema>> = string extends StatePaths<TStateSchemas> ? string extends StatePaths<RelativeSetupStateSchemas<TStateSchemas>> ? never : SetupRelativeStateTarget<RelativeSetupStateSchemas<TStateSchemas>> | RootSetupStateIdTarget<RootSetupStateSchemas<TStateSchemas>> : (StrictSetupStatePaths<TStateSchemas> & string) | SetupRelativeStateTarget<RelativeSetupStateSchemas<TStateSchemas>> | RootSetupStateIdTarget<RootSetupStateSchemas<TStateSchemas>>;
+declare const strictSetupStateTargets: unique symbol;
+declare const relativeSetupStateSchemas: unique symbol;
+declare const rootSetupStateSchemas: unique symbol;
+declare const currentSetupStateSchema: unique symbol;
+declare const parentSetupStateType: unique symbol;
+/** @public Referenced by emitted declarations of strict transition targets. */
+type StrictSetupStateTargetsFlag = {
+  readonly [strictSetupStateTargets]: true;
+};
+/** @public Referenced by emitted declarations of strict transition targets. */
+type RelativeSetupStateSchemasMarker<TRelativeStateSchemas extends Record<string, SetupStateSchema>> = {
+  readonly [relativeSetupStateSchemas]: TRelativeStateSchemas;
+};
+/** @public Referenced by emitted declarations of strict transition targets. */
+type CurrentSetupStateSchemaMarker<TCurrentStateSchema extends SetupStateSchema> = {
+  readonly [currentSetupStateSchema]: TCurrentStateSchema;
+};
+/** @public Referenced by emitted declarations of strict transition targets. */
+type StrictSetupStateTargetsMarker<TRelativeStateSchemas extends Record<string, SetupStateSchema>, TRootStateSchemas extends Record<string, SetupStateSchema>, TCurrentStateSchema extends SetupStateSchema> = StrictSetupStateTargetsFlag & RelativeSetupStateSchemasMarker<TRelativeStateSchemas> & RootSetupStateSchemasMarker<TRootStateSchemas> & CurrentSetupStateSchemaMarker<TCurrentStateSchema>;
+/** @public Referenced by emitted declarations of strict transition targets. */
+type StrictSetupStateSchemas<TStateSchemas extends Record<string, SetupStateSchema>, TRelativeStateSchemas extends Record<string, SetupStateSchema> = Record<string, SetupStateSchema>, TRootStateSchemas extends Record<string, SetupStateSchema> = RootSetupStateSchemas<TStateSchemas>, TCurrentStateSchema extends SetupStateSchema = never> = TStateSchemas & StrictSetupStateTargetsMarker<TRelativeStateSchemas, TRootStateSchemas, TCurrentStateSchema>;
+type RelativeSetupStateSchemas<TStateSchemas extends Record<string, SetupStateSchema>> = TStateSchemas extends RelativeSetupStateSchemasMarker<infer TRelativeStateSchemas> ? TRelativeStateSchemas : TStateSchemas;
+type RootSetupStateSchemas<TStateSchemas extends Record<string, SetupStateSchema>> = TStateSchemas extends RootSetupStateSchemasMarker<infer TRootStateSchemas> ? TRootStateSchemas : TStateSchemas;
+type CurrentSetupStateSchema<TStateSchemas extends Record<string, SetupStateSchema>> = TStateSchemas extends CurrentSetupStateSchemaMarker<infer TCurrentStateSchema> ? TCurrentStateSchema : never;
+type SetupStateSelfSchema<TStateSchema extends SetupStateSchema> = TStateSchema extends {
+  schemas: infer TSchemas extends SetupStateSchemas;
+} ? {
+  schemas: TSchemas;
+} : {};
+/** @public Referenced by emitted declarations of strict transition targets. */
+type SetupStateParentTypeMarker<TParentStateType extends SetupStateType | never> = {
+  readonly [parentSetupStateType]: TParentStateType;
+};
+/** @public Referenced by emitted declarations of strict transition targets. */
+type SetupStateSchemasWithParentType<TStateSchemas extends Record<string, SetupStateSchema>, TParentStateType extends SetupStateType | never> = TStateSchemas & SetupStateParentTypeMarker<TParentStateType>;
+type SetupStateParentType<TStateSchemas extends Record<string, SetupStateSchema>> = TStateSchemas extends SetupStateParentTypeMarker<infer TParentStateType> ? TParentStateType : never;
+type IsParallelSetupStateParent<TStateSchemas extends Record<string, SetupStateSchema>> = [SetupStateParentType<TStateSchemas>] extends [never] ? false : SetupStateParentType<TStateSchemas> extends 'parallel' ? true : false;
+type ResolveStateSiblingsForPath<TStates extends Record<string, SetupStateSchema>, TPath extends string> = SetupStateParentAtPath<TStates, TPath> extends (infer TParent) ? [TParent] extends [SetupStateSchema] ? SetupStateSchemasWithParentType<ResolveStateSiblings<TStates, TPath>, TParent extends {
+  type: infer TType extends SetupStateType;
+} ? TType : never> : ResolveStateSiblings<TStates, TPath> : never;
+/** @public Referenced by emitted declarations of strict transition targets. */
+type RootSetupStateSchemasMarker<TRootStateSchemas extends Record<string, SetupStateSchema>> = {
+  readonly [rootSetupStateSchemas]: TRootStateSchemas;
+};
+/** @public Referenced by emitted declarations of strict transition targets. */
+type WithRootSetupStateSchemas<TStateSchemas extends Record<string, SetupStateSchema>, TRootStateSchemas extends Record<string, SetupStateSchema>> = TStateSchemas & RootSetupStateSchemasMarker<TRootStateSchemas>;
+type RootSetupStateTransitionSchemas<TStateSchemas extends Record<string, SetupStateSchema>> = StrictSetupStateSchemas<{}, TStateSchemas, TStateSchemas>;
+type RootSetupStateTarget<TStateSchemas extends Record<string, SetupStateSchema>> = SetupRelativeStateTarget<TStateSchemas> | RootSetupStateIdTarget<TStateSchemas>;
+type SetupStateTransitionChildSchemas<TStateSchema extends SetupStateSchema> = TStateSchema extends {
+  states: infer TChildStateSchemas extends Record<string, SetupStateSchema>;
+} ? TChildStateSchemas : {};
+type SetupStateTransitionSchemas<TSiblingStateSchemas extends Record<string, SetupStateSchema>, TStateSchema extends SetupStateSchema> = IsParallelSetupStateParent<TSiblingStateSchemas> extends true ? StrictSetupStateSchemas<{}, SetupStateTransitionChildSchemas<TStateSchema>, RootSetupStateSchemas<TSiblingStateSchemas>, SetupStateSelfSchema<TStateSchema>> : string extends SetupStateKeys<TSiblingStateSchemas> ? TSiblingStateSchemas : keyof SetupStateSchema extends keyof TStateSchema ? TSiblingStateSchemas : TStateSchema extends {
+  states: Record<string, SetupStateSchema>;
+} ? TStateSchema extends {
+  type: SetupStateType;
+} ? StrictSetupStateSchemas<TSiblingStateSchemas, SetupStateTransitionChildSchemas<TStateSchema>, RootSetupStateSchemas<TSiblingStateSchemas>, SetupStateSelfSchema<TStateSchema>> : TSiblingStateSchemas : StrictSetupStateSchemas<TSiblingStateSchemas, {}, RootSetupStateSchemas<TSiblingStateSchemas>, SetupStateSelfSchema<TStateSchema>>;
+type SetupStateChildSchemas<TStateSchema extends SetupStateSchema> = TStateSchema['states'] extends Record<string, SetupStateSchema> ? TStateSchema['states'] : Record<string, SetupStateSchema>;
+type SetupStateIds<TStateSchemas extends Record<string, SetupStateSchema>> = { [K in keyof TStateSchemas & string]: TStateSchemas[K] extends {
+  id: infer TId extends string;
+} ? TId : never; }[keyof TStateSchemas & string] | { [K in keyof TStateSchemas & string]: TStateSchemas[K]['states'] extends Record<string, SetupStateSchema> ? SetupStateIds<TStateSchemas[K]['states']> : never; }[keyof TStateSchemas & string];
+type SetupStateIdTarget<TId extends string> = `#${EscapeSetupStatePathDots<TId>}`;
+type SetupStateIdTargets<TStateSchemas extends Record<string, SetupStateSchema>> = string extends SetupStateKeys<TStateSchemas> ? never : { [K in keyof TStateSchemas & string]: TStateSchemas[K] extends {
+  id: infer TId extends string;
+} ? TStateSchemas[K]['states'] extends (infer TChildStateSchemas extends Record<string, SetupStateSchema>) ? string extends SetupStateKeys<TChildStateSchemas> ? never : `${SetupStateIdTarget<TId>}.${StatePaths<TChildStateSchemas> & string}` : never : never; }[keyof TStateSchemas & string] | { [K in keyof TStateSchemas & string]: TStateSchemas[K]['states'] extends (infer TChildStateSchemas extends Record<string, SetupStateSchema>) ? SetupStateIdTargets<TChildStateSchemas> : never; }[keyof TStateSchemas & string];
+type RootSetupStateIdTarget<TStateSchemas extends Record<string, SetupStateSchema>> = SetupStateIds<TStateSchemas> extends (infer TIds extends string) ? [TIds] extends [never] ? never : SetupStateIdTarget<TIds> | SetupStateIdTargets<TStateSchemas> : never;
+type SetupStateSchemaAtTarget<TStateSchemas extends Record<string, SetupStateSchema>, TTarget extends string> = (TTarget extends '.' ? CurrentSetupStateSchema<TStateSchemas> : TTarget extends `.${infer TPath}` ? ResolveStatePath<RelativeSetupStateSchemas<TStateSchemas>, TPath> : TTarget extends `#${string}` ? SetupStateSchemaAtIdTarget<RootSetupStateSchemas<TStateSchemas>, TTarget> : ResolveStatePath<TStateSchemas, TTarget>) extends (infer TStateSchema) ? TStateSchema extends SetupStateSchema ? TStateSchema : never : never;
+type SetupStateSchemaAtId<TStateSchemas extends Record<string, SetupStateSchema>, TId extends string> = { [K in keyof TStateSchemas & string]: TStateSchemas[K] extends {
+  id: TId;
+} ? TStateSchemas[K] : TStateSchemas[K]['states'] extends Record<string, SetupStateSchema> ? SetupStateSchemaAtId<TStateSchemas[K]['states'], TId> : never; }[keyof TStateSchemas & string];
+type SetupStateSchemaAtIdTarget<TStateSchemas extends Record<string, SetupStateSchema>, TTarget extends string> = TTarget extends `#${infer TPath}` ? SplitSetupStatePath<TPath> extends [infer TId extends string, ...infer TDescendant extends string[]] ? SetupStateSchemaAtId<TStateSchemas, TId> extends (infer TStateSchema) ? TDescendant extends [] ? TStateSchema : TStateSchema extends {
+  states: infer TChildStateSchemas extends Record<string, SetupStateSchema>;
+} ? ResolveStatePathSegments<TChildStateSchemas, TDescendant> : never : never : never : never;
+type StateSchemasWithKeys<TStateSchemas extends Record<string, SetupStateSchema>, TStateKeys extends string> = TStateSchemas & { [K in Exclude<TStateKeys, keyof TStateSchemas>]: {}; };
+type EscapeSetupStatePathDots<TValue extends string> = TValue extends `${infer THead}.${infer TTail}` ? `${THead}\\.${EscapeSetupStatePathDots<TTail>}` : TValue;
+type ProtectSetupStatePathDots<TValue extends string> = TValue extends `${infer THead}\\.${infer TTail}` ? `${THead}__XSTATE_ESCAPED_DOT__${ProtectSetupStatePathDots<TTail>}` : TValue;
+type RestoreSetupStatePathDots<TValue extends string> = TValue extends `${infer THead}__XSTATE_ESCAPED_DOT__${infer TTail}` ? `${THead}.${RestoreSetupStatePathDots<TTail>}` : TValue;
+type SplitSetupStatePath<TPath extends string> = ProtectSetupStatePathDots<TPath> extends (infer TProtected extends string) ? TProtected extends '' ? [] : TProtected extends `${infer THead}.${infer TTail}` ? [RestoreSetupStatePathDots<THead>, ...SplitSetupStatePath<TTail>] : [RestoreSetupStatePathDots<TProtected>] : never;
+type ResolveStatePathSegments<TStates extends Record<string, SetupStateSchema>, TSegments extends readonly string[]> = TSegments extends [infer THead extends string, ...infer TRest extends string[]] ? THead extends keyof TStates ? TRest extends [] ? TStates[THead] : TStates[THead]['states'] extends Record<string, SetupStateSchema> ? ResolveStatePathSegments<TStates[THead]['states'], TRest> : never : never : never;
+type ResolveStatePath<TStates extends Record<string, SetupStateSchema>, TPath extends string> = ResolveStatePathSegments<TStates, SplitSetupStatePath<TPath>>;
+type ResolveStateSiblingsSegments<TStates extends Record<string, SetupStateSchema>, TSegments extends readonly string[]> = TSegments extends [infer THead extends string, ...infer TRest extends string[]] ? TRest extends [] ? TStates : THead extends keyof TStates ? TStates[THead]['states'] extends Record<string, SetupStateSchema> ? ResolveStateSiblingsSegments<TStates[THead]['states'], TRest> : never : never : never;
+/**
+ * The sibling state schemas of a dotted path: the children of the path's
+ * parent. A bare transition target resolves relative to the parent, so the
+ * valid targets for a path's config are its siblings. For a dotless (top-level)
+ * path the siblings are the root states.
+ */
+type ResolveStateSiblings<TStates extends Record<string, SetupStateSchema>, TPath extends string> = ResolveStateSiblingsSegments<TStates, SplitSetupStatePath<TPath>>;
+type SetupStateParentAtSegments<TStates extends Record<string, SetupStateSchema>, TSegments extends readonly string[]> = TSegments extends [infer THead extends string, ...infer TRest extends string[]] ? THead extends keyof TStates ? TRest extends [string] ? TStates[THead] : TStates[THead]['states'] extends Record<string, SetupStateSchema> ? SetupStateParentAtSegments<TStates[THead]['states'], TRest> : never : never : never;
+type SetupStateParentAtPath<TStates extends Record<string, SetupStateSchema>, TPath extends string> = SetupStateParentAtSegments<TStates, SplitSetupStatePath<TPath>>;
+/** Union of every addressable dotted path into a setup states tree */
+type StatePathsInner<TStates extends Record<string, SetupStateSchema>> = { [K in SetupStateKeys<TStates>]: EscapeSetupStatePathDots<K> | (TStates[K]['states'] extends Record<string, SetupStateSchema> ? `${EscapeSetupStatePathDots<K>}.${StatePathsInner<TStates[K]['states']>}` : never); }[SetupStateKeys<TStates>];
+type StatePaths<TStates extends Record<string, SetupStateSchema>> = string extends SetupStateKeys<TStates> ? string : [SetupStateKeys<TStates>] extends [never] ? string : StatePathsInner<TStates>;
+type SetupStatePath = readonly string[];
+type SetupStatePathAtId<TStates extends Record<string, SetupStateSchema>, TId extends string, TPrefix extends SetupStatePath = []> = { [K in SetupStateKeys<TStates>]: TStates[K] extends {
+  id: TId;
+} ? [...TPrefix, K] : TStates[K]['states'] extends Record<string, SetupStateSchema> ? SetupStatePathAtId<TStates[K]['states'], TId, [...TPrefix, K]> : never; }[SetupStateKeys<TStates>];
+type SetupParentStatePath<TPath extends SetupStatePath> = TPath extends readonly [...infer TParent extends string[], string] ? TParent : [];
+type SetupResolvedStatePath<TRootStateSchemas extends Record<string, SetupStateSchema>, TSourcePath extends string, TTarget extends string> = TTarget extends `#${infer TIdPath}` ? SplitSetupStatePath<TIdPath> extends [infer TId extends string, ...infer TDescendant extends string[]] ? SetupStatePathAtId<TRootStateSchemas, TId> extends (infer TIdStatePath) ? TIdStatePath extends SetupStatePath ? [...TIdStatePath, ...TDescendant] : never : never : never : TTarget extends '.' ? SplitSetupStatePath<TSourcePath> : TTarget extends `.${infer TDescendant}` ? [...SplitSetupStatePath<TSourcePath>, ...SplitSetupStatePath<TDescendant>] : [...SetupParentStatePath<SplitSetupStatePath<TSourcePath>>, ...SplitSetupStatePath<TTarget>];
+type SetupCommonStatePath<TLeft extends SetupStatePath, TRight extends SetupStatePath, TCommon extends SetupStatePath = []> = 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 ? SetupCommonStatePath<TLeftTail, TRightTail, [...TCommon, TLeftHead]> : TCommon : TCommon : TCommon;
+type SetupIsParallelStatePath<TRootStateSchemas extends Record<string, SetupStateSchema>, TPath extends SetupStatePath> = TPath extends [] ? false : ResolveStatePathSegments<TRootStateSchemas, TPath> extends (infer TStateSchema) ? TStateSchema extends {
+  type: 'parallel';
+} ? true : TStateSchema extends {
+  type: SetupStateType;
+} ? false : 'unknown' : 'unknown';
+type SetupInvalidTargetPair<TRootStateSchemas extends Record<string, SetupStateSchema>, TLeft extends SetupStatePath, TRight extends SetupStatePath> = [TLeft] extends [never] ? false : [TRight] extends [never] ? false : TLeft extends TRight ? true : TRight extends TLeft ? true : SetupIsParallelStatePath<TRootStateSchemas, SetupCommonStatePath<TLeft, TRight>> extends true ? false : SetupIsParallelStatePath<TRootStateSchemas, SetupCommonStatePath<TLeft, TRight>> extends false ? true : false;
+type SetupInvalidTargetPairsWithHead<TRootStateSchemas extends Record<string, SetupStateSchema>, TSourcePath extends string, THead, TRest extends readonly unknown[]> = TRest extends readonly [infer TNext, ...infer TTail] ? SetupInvalidTargetPair<TRootStateSchemas, SetupResolvedStatePath<TRootStateSchemas, TSourcePath, Extract<THead, string>>, SetupResolvedStatePath<TRootStateSchemas, TSourcePath, Extract<TNext, string>>> extends true ? true : SetupInvalidTargetPairsWithHead<TRootStateSchemas, TSourcePath, THead, TTail> : false;
+type SetupInvalidTargetSet<TRootStateSchemas extends Record<string, SetupStateSchema>, TSourcePath extends string, TTargets> = TTargets extends readonly [infer THead, ...infer TRest] ? SetupInvalidTargetPairsWithHead<TRootStateSchemas, TSourcePath, THead, TRest> extends true ? true : SetupInvalidTargetSet<TRootStateSchemas, TSourcePath, TRest> : false;
+type SetupTargetSetLegality<TTransition, TRootStateSchemas extends Record<string, SetupStateSchema>, TSourcePath extends string> = TTransition extends ((...args: infer TArgs) => infer TResult) ? (...args: TArgs) => TResult & SetupTargetSetLegality<TResult, TRootStateSchemas, TSourcePath> : TTransition extends readonly unknown[] ? { [K in keyof TTransition]: TTransition[K] & SetupTargetSetLegality<TTransition[K], TRootStateSchemas, TSourcePath>; } : TTransition extends {
+  target: infer TTargets extends readonly string[];
+} ? string extends TTargets[number] ? unknown : SetupInvalidTargetSet<TRootStateSchemas, TSourcePath, TTargets> extends true ? never : unknown : unknown;
+type SetupTargetSetMapLegality<TMap, TRootStateSchemas extends Record<string, SetupStateSchema>, TSourcePath extends string> = TMap extends Record<string, unknown> ? { [K in keyof TMap]?: TMap[K] & SetupTargetSetLegality<TMap[K], TRootStateSchemas, TSourcePath>; } : unknown;
+type SetupInvokeTargetSetLegality<TInvoke, TRootStateSchemas extends Record<string, SetupStateSchema>, TSourcePath extends string> = TInvoke extends {
+  readonly [createdInvokeConfig]: infer TConfig;
+} ? {
+  readonly [createdInvokeConfig]: TConfig & SetupInvokeTargetSetLegality<TConfig, TRootStateSchemas, TSourcePath>;
+} : TInvoke extends readonly unknown[] ? { [K in keyof TInvoke]: TInvoke[K] & SetupInvokeTargetSetLegality<TInvoke[K], TRootStateSchemas, TSourcePath>; } : TInvoke extends Record<string, unknown> ? (TInvoke extends {
+  onDone: infer TOnDone;
+} ? {
+  onDone?: TInvoke['onDone'] & SetupTargetSetLegality<TOnDone, TRootStateSchemas, TSourcePath>;
+} : unknown) & (TInvoke extends {
+  onError: infer TOnError;
+} ? {
+  onError?: TInvoke['onError'] & SetupTargetSetLegality<TOnError, TRootStateSchemas, TSourcePath>;
+} : unknown) & (TInvoke extends {
+  onSnapshot: infer TOnSnapshot;
+} ? {
+  onSnapshot?: TInvoke['onSnapshot'] & SetupTargetSetLegality<TOnSnapshot, TRootStateSchemas, TSourcePath>;
+} : unknown) & (TInvoke extends {
+  onTimeout: infer TOnTimeout;
+} ? {
+  onTimeout?: TInvoke['onTimeout'] & SetupTargetSetLegality<TOnTimeout, TRootStateSchemas, TSourcePath>;
+} : unknown) : unknown;
+type SetupStateTargetSetLegality<TConfig, TRootStateSchemas extends Record<string, SetupStateSchema>, TSourcePath extends string> = (TConfig extends {
+  on: infer TOn;
+} ? {
+  on?: TConfig['on'] & SetupTargetSetMapLegality<TOn, TRootStateSchemas, TSourcePath>;
+} : unknown) & (TConfig extends {
+  always: infer TAlways;
+} ? {
+  always?: TConfig['always'] & SetupTargetSetLegality<TAlways, TRootStateSchemas, TSourcePath>;
+} : unknown) & (TConfig extends {
+  after: infer TAfter;
+} ? {
+  after?: TConfig['after'] & SetupTargetSetMapLegality<TAfter, TRootStateSchemas, TSourcePath>;
+} : unknown) & (TConfig extends {
+  onDone: infer TOnDone;
+} ? {
+  onDone?: TConfig['onDone'] & SetupTargetSetLegality<TOnDone, TRootStateSchemas, TSourcePath>;
+} : unknown) & (TConfig extends {
+  onError: infer TOnError;
+} ? {
+  onError?: TConfig['onError'] & SetupTargetSetLegality<TOnError, TRootStateSchemas, TSourcePath>;
+} : unknown) & (TConfig extends {
+  onTimeout: infer TOnTimeout;
+} ? {
+  onTimeout?: TConfig['onTimeout'] & SetupTargetSetLegality<TOnTimeout, TRootStateSchemas, TSourcePath>;
+} : unknown) & (TConfig extends {
+  choice: infer TChoice;
+} ? {
+  choice?: TConfig['choice'] & SetupTargetSetLegality<TChoice, TRootStateSchemas, TSourcePath>;
+} : unknown) & (TConfig extends {
+  invoke: infer TInvoke;
+} ? {
+  invoke?: TConfig['invoke'] & SetupInvokeTargetSetLegality<TInvoke, TRootStateSchemas, TSourcePath>;
+} : unknown);
+/**
+ * Shared body of both `createStateConfig` overloads: the
+ * `StateNodeConfigWithNestedInput` instantiation whose only varying parts are
+ * the leading sibling-schemas and state-schema arguments.
+ */
+type SetupStateNodeConfig<TStates extends Record<string, SetupStateSchema>, TStateSchema extends SetupStateSchema, TSchemas extends SetupSchemas, TSetupActionMap extends Sources['actions'], TSetupActorMap extends Sources['actors'], TSetupGuardMap extends Sources['guards'], TSetupDelayMap extends Sources['delays'], TSystemRegistry extends SystemRegistry> = StateNodeConfigWithNestedInput<TStates, TStateSchema, SetupContext<TSchemas, StandardSchemaV1>, SetupContextShape<TSchemas, StandardSchemaV1, SetupContext<TSchemas, StandardSchemaV1>>, SetupEvents<TSchemas, Record<string, StandardSchemaV1>>, Cast<SetupChildren<TSchemas, Record<string, StandardSchemaV1>>, Record<string, AnyActorRef | undefined>>, string, SetupTags<TSchemas, StandardSchemaV1>, SetupOutput<TSchemas, StandardSchemaV1>, SetupEmitted<TSchemas, Record<string, StandardSchemaV1>>, SetupMeta<TSchemas, StandardSchemaV1>, SetupTransitionMeta<TSchemas, StandardSchemaV1, StandardSchemaV1>, SetupActions<TSchemas, TSetupActionMap>, TSetupActorMap, SetupGuards<TSchemas, TSetupGuardMap>, TSetupDelayMap, TSystemRegistry>;
+type SetupContext<TSchemas, TContextSchema extends StandardSchemaV1> = [SetupSchema<TSchemas, 'context'>] extends [never] ? unknown extends StandardSchemaV1.InferOutput<TContextSchema> ? MachineContext : StandardSchemaV1.InferOutput<TContextSchema> & MachineContext : StandardSchemaV1.InferOutput<SetupSchema<TSchemas, 'context'>> & MachineContext;
+type SetupContextShape<TSchemas, TContextSchema extends StandardSchemaV1, TFallbackContext> = [SetupSchema<TSchemas, 'context'>] extends [never] ? unknown extends StandardSchemaV1.InferOutput<TContextSchema> ? TFallbackContext : StandardSchemaV1.InferOutput<TContextSchema> : StandardSchemaV1.InferOutput<SetupSchema<TSchemas, 'context'>>;
+type SetupContextRequired<TSchemas, TContextSchema extends StandardSchemaV1> = [SetupSchema<TSchemas, 'context'>] extends [never] ? unknown extends StandardSchemaV1.InferOutput<TContextSchema> ? false : true : true;
+type SetupPublicEvents<TSchemas, TEventSchemaMap extends Record<string, StandardSchemaV1>> = [SetupSchemaMap<TSchemas, 'events'>] extends [never] ? InferEvents<TEventSchemaMap> : InferEvents<SetupSchemaMap<TSchemas, 'events'>>;
+type SetupInternalEvents<TSchemas, TInternalEventSchemaMap extends Record<string, StandardSchemaV1>> = [SetupSchemaMap<TSchemas, 'internalEvents'>] extends [never] ? InferInternalEvents<TInternalEventSchemaMap> : InferInternalEvents<SetupSchemaMap<TSchemas, 'internalEvents'>>;
+type SetupEvents<TSchemas, TEventSchemaMap extends Record<string, StandardSchemaV1>, TInternalEventSchemaMap extends Record<string, StandardSchemaV1> = {}> = SetupPublicEvents<TSchemas, TEventSchemaMap> | SetupInternalEvents<TSchemas, TInternalEventSchemaMap>;
+type SetupTags<TSchemas, TTagSchema extends StandardSchemaV1> = [SetupSchema<TSchemas, 'tags'>] extends [never] ? StandardSchemaV1.InferOutput<TTagSchema> & string : StandardSchemaV1.InferOutput<SetupSchema<TSchemas, 'tags'>> & string;
+type SetupInput<TSchemas, TInputSchema extends StandardSchemaV1> = [SetupSchema<TSchemas, 'input'>] extends [never] ? InferMachineInput<TInputSchema> : InferOutput<SetupSchema<TSchemas, 'input'>, unknown>;
+type SetupOutput<TSchemas, TOutputSchema extends StandardSchemaV1> = [SetupSchema<TSchemas, 'output'>] extends [never] ? InferOutput<TOutputSchema, unknown> : InferOutput<SetupSchema<TSchemas, 'output'>, unknown>;
+/**
+ * Whether an output schema was declared, either in `setup({ schemas })` or in
+ * the machine config's own `schemas.output`. A declared schema is always
+ * authoritative for the machine's output type.
+ */
+type HasOutputSchema<TSchemas, TOutputSchema extends StandardSchemaV1> = [SetupSchema<TSchemas, 'output'>] extends [never] ? StandardSchemaV1 extends TOutputSchema ? false : true : true;
+/**
+ * Whether a state is final, per the authored config or the setup-declared
+ * state contract.
+ */
+type IsFinalState<TStateConfig, TStateSchema> = TStateConfig extends {
+  type: 'final';
+} ? true : TStateSchema extends {
+  type: 'final';
+} ? true : false;
+/**
+ * The union of output types across the config's top-level final states, or
+ * `never` when it has none. A setup-declared per-state `schemas.output` wins
+ * over the state's inline `schemas.output`, which wins over the state's
+ * `output` mapper; a final state with none of these contributes `undefined`.
+ */
+type SetupTopLevelFinalOutput<TConfig, TStates extends Record<string, SetupStateSchema>> = TConfig extends {
+  states: infer TConfigStates;
+} ? { [K in keyof TConfigStates]: IsFinalState<TConfigStates[K], K extends keyof TStates ? TStates[K] : never> extends true ? K extends keyof TStates ? StateOutput<TStates[K], FinalStateConfigOutput<TConfigStates[K]>> : FinalStateConfigOutput<TConfigStates[K]> : never; }[keyof TConfigStates] : never;
+/**
+ * The machine's output type. A declared output schema wins; otherwise the type
+ * is inferred from the config's `output` property (a mapper's return type, or
+ * the static value's type), falling back to the union of top-level
+ * final-state output types.
+ */
+type SetupOrConfigOutput<TSchemas, TOutputSchema extends StandardSchemaV1, TConfig, TStates extends Record<string, SetupStateSchema>> = HasOutputSchema<TSchemas, TOutputSchema> extends true ? SetupOutput<TSchemas, TOutputSchema> : OutputFromConfig<TConfig, [SetupTopLevelFinalOutput<TConfig, TStates>] extends [never] ? SetupOutput<TSchemas, TOutputSchema> : SetupTopLevelFinalOutput<TConfig, TStates>>;
+type SetupEmitted<TSchemas, TEmittedSchemaMap extends Record<string, StandardSchemaV1>> = [SetupSchemaMap<TSchemas, 'emitted'>] extends [never] ? WithDefault<InferEvents<TEmittedSchemaMap>, AnyEventObject> : WithDefault<InferEvents<SetupSchemaMap<TSchemas, 'emitted'>>, AnyEventObject>;
+type SetupMeta<TSchemas, TMetaSchema extends StandardSchemaV1> = [SetupSchema<TSchemas, 'meta'>] extends [never] ? InferOutput<TMetaSchema, MetaObject> : InferOutput<SetupSchema<TSchemas, 'meta'>, MetaObject>;
+type SetupTransitionMeta<TSchemas, TMetaSchema extends StandardSchemaV1, TTransitionMetaSchema extends StandardSchemaV1> = [SetupSchema<TSchemas, 'transitionMeta'>] extends [never] ? StandardSchemaV1 extends TTransitionMetaSchema ? SetupMeta<TSchemas, TMetaSchema> : InferOutput<TTransitionMetaSchema, MetaObject> : InferOutput<SetupSchema<TSchemas, 'transitionMeta'>, MetaObject>;
+type SetupChildren<TSchemas, TChildrenSchemaMap extends Record<string, StandardSchemaV1>> = [SetupSchemaMap<TSchemas, 'children'>] extends [never] ? InferChildren<TChildrenSchemaMap> : InferChildren<SetupSchemaMap<TSchemas, 'children'>>;
+type SetupActions<TSchemas, TActionMap extends Sources['actions']> = [SetupActionSchemaMap<TSchemas>] extends [never] ? TActionMap : MergeSourceMaps<InferActions<SetupActionSchemaMap<TSchemas>>, TActionMap>;
+type SetupGuards<TSchemas, TGuardMap extends Sources['guards']> = [SetupGuardSchemaMap<TSchemas>] extends [never] ? TGuardMap : MergeSourceMaps<InferGuards<SetupGuardSchemaMap<TSchemas>>, TGuardMap>;
+type SetupMergeChildren<TChildren extends Record<string, AnyActorRef | undefined>, TActor extends ProvidedActor> = [keyof TChildren] extends [never] ? Compute<ToChildren<TActor>> : Compute<TChildren>;
+type MergeSourceMaps<TBase extends Record<string, unknown>, TExtension extends Record<string, unknown>> = Compute<TBase & TExtension>;
+type MergeSetupStateSchemaField<TBase extends SetupStateSchema, TExtension extends SetupStateSchema, TKey extends 'schemas' | 'states'> = TKey extends keyof TExtension ? TKey extends keyof TBase ? TKey extends 'schemas' ? { [K in TKey]: MergeRecord<NonNullable<TBase[TKey]>, NonNullable<TExtension[TKey]>>; } : NonNullable<TBase[TKey]> extends Record<string, SetupStateSchema> ? NonNullable<TExtension[TKey]> extends Record<string, SetupStateSchema> ? { [K in TKey]: MergeSetupStateSchemas<NonNullable<TBase[TKey]>, NonNullable<TExtension[TKey]>>; } : Pick<TExtension, TKey> : Pick<TExtension, TKey> : Pick<TExtension, TKey> : TKey extends keyof TBase ? Pick<TBase, TKey> : {};
+type MergeSetupStateSchema<TBase extends SetupStateSchema, TExtension extends SetupStateSchema> = Omit<TBase, keyof TExtension> & Omit<TExtension, 'schemas' | 'states'> & MergeSetupStateSchemaField<TBase, TExtension, 'schemas'> & MergeSetupStateSchemaField<TBase, TExtension, 'states'>;
+type MergeSetupStateSchemas<TBase extends Record<string, SetupStateSchema>, TExtension extends Record<string, SetupStateSchema>> = { [K in keyof TBase | keyof TExtension]: K extends keyof TExtension ? K extends keyof TBase ? MergeSetupStateSchema<TBase[K], TExtension[K]> : TExtension[K] : K extends keyof TBase ? TBase[K] : never; };
+type DelayNamesFromConfigOrString<TConfig> = TConfig extends {
+  delays: infer TDelays;
+} ? Extract<keyof TDelays, string> : string;
+type DelayNamesFromConfig<TConfig> = TConfig extends {
+  delays: infer TDelays;
+} ? Extract<keyof TDelays, string> : never;
+type ValidateSetupDelayReferences<TConfig, TSetupDelays extends string> = ValidateDelayNames<TConfig, [TSetupDelays] extends [never] ? DelayNamesFromConfigOrString<TConfig> : TSetupDelays | DelayNamesFromConfig<TConfig>>;
+/** Extracts input type from a state schema */
+type StateInput<TStateSchema extends SetupStateSchema> = TStateSchema['schemas'] extends {
+  input: infer TInputSchema;
+} ? TInputSchema extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<TInputSchema> : undefined : undefined;
+/** Extracts the completion output type from a state schema. */
+type StateOutput<TStateSchema extends SetupStateSchema, TFallback> = TStateSchema['schemas'] extends {
+  output: infer TOutputSchema;
+} ? TOutputSchema extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<TOutputSchema> : TFallback : TFallback;
+type StateCompletionOutput<TStateSchema extends SetupStateSchema> = StateOutput<TStateSchema, unknown>;
+type StateContext<TStateSchema extends SetupStateSchema, TFallbackContext extends MachineContext> = TStateSchema['schemas'] extends {
+  context: infer TContextSchema;
+} ? TContextSchema extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<TContextSchema> & RootContext<TFallbackContext> & MachineContext & RootContextMarker<TFallbackContext> : RootContext<TFallbackContext> : RootContext<TFallbackContext>;
+declare const rootContext: unique symbol;
+/** @public Referenced by emitted declarations of narrowed state contexts. */
+interface RootContextMarker<TContext> {
+  readonly [rootContext]?: RootContext<TContext>;
+}
+type RootContext<TContext> = typeof rootContext extends keyof TContext ? TContext[typeof rootContext] : TContext;
+type StateContextShape<TStateSchema extends SetupStateSchema, TFallbackContext> = TStateSchema['schemas'] extends {
+  context: infer TContextSchema;
+} ? TContextSchema extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<TContextSchema> & RootContext<TFallbackContext> & RootContextMarker<TFallbackContext> : RootContext<TFallbackContext> : RootContext<TFallbackContext>;
+/** @public Referenced by emitted declarations of narrowed state contexts. */
+type ActiveStateContext<TStateSchema extends SetupStateSchema, TRootContext extends MachineContext, TAncestorContext> = StateContext<TStateSchema, TRootContext> & TAncestorContext & MachineContext;
+type ActiveStateContextShape<TStateSchema extends SetupStateSchema, TAncestorContext> = StateContextShape<TStateSchema, TAncestorContext> & TAncestorContext;
+type WithNestedStates<TConfig, TNestedStates> = TConfig extends {
+  type: 'choice';
+} ? TConfig : Omit<TConfig, 'states'> & {
+  states?: TNestedStates;
+};
+type HasStateInputSchema<TStateSchema extends SetupStateSchema> = TStateSchema['schemas'] extends {
+  input: infer TInputSchema;
+} ? TInputSchema extends StandardSchemaV1 ? true : false : false;
+type RequiresStateInput<TStateSchema extends SetupStateSchema> = HasStateInputSchema<TStateSchema> extends true ? undefined extends StateInput<TStateSchema> ? false : true : false;
+type HasRequiredStateInput<TStates extends Record<string, SetupStateSchema>> = true extends { [K in keyof TStates]: RequiresStateInput<TStates[K]>; }[keyof TStates] ? true : false;
+type SetupStateSchemaForChild<TStateSchema extends SetupStateSchema, TTarget extends string> = TStateSchema['states'] extends (infer TStates extends Record<string, SetupStateSchema>) ? TTarget extends keyof TStates & string ? TStates[TTarget] : {} : {};
+type SetupStateInputConfig<TStateSchema extends SetupStateSchema, TContext extends MachineContext, TEvent extends EventObject, TInputArgs extends {
+  context: TContext;
+  event: TEvent;
+} = {
+  context: TContext;
+  event: TEvent;
+}> = HasStateInputSchema<TStateSchema> extends true ? undefined extends StateInput<TStateSchema> ? {
+  input?: StateInput<TStateSchema> | ((args: TInputArgs) => StateInput<TStateSchema>);
+} : {
+  input: StateInput<TStateSchema> | ((args: TInputArgs) => StateInput<TStateSchema>);
+} : {
+  input?: Record<string, unknown> | ((args: TInputArgs) => Record<string, unknown>);
+};
+type SetupChoiceTargetConfig<TStateSchemas extends Record<string, SetupStateSchema>, TContext extends MachineContext, TEvent extends EventObject> = { [K in KnownSetupStateTarget<TStateSchemas>]: {
+  target: K;
+} & SetupStateInputConfig<SetupStateSchemaAtTarget<TStateSchemas, K>, TContext, TEvent>; }[KnownSetupStateTarget<TStateSchemas>] | (TStateSchemas extends StrictSetupStateTargetsFlag ? {
+  target: KnownSetupStateTarget<TStateSchemas>[];
+  input?: Record<string, unknown>;
+} : {
+  target: SetupStateTarget<TStateSchemas>[];
+  input?: Record<string, unknown>;
+});
+type SetupChoiceFunction<TChoice, TStateSchemas extends Record<string, SetupStateSchema>, TContext extends MachineContext, TEvent extends EventObject> = TChoice extends ((...args: infer TArgs) => infer TResult) ? (...args: TArgs) => (TResult extends {
+  target: unknown;
+} ? Omit<TResult, 'target' | 'input'> & SetupChoiceTargetConfig<TStateSchemas, TContext, TEvent> : TResult) | void : never;
+type SetupChoiceTargetArrayInputConstraint<TChoice, TStateSchemas extends Record<string, SetupStateSchema>, TContext extends MachineContext, TEvent extends EventObject> = TChoice extends ((...args: infer TArgs) => infer TResult) ? (...args: TArgs) => TResult & SetupTargetArrayInputConstraint<TResult, TStateSchemas, TContext, TEvent> : never;
+type SetupTargetInput<TStateSchema extends SetupStateSchema> = HasStateInputSchema<TStateSchema> extends true ? Exclude<StateInput<TStateSchema>, undefined> : Record<string, unknown>;
+type SetupUnionToIntersection<T> = (T extends any ? (value: T) => void : never) extends ((value: infer I) => void) ? I : never;
+type SetupTargetArrayInput<TStateSchemas extends Record<string, SetupStateSchema>, TTargets extends readonly string[]> = SetupUnionToIntersection<SetupTargetInputForTarget<TStateSchemas, TTargets[number]>>;
+type SetupTargetInputForTarget<TStateSchemas extends Record<string, SetupStateSchema>, TTarget extends string> = SetupStateSchemaAtTarget<TStateSchemas, TTarget> extends (infer TStateSchema) ? TStateSchema extends SetupStateSchema ? SetupTargetInput<TStateSchema> : Record<string, unknown> : Record<string, unknown>;
+type SetupTargetArrayRequiresInput<TStateSchemas extends Record<string, SetupStateSchema>, TTargets extends readonly string[]> = true extends { [K in TTargets[number]]: RequiresStateInput<SetupStateSchemaAtTarget<TStateSchemas, K>>; }[TTargets[number]] ? true : false;
+type SetupTargetArrayInputConfig<TStateSchemas extends Record<string, SetupStateSchema>, TTargets extends readonly string[], TContext extends MachineContext = MachineContext, TEvent extends EventObject = EventObject> = SetupTargetArrayRequiresInput<TStateSchemas, TTargets> extends true ? {
+  input: SetupTargetArrayInput<TStateSchemas, TTargets> | ((args: {
+    context: TContext;
+    event: TEvent;
+  }) => SetupTargetArrayInput<TStateSchemas, TTargets>);
+} : {
+  input?: SetupTargetArrayInput<TStateSchemas, TTargets> | ((args: {
+    context: TContext;
+    event: TEvent;
+  }) => SetupTargetArrayInput<TStateSchemas, TTargets>);
+};
+/**
+ * The runtime applies one transition input to every target in a target set.
+ * Keep the array's input correlated to its literal targets by requiring the
+ * intersection of their direct input types. Widened string arrays remain
+ * permissive for compatibility.
+ */
+type SetupTargetArrayInputConstraint<TTransition, TStateSchemas extends Record<string, SetupStateSchema>, TContext extends MachineContext = MachineContext, TEvent extends EventObject = EventObject> = TTransition extends ((...args: infer TArgs) => infer TResult) ? (...args: TArgs) => TResult & SetupTargetArrayInputConstraint<TResult, TStateSchemas, TContext, TEvent> : [TTransition] extends [{
+  target: infer TTargets extends readonly string[];
+}] ? string extends TTargets[number] ? unknown : [TTargets[number]] extends [never] ? unknown : KnownSetupStateTarget<TStateSchemas> extends never ? unknown : Exclude<TTargets[number], KnownSetupStateTarget<TStateSchemas>> extends never ? SetupTargetArrayInputConfig<TStateSchemas, TTargets, TContext, TEvent> : never : unknown;
+type SetupTransitionValueTargetArrayInputConstraint<TValue, TStateSchemas extends Record<string, SetupStateSchema>> = [TValue] extends [readonly unknown[]] ? { [K in keyof TValue]: TValue[K] & SetupTransitionValueTargetArrayInputConstraint<TValue[K], TStateSchemas>; } : SetupTargetArrayInputConstraint<TValue, TStateSchemas>;
+type SetupTransitionMapTargetArrayInputConstraint<TValue, TStateSchemas extends Record<string, SetupStateSchema>> = [TValue] extends [Record<string, unknown>] ? { [K in keyof TValue]?: TValue[K] & SetupTransitionValueTargetArrayInputConstraint<TValue[K], TStateSchemas>; } : unknown;
+type SetupTransitionPropertyTargetArrayInputConstraint<TConfig, TKey extends PropertyKey, TStateSchemas extends Record<string, SetupStateSchema>, TIsMap extends boolean = false> = TKey extends keyof TConfig ? { [K in TKey]?: TConfig[K] & (TIsMap extends true ? SetupTransitionMapTargetArrayInputConstraint<TConfig[K], TStateSchemas> : SetupTransitionValueTargetArrayInputConstraint<TConfig[K], TStateSchemas>); } : unknown;
+type SetupInvokeTargetArrayInputConstraint<TInvoke, TStateSchemas extends Record<string, SetupStateSchema>> = TInvoke extends {
+  readonly [createdInvokeConfig]: infer TConfig;
+} ? {
+  readonly [createdInvokeConfig]: TConfig & SetupInvokeTargetArrayInputConstraint<TConfig, TStateSchemas>;
+} : [TInvoke] extends [readonly unknown[]] ? { [K in keyof TInvoke]: TInvoke[K] & SetupInvokeTargetArrayInputConstraint<TInvoke[K], TStateSchemas>; } : [TInvoke] extends [Record<string, unknown>] ? SetupTransitionPropertyTargetArrayInputConstraint<TInvoke, 'onDone', TStateSchemas> & SetupTransitionPropertyTargetArrayInputConstraint<TInvoke, 'onError', TStateSchemas> & SetupTransitionPropertyTargetArrayInputConstraint<TInvoke, 'onSnapshot', TStateSchemas> & SetupTransitionPropertyTargetArrayInputConstraint<TInvoke, 'onTimeout', TStateSchemas> : unknown;
+type SetupStateNodeTargetArrayInputConstraint<TConfig, TSiblingStateSchemas extends Record<string, SetupStateSchema>, TStateSchema extends SetupStateSchema, TChildStateSchemas extends Record<string, SetupStateSchema>> = SetupTransitionPropertyTargetArrayInputConstraint<TConfig, 'on', SetupStateTransitionSchemas<TSiblingStateSchemas, TStateSchema>, true> & SetupTransitionPropertyTargetArrayInputConstraint<TConfig, 'always', SetupStateTransitionSchemas<TSiblingStateSchemas, TStateSchema>> & SetupTransitionPropertyTargetArrayInputConstraint<TConfig, 'after', SetupStateTransitionSchemas<TSiblingStateSchemas, TStateSchema>, true> & SetupTransitionPropertyTargetArrayInputConstraint<TConfig, 'onDone', SetupStateTransitionSchemas<TSiblingStateSchemas, TStateSchema>> & SetupTransitionPropertyTargetArrayInputConstraint<TConfig, 'onError', SetupStateTransitionSchemas<TSiblingStateSchemas, TStateSchema>> & SetupTransitionPropertyTargetArrayInputConstraint<TConfig, 'onTimeout', SetupStateTransitionSchemas<TSiblingStateSchemas, TStateSchema>> & SetupTransitionPropertyTargetArrayInputConstraint<TConfig, 'choice', SetupStateTransitionSchemas<TSiblingStateSchemas, TStateSchema>> & (TConfig extends {
+  invoke: infer TInvoke;
+} ? {
+  invoke?: TConfig['invoke'] & SetupInvokeTargetArrayInputConstraint<TInvoke, SetupStateTransitionSchemas<TSiblingStateSchemas, TStateSchema>>;
+} : unknown) & (TConfig extends {
+  states: infer TChildren extends Record<string, unknown>;
+} ? {
+  states?: { [K in keyof TChildren]?: TChildren[K] & SetupStateNodeTargetArrayInputConstraint<TChildren[K], TChildStateSchemas, K extends keyof TChildStateSchemas ? TChildStateSchemas[K] : SetupStateSchema, SetupStateChildSchemas<K extends keyof TChildStateSchemas ? TChildStateSchemas[K] : SetupStateSchema>>; };
+} : unknown);
+type ValidateSetupTargetArrayInputs<TConfig, TRootStateSchemas extends Record<string, SetupStateSchema>> = SetupStateNodeTargetArrayInputConstraint<TConfig, TRootStateSchemas, SetupStateSchema, TRootStateSchemas>;
+type ValidateSetupStateContracts<TConfig, TStateSchemas extends Record<string, SetupStateSchema>> = HasExplicitSetupStateContracts<TStateSchemas> extends true ? ValidateSetupHistoryInputs<TConfig, TStateSchemas> & ValidateHistoryDefaults<MergeSetupConfig<TConfig, TStateSchemas>> & ValidateStateTargets<MergeSetupConfig<TConfig, TStateSchemas>> & NoInfer<ValidateSetupTargetArrayInputs<TConfig, TStateSchemas>> : unknown;
+type SetupInitialTransitionConfig<TStateSchema extends SetupStateSchema, TTarget extends string, TConfig, TContext extends MachineContext, TEvent extends EventObject> = Extract<SetupConfigInitial<TConfig>, {
+  target: TTarget;
+}> extends (infer TInitial) ? [TInitial] extends [never] ? {
+  target: TTarget;
+} & SetupStateInputConfig<SetupStateSchemaForChild<TStateSchema, TTarget>, TContext, TEvent> : Omit<TInitial, 'target' | 'input'> & {
+  target: TTarget;
+} & SetupStateInputConfig<SetupStateSchemaForChild<TStateSchema, TTarget>, TContext, TEvent> : never;
+type SetupConfigInitial<TConfig> = TConfig extends {
+  initial?: infer TInitial;
+} ? NonNullable<TInitial> : never;
+type SetupInitialTransition<TStateSchema extends SetupStateSchema, TTarget extends string = string, TConfig = unknown, TContext extends MachineContext = MachineContext, TEvent extends EventObject = EventObject> = (RequiresStateInput<SetupStateSchemaForChild<TStateSchema, TTarget>> extends true ? never : TTarget) | SetupInitialTransitionConfig<TStateSchema, TTarget, TConfig, TContext, TEvent>;
+type SetupInitialTransitionForStates<TStateSchema extends SetupStateSchema, TConfig, TContext extends MachineContext, TEvent extends EventObject> = TStateSchema['states'] extends (infer TStates extends Record<string, SetupStateSchema>) ? { [K in keyof TStates & string]: SetupInitialTransition<TStateSchema, K, TConfig, TContext, TEvent>; }[keyof TStates & string] : never;
+type SetupInitialTransitionForOtherStates<TStateSchema extends SetupStateSchema, TInitial extends string, TContext extends MachineContext, TEvent extends EventObject> = TStateSchema['states'] extends (infer TStates extends Record<string, SetupStateSchema>) ? { [K in Exclude<keyof TStates & string, TInitial>]: SetupInitialTransition<TStateSchema, K, unknown, TContext, TEvent>; }[Exclude<keyof TStates & string, TInitial>] : never;
+type SetupStateInitial<TStateSchema extends SetupStateSchema, TContext extends MachineContext, TEvent extends EventObject> = TStateSchema extends {
+  initial: infer TInitial extends string;
+} ? RequiresStateInput<SetupStateSchemaForChild<TStateSchema, TInitial>> extends true ? {
+  initial: SetupInitialTransition<TStateSchema, TInitial, unknown, TContext, TEvent> | SetupInitialTransitionForOtherStates<TStateSchema, TInitial, TContext, TEvent>;
+} : {
+  initial?: SetupInitialTransition<TStateSchema, TInitial, unknown, TContext, TEvent> | SetupInitialTransitionForOtherStates<TStateSchema, TInitial, TContext, TEvent>;
+} : TStateSchema['states'] extends Record<string, SetupStateSchema> ? HasRequiredStateInput<TStateSchema['states']> extends true ? {
+  initial: SetupInitialTransitionForStates<TStateSchema, unknown, TContext, TEvent>;
+} : {
+  initial: string | {
+    target: string;
+    input?: Record<string, unknown>;
+  };
+} : {
+  initial: string | {
+    target: string;
+    input?: Record<string, unknown>;
+  };
+};
+type SetupStateNodeContract<TStateSchema extends SetupStateSchema, TConfig, TContext extends MachineContext = MachineContext, TEvent extends EventObject = EventObject, TSiblingStateSchemas extends Record<string, SetupStateSchema> = Record<string, SetupStateSchema>> = TStateSchema extends {
+  type: infer TType;
+} ? TType extends 'atomic' ? Omit<TConfig, 'type' | 'states' | 'initial' | 'history' | 'target'> & {
+  type?: 'atomic';
+  states?: never;
+  initial?: never;
+  history?: never;
+  target?: never;
+} : TType extends 'compound' ? Omit<TConfig, 'type' | 'initial'> & ({
+  type?: 'compound';
+} & SetupStateChildrenContract<TStateSchema, TConfig> & SetupStateInitial<TStateSchema, TContext, TEvent>) : TType extends 'parallel' ? Omit<TConfig, 'type' | 'initial'> & {
+  type?: 'parallel';
+  initial?: never;
+  states: NonNullable<TConfig extends {
+    states?: infer TStates;
+  } ? TStates : unknown>;
+} : TType extends 'final' ? Omit<TConfig, 'type' | 'states' | 'initial' | 'history' | 'target' | 'invoke' | 'on' | 'always' | 'after' | 'timeout' | 'onTimeout' | 'onDone' | 'onError'> & {
+  type?: 'final';
+  states?: never;
+  initial?: never;
+  history?: never;
+  target?: never;
+  invoke?: never;
+  on?: never;
+  always?: never;
+  after?: never;
+  timeout?: never;
+  onTimeout?: never;
+  onDone?: never;
+  onError?: never;
+} : TType extends 'history' ? SetupHistoryStateContract<TStateSchema, TConfig, TSiblingStateSchemas> : TType extends 'choice' ? Omit<TConfig, 'type' | 'states' | 'initial' | 'history' | 'target' | 'invoke' | 'on' | 'entry' | 'exit' | 'onDone' | 'onError' | 'after' | 'timeout' | 'onTimeout' | 'always'> & {
+  type?: 'choice';
+  choice: Extract<TConfig, {
+    choice: (...args: any[]) => any;
+  }> extends {
+    choice: infer TChoice;
+  } ? SetupChoiceFunction<TChoice, SetupStateTransitionSchemas<TSiblingStateSchemas, TStateSchema>, TContext, TEvent> & SetupChoiceTargetArrayInputConstraint<TChoice, SetupStateTransitionSchemas<TSiblingStateSchemas, TStateSchema>, TContext, TEvent> : (...args: any[]) => any;
+  states?: never;
+  initial?: never;
+  history?: never;
+  target?: never;
+  invoke?: never;
+  on?: never;
+  entry?: never;
+  exit?: never;
+  onDone?: never;
+  onError?: never;
+  after?: never;
+  timeout?: never;
+  onTimeout?: never;
+  always?: never;
+} : TStateSchema extends {
+  history: unknown;
+} ? SetupHistoryStateContract<TStateSchema, TConfig, TSiblingStateSchemas> : TConfig : TConfig;
+type SetupHistoryStateContract<TStateSchema extends SetupStateSchema, TConfig, TSiblingStateSchemas extends Record<string, SetupStateSchema>> = Omit<TConfig, 'type' | 'states' | 'initial' | 'target'> & {
+  type?: 'history';
+  states?: never;
+  initial?: never;
+} & (TStateSchema extends {
+  target: infer TTarget extends string | readonly [string, ...string[]];
+} ? {
+  target?: TTarget | KnownSetupStateTarget<TSiblingStateSchemas> | readonly KnownSetupStateTarget<TSiblingStateSchemas>[];
+} : {
+  target: KnownSetupStateTarget<TSiblingStateSchemas> | readonly KnownSetupStateTarget<TSiblingStateSchemas>[];
+});
+type SetupStateChildrenContract<TStateSchema extends SetupStateSchema, TConfig> = TStateSchema extends {
+  states: Record<string, SetupStateSchema>;
+} ? {
+  states: NonNullable<TConfig extends {
+    states?: infer TStates;
+  } ? TStates : unknown>;
+} : {};
+type HistoryTargetRequiresInput<TSiblingStateSchemas extends Record<string, SetupStateSchema>, TTarget extends string | readonly string[]> = TTarget extends readonly (infer TTargets extends string)[] ? true extends { [K in TTargets]: RequiresStateInput<SetupStateSchemaAtTarget<TSiblingStateSchemas, K>>; }[TTargets] ? true : false : TTarget extends string ? RequiresStateInput<SetupStateSchemaAtTarget<TSiblingStateSchemas, TTarget>> : false;
+type SetupHistoryTarget<TStateSchema extends SetupStateSchema, TConfig> = TConfig extends {
+  target: infer TTarget extends string | readonly [string, ...string[]];
+} ? TTarget : TStateSchema extends {
+  target: infer TTarget extends string | readonly [string, ...string[]];
+} ? TTarget : never;
+type ValidateSetupHistoryStateInput<TConfig, TStateSchema extends SetupStateSchema, TSiblingStateSchemas extends Record<string, SetupStateSchema>> = TStateSchema extends {
+  type: 'history';
+} | {
+  history: unknown;
+} ? SetupHistoryTarget<TStateSchema, TConfig> extends (infer TTarget) ? [TTarget] extends [never] ? unknown : TTarget extends string | readonly [string, ...string[]] ? HistoryTargetRequiresInput<TSiblingStateSchemas, TTarget> extends true ? never : unknown : unknown : unknown : unknown;
+type ValidateSetupHistoryInputs<TConfig, TStateSchemas extends Record<string, SetupStateSchema>, TRootStateSchemas extends Record<string, SetupStateSchema> = TStateSchemas> = TConfig extends {
+  states: infer TStates extends Record<string, unknown>;
+} ? {
+  states: { [K in keyof TStates & string]: K extends keyof TStateSchemas ? TStates[K] & ValidateSetupHistoryStateInput<TStates[K], TStateSchemas[K], WithRootSetupStateSchemas<TStateSchemas, TRootStateSchemas>> & (TStateSchemas[K]['states'] extends Record<string, SetupStateSchema> ? ValidateSetupHistoryInputs<TStates[K], TStateSchemas[K]['states'], TRootStateSchemas> : unknown) : TStates[K]; };
+} : unknown;
+type DistributiveOmit<T, K extends keyof any> = T extends any ? Omit<T, K> : never;
+type SetupStateSchemaMetadata<TSetupSchema extends SetupStateSchema> = (TSetupSchema extends {
+  type: infer TType;
+} ? {
+  type: TType;
+} : {}) & (TSetupSchema extends {
+  id: infer TId;
+} ? {
+  id: TId;
+} : {}) & (TSetupSchema extends {
+  initial: infer TInitial;
+} ? {
+  initial: TInitial;
+} : {}) & (TSetupSchema extends {
+  history: infer THistory;
+} ? {
+  history: THistory;
+} : {}) & (TSetupSchema extends {
+  target: infer TTarget;
+} ? {
+  target: TTarget;
+} : {}) & (TSetupSchema extends {
+  route: infer TRoute;
+} ? {
+  route: TRoute;
+} : {});
+/**
+ * Converts SetupStateSchema to StateSchema with input types included. This
+ * allows getInputs() to be strongly typed.
+ */
+type SetupStateSchemaToStateSchema<TSetupSchema extends SetupStateSchema> = {
+  input: StateInput<TSetupSchema>;
+  contextSchema: TSetupSchema['schemas'] extends {
+    context: infer TContextSchema;
+  } ? TContextSchema extends StandardSchemaV1 ? TContextSchema : undefined : undefined;
+  outputSchema: TSetupSchema['schemas'] extends {
+    output: infer TOutputSchema;
+  } ? TOutputSchema extends StandardSchemaV1 ? TOutputSchema : undefined : undefined;
+  states: TSetupSchema['states'] extends Record<string, SetupStateSchema> ? { [K in keyof TSetupSchema['states'] & string]: SetupStateSchemaToStateSchema<TSetupSchema['states'][K]>; } : undefined;
+} & SetupStateSchemaMetadata<TSetupSchema>;
+/** Converts the root setup states config to a StateSchema. */
+type SetupStatesToStateSchema<TStates extends Record<string, SetupStateSchema>> = {
+  states: { [K in keyof TStates & string]: SetupStateSchemaToStateSchema<TStates[K]>; };
+};
+type EmptyStateSchema = {
+  input: undefined;
+  states: undefined;
+};
+type StateSchemaInput<TConfig extends StateSchema, TSetup extends StateSchema> = TSetup extends {
+  input: infer TInput;
+} ? TInput : TConfig extends {
+  input: infer TInput;
+} ? TInput : undefined;
+type StateSchemaContextSchema<TConfig extends StateSchema, TSetup extends StateSchema> = TSetup extends {
+  contextSchema: infer TContextSchema;
+} ? TContextSchema extends StandardSchemaV1 ? TContextSchema : undefined : TConfig extends {
+  contextSchema: infer TContextSchema;
+} ? TContextSchema extends StandardSchemaV1 ? TContextSchema : undefined : undefined;
+type StateSchemaOutputSchema<TConfig extends StateSchema, TSetup extends StateSchema> = TSetup extends {
+  outputSchema: infer TOutputSchema;
+} ? TOutputSchema extends StandardSchemaV1 ? TOutputSchema : undefined : TConfig extends {
+  outputSchema: infer TOutputSchema;
+} ? TOutputSchema extends StandardSchemaV1 ? TOutputSchema : undefined : undefined;
+type StateSchemaChild<TSetup extends StateSchema, K extends string> = TSetup extends {
+  states: infer TStates;
+} ? K extends keyof TStates ? Cast<TStates[K], StateSchema> : EmptyStateSchema : EmptyStateSchema;
+type StateMetadataField<TConfig, TSetup extends StateSchema, TKey extends keyof StateSchema> = TConfig extends Record<TKey, infer TValue> ? { [K in TKey]: TValue; } : TSetup extends Record<TKey, infer TValue> ? { [K in TKey]: TValue; } : {};
+type MergeStateSchemaMetadata<TConfig extends StateSchema, TSetup extends StateSchema> = StateMetadataField<TConfig, TSetup, 'id'> & StateMetadataField<TConfig, TSetup, 'route'> & StateMetadataField<TConfig, TSetup, 'type'> & StateMetadataField<TConfig, TSetup, 'initial'> & StateMetadataField<TConfig, TSetup, 'history'> & StateMetadataField<TConfig, TSetup, 'target'>;
+/** Adds setup-declared topology to authored config for structural validation. */
+type MergeSetupConfigState<TConfig, TSetup extends StateSchema> = Omit<TConfig, 'id' | 'route' | 'type' | 'initial' | 'history' | 'target' | 'states'> & StateMetadataField<TConfig, TSetup, 'id'> & StateMetadataField<TConfig, TSetup, 'route'> & StateMetadataField<TConfig, TSetup, 'type'> & StateMetadataField<TConfig, TSetup, 'initial'> & StateMetadataField<TConfig, TSetup, 'history'> & StateMetadataField<TConfig, TSetup, 'target'> & (TConfig extends {
+  states: infer TStates;
+} ? TStates extends Record<string, unknown> ? {
+  states: { [K in keyof TStates & string]: MergeSetupConfigState<TStates[K], StateSchemaChild<TSetup, K>>; };
+} : {
+  states: TStates;
+} : {});
+type MergeSetupConfig<TConfig, TStates extends Record<string, SetupStateSchema>> = MergeSetupConfigState<TConfig, SetupStatesToStateSchema<TStates>>;
+type MergeStateSchema<TConfig extends StateSchema, TSetup extends StateSchema> = Omit<TConfig, 'contextSchema' | 'input' | 'states'> & {
+  contextSchema: StateSchemaContextSchema<TConfig, TSetup>;
+  outputSchema: StateSchemaOutputSchema<TConfig, TSetup>;
+  input: StateSchemaInput<TConfig, TSetup>;
+  states: TConfig extends {
+    states: infer TStates;
+  } ? TStates extends Record<string, StateSchema> ? { [K in keyof TStates & string]: MergeStateSchema<TStates[K], StateSchemaChild<TSetup, K>>; } : undefined : undefined;
+} & MergeStateSchemaMetadata<TConfig, TSetup>;
+type SetupMachineStateSchema<TConfig, TStateSchemas extends Record<string, SetupStateSchema>> = HasExplicitSetupStateContracts<TStateSchemas> extends true ? MergeStateSchema<Cast<TConfig, StateSchema>, SetupStatesToStateSchema<TStateSchemas>> : Cast<TConfig, StateSchema>;
+type PublicInvoke<T> = T extends readonly (infer TEntry)[] ? readonly PublicInvoke<TEntry>[] : T extends {
+  src: infer TSrc;
+} ? {
+  src: TSrc;
+} : never;
+type PublicStateField<T, K extends PropertyKey> = T extends Record<K, infer TValue> ? { [P in K]: TValue; } : {};
+type PublicStateSchema<T extends StateSchema> = {
+  input: T extends {
+    input: infer TInput;
+  } ? TInput : undefined;
+} & PublicStateField<T, 'id'> & PublicStateField<T, 'version'> & PublicStateField<T, 'route'> & PublicStateField<T, 'type'> & PublicStateField<T, 'history'> & PublicStateField<T, 'target'> & PublicStateField<T, 'initial'> & PublicStateField<T, 'contextSchema'> & PublicStateField<T, 'outputSchema'> & PublicStateField<T, 'internalEvents'> & (T extends {
+  invoke: infer TInvoke;
+} ? {
+  invoke: PublicInvoke<TInvoke>;
+} : {}) & (T extends {
+  states: infer TStates extends Record<string, StateSchema>;
+} ? {
+  states: { [K in keyof TStates]: PublicStateSchema<TStates[K]>; };
+} : {});
+/** Machine config without setup-declared state contracts. */
+type SetupMachineConfigBase<_TStateSchemas extends Record<string, SetupStateSchema>, TStateKeys extends string, TSchemas extends SetupSchemas, 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, TEvent extends EventObject, TChildren extends Record<string, AnyActorRef | undefined>, TDelays extends string, TTag extends string, TEmitted extends EventObject, TStateMeta extends MetaObject, TTransitionMeta extends MetaObject, TActionMap extends Sources['actions'], TActorMap extends Sources['actors'], TGuardMap extends Sources['guards'], TDelayMap extends Sources['delays'], TSystemRegistry extends SystemRegistry, TContextRequired extends boolean, TRootDelays extends string = TDelays, TRootActionMap extends Sources['actions'] = TActionMap, TRootActorMap extends Sources['actors'] = TActorMap, TRootGuardMap extends Sources['guards'] = TGuardMap> = Omit<Next_MachineConfig<SetupOrConfigSchema<TSchemas, 'context', TContextSchema>, SetupOrConfigSchemaMap<TSchemas, 'events', TEventSchemaMap>, SetupOrConfigSchemaMap<TSchemas, 'internalEvents', TInternalEventSchemaMap>, SetupOrConfigSchemaMap<TSchemas, 'emitted', TEmittedSchemaMap>, SetupOrConfigSchema<TSchemas, 'input', TInputSchema>, SetupOrConfigSchema<TSchemas, 'output', TOutputSchema>, SetupOrConfigSchema<TSchemas, 'meta', TMetaSchema>, SetupOrConfigSchema<TSchemas, 'transitionMeta', TTransitionMetaSchema>, SetupOrConfigSchema<TSchemas, 'tags', TTagSchema>, SetupOrConfigSchemaMap<TSchemas, 'children', TChildrenSchemaMap>, TContext, TEvent, TChildren, TDelays, TTag, TActionMap, TActorMap, TGuardMap, TDelayMap, TContextRequired, TSystemRegistry>, 'states' | 'initial' | 'on' | 'always' | 'invoke' | 'actions' | 'actors' | 'guards' | 'delays'> & {
+  actions?: TRootActionMap;
+  actors?: TRootActorMap;
+  guards?: TRootGuardMap & GuardSourceMap<TContext, TEvent>;
+  delays?: { [K in TRootDelays | number]?: number | (({ context, event, stateNode }: {
+    context: TContext;
+    event: TEvent;
+    stateNode: AnyStateNode;
+  }) => number); };
+  initial?: string | {
+    target: string;
+    meta?: TTransitionMeta;
+    description?: string;
+    input?: unknown;
+  } | undefined;
+  on?: StateTransitions<UncheckedSetupStateSchemas, TContext, SetupContextShape<TSchemas, TContextSchema, TContext>, TEvent, TEmitted, TChildren, TTransitionMeta, TActionMap, TActorMap, TGuardMap, TDelayMap, TSystemRegistry>;
+  always?: StateTransitionConfigOrTarget<UncheckedSetupStateSchemas, TContext, SetupContextShape<TSchemas, TContextSchema, TContext>, TEvent, TEvent, TEmitted, TChildren, TTransitionMeta, TActionMap, TActorMap, TGuardMap, TDelayMap, TSystemRegistry>;
+  invoke?: SingleOrArray<SetupInvokeConfig<UncheckedSetupStateSchemas, TContext, SetupContextShape<TSchemas, TContextSchema, TContext>, TEvent, TEmitted, TChildren, TTransitionMeta, TActionMap, TActorMap, TGuardMap, TDelayMap, TSystemRegistry, SetupInput<TSchemas, TInputSchema>>>;
+  states?: StatesWithInput<UncheckedSetupStateSchemas, UncheckedSetupStateSchemas, TContext, SetupContextShape<TSchemas, TContextSchema, TContext>, TEvent, TChildren, TDelays, TTag, SetupOutput<TSchemas, TOutputSchema>, TEmitted, TStateMeta, TTransitionMeta, TActionMap, TActorMap, TGuardMap, TDelayMap, TSystemRegistry, TStateKeys>;
+};
+/** Machine config with typed state input */
+type SetupMachineConfig<TStateSchemas extends Record<string, SetupStateSchema>, TStateKeys extends string, TSchemas extends SetupSchemas, 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, TEvent extends EventObject, TChildren extends Record<string, AnyActorRef | undefined>, TDelays extends string, TTag extends string, TEmitted extends EventObject, TStateMeta extends MetaObject, TTransitionMeta extends MetaObject, TActionMap extends Sources['actions'], TActorMap extends Sources['actors'], TGuardMap extends Sources['guards'], TDelayMap extends Sources['delays'], TSystemRegistry extends SystemRegistry, TContextRequired extends boolean, TRootDelays extends string = TDelays, TRootActionMap extends Sources['actions'] = TActionMap, TRootActorMap extends Sources['actors'] = TActorMap, TRootGuardMap extends Sources['guards'] = TGuardMap> = HasExplicitSetupStateContracts<TStateSchemas> extends true ? Omit<SetupMachineConfigBase<TStateSchemas, TStateKeys, TSchemas, TContextSchema, TEventSchemaMap, TInternalEventSchemaMap, TEmittedSchemaMap, TInputSchema, TOutputSchema, TMetaSchema, TTransitionMetaSchema, TTagSchema, TChildrenSchemaMap, TContext, TEvent, TChildren, TDelays, TTag, TEmitted, TStateMeta, TTransitionMeta, TActionMap, TActorMap, TGuardMap, TDelayMap, TSystemRegistry, TContextRequired, TRootDelays, TRootActionMap, TRootActorMap, TRootGuardMap>, 'states' | 'initial' | 'on' | 'always' | 'invoke'> & {
+  initial?: SetupInitialStateKey<TStateSchemas, TStateKeys> | RootInitialTransitionWithInput<TStateSchemas, TContext, TEvent, TTransitionMeta> | undefined;
+  on?: StateTransitions<TStateSchemas, TContext, SetupContextShape<TSchemas, TContextSchema, TContext>, TEvent, TEmitted, TChildren, TTransitionMeta, TActionMap, TActorMap, TGuardMap, TDelayMap, TSystemRegistry, undefined, RootSetupStateTarget<TStateSchemas>, RootSetupStateTarget<TStateSchemas>>;
+  always?: StateTransitionConfigOrTarget<TStateSchemas, TContext, SetupContextShape<TSchemas, TContextSchema, TContext>, TEvent, TEvent, TEmitted, TChildren, TTransitionMeta, TActionMap, TActorMap, TGuardMap, TDelayMap, TSystemRegistry, undefined, RootSetupStateTarget<TStateSchemas>, RootSetupStateTarget<TStateSchemas>>;
+  invoke?: SingleOrArray<SetupInvokeConfig<RootSetupStateTransitionSchemas<TStateSchemas>, TContext, SetupContextShape<TSchemas, TContextSchema, TContext>, TEvent, TEmitted, TChildren, TTransitionMeta, TActionMap, TActorMap, TGuardMap, TDelayMap, TSystemRegistry, SetupInput<TSchemas, TInputSchema>>>;
+  states?: StatesWithInput<TStateSchemas, TStateSchemas, TContext, SetupContextShape<TSchemas, TContextSchema, TContext>, TEvent, TChildren, TDelays, TTag, SetupOutput<TSchemas, TOutputSchema>, TEmitted, TStateMeta, TTransitionMeta, TActionMap, TActorMap, TGuardMap, TDelayMap, TSystemRegistry, TStateKeys>;
+} : SetupMachineConfigBase<TStateSchemas, TStateKeys, TSchemas, TContextSchema, TEventSchemaMap, TInternalEventSchemaMap, TEmittedSchemaMap, TInputSchema, TOutputSchema, TMetaSchema, TTransitionMetaSchema, TTagSchema, TChildrenSchemaMap, TContext, TEvent, TChildren, TDelays, TTag, TEmitted, TStateMeta, TTransitionMeta, TActionMap, TActorMap, TGuardMap, TDelayMap, TSystemRegistry, TContextRequired, TRootDelays, TRootActionMap, TRootActorMap, TRootGuardMap>;
+/** States config type that provides typed input for known states */
+type StatesWithInput<TRootStateSchemas extends Record<string, SetupStateSchema>, TStateSchemas extends Record<string, SetupStateSchema>, TContext extends MachineContext, TContextShape, TEvent extends EventObject, TChildren extends Record<string, AnyActorRef | undefined>, TDelays extends string, TTag extends string, TOutput, TEmitted extends EventObject, TStateMeta extends MetaObject, TTransitionMeta extends MetaObject, TActionMap extends Sources['actions'], TActorMap extends Sources['actors'], TGuardMap extends Sources['guards'], TDelayMap extends Sources['delays'], TSystemRegistry extends SystemRegistry, TStateKeys extends string = SetupStateKey<TStateSchemas>> = { [K in TStateKeys]?: StateNodeConfigWithNestedInput<StateSchemasWithKeys<TRootStateSchemas, TStateKeys>, K extends keyof TStateSchemas ? TStateSchemas[K] : {}, TContext, TContextShape, TEvent, TChildren, TDelays, TTag, TOutput, TEmitted, TStateMeta, TTransitionMeta, TActionMap, TActorMap, TGuardMap, TDelayMap, TSystemRegistry>; };
+/** State node config that recursively applies typed input for nested states */
+type StateNodeConfigWithNestedInputBase<TSiblingStateSchemas extends Record<string, SetupStateSchema>, TStateSchema extends SetupStateSchema, TContext extends MachineContext, TContextShape, TEvent extends EventObject, TChildren extends Record<string, AnyActorRef | undefined>, TDelays extends string, TTag extends string, TOutput, TEmitted extends EventObject, TStateMeta extends MetaObject, TTransitionMeta extends MetaObject, TActionMap extends Sources['actions'], TActorMap extends Sources['actors'], TGuardMap extends Sources['guards'], TDelayMap extends Sources['delays'], TSystemRegistry extends SystemRegistry> = WithNestedStates<DistributiveOmit<Next_StateNodeConfig<ActiveStateContext<TStateSchema, TContext, TContextShape>, TEvent, TDelays, TTag, StateOutput<TStateSchema, TOutput>, TEmitted, TStateMeta, TChildren, TActionMap, TActorMap, TGuardMap, TDelayMap, StateInput<TStateSchema>, Record<string, unknown>, TSystemRegistry, StateCompletionOutput<TStateSchema>, TTransitionMeta>, 'on' | 'always' | 'initial' | 'invoke' | 'onDone' | 'onError' | 'onTimeout' | 'after'> & {
+  initial?: TStateSchema['states'] extends Record<string, SetupStateSchema> ? SetupStateKey<TStateSchema['states']> | (string & {}) | InitialTransitionWithInput<TStateSchema['states'], ActiveStateContext<TStateSchema, TContext, TContextShape>, TEvent, TTransitionMeta> : string | {
+    target: string;
+    meta?: TTransitionMeta;
+    description?: string;
+    input?: Record<string, unknown>;
+  } | undefined;
+} & {
+  on?: StateTransitions<SetupStateTransitionSchemas<TSiblingStateSchemas, TStateSchema>, ActiveStateContext<TStateSchema, TContext, TContextShape>, ActiveStateContextShape<TStateSchema, TContextShape>, TEvent, TEmitted, TChildren, TTransitionMeta, TActionMap, TActorMap, TGuardMap, TDelayMap, TSystemRegistry, StateInput<TStateSchema>>;
+  always?: StateTransitionConfigOrTarget<SetupStateTransitionSchemas<TSiblingStateSchemas, TStateSchema>, ActiveStateContext<TStateSchema, TContext, TContextShape>, ActiveStateContextShape<TStateSchema, TContextShape>, TEvent, TEvent, TEmitted, TChildren, TTransitionMeta, TActionMap, TActorMap, TGuardMap, TDelayMap, TSystemRegistry, StateInput<TStateSchema>>;
+  invoke?: SingleOrArray<SetupInvokeConfig<SetupStateTransitionSchemas<TSiblingStateSchemas, TStateSchema>, ActiveStateContext<TStateSchema, TContext, TContextShape>, ActiveStateContextShape<TStateSchema, TContextShape>, TEvent, TEmitted, TChildren, TTransitionMeta, TActionMap, TActorMap, TGuardMap, TDelayMap, TSystemRegistry, StateInput<TStateSchema>>>;
+  onDone?: StateTransitionConfigOrTarget<SetupStateTransitionSchemas<TSiblingStateSchemas, TStateSchema>, ActiveStateContext<TStateSchema, TContext, TContextShape>, ActiveStateContextShape<TStateSchema, TContextShape>, DoneStateEvent<StateCompletionOutput<TStateSchema>>, TEvent, TEmitted, TChildren, TTransitionMeta, TActionMap, TActorMap, TGuardMap, TDelayMap, TSystemRegistry, StateInput<TStateSchema>>;
+  onError?: StateTransitionConfigOrTarget<SetupStateTransitionSchemas<TSiblingStateSchemas, TStateSchema>, ActiveStateContext<TStateSchema, TContext, TContextShape>, ActiveStateContextShape<TStateSchema, TContextShape>, ErrorEvent, TEvent, TEmitted, TChildren, TTransitionMeta, TActionMap, TActorMap, TGuardMap, TDelayMap, TSystemRegistry, StateInput<TStateSchema>>;
+  onTimeout?: StateTransitionConfigOrTarget<SetupStateTransitionSchemas<TSiblingStateSchemas, TStateSchema>, ActiveStateContext<TStateSchema, TContext, TContextShape>, ActiveStateContextShape<TStateSchema, TContextShape>, TimeoutEvent, TEvent, TEmitted, TChildren, TTransitionMeta, TActionMap, TActorMap, TGuardMap, TDelayMap, TSystemRegistry, StateInput<TStateSchema>>;
+  after?: { [K in NoInfer<TDelays> | number | DelayDurationKey]?: StateTransitionConfigOrTarget<SetupStateTransitionSchemas<TSiblingStateSchemas, TStateSchema>, ActiveStateContext<TStateSchema, TContext, TContextShape>, ActiveStateContextShape<TStateSchema, TContextShape>, AfterEvent, TEvent, TEmitted, TChildren, TTransitionMeta, TActionMap, TActorMap, TGuardMap, TDelayMap, TSystemRegistry, StateInput<TStateSchema>>; };
+}, TStateSchema['states'] extends Record<string, SetupStateSchema> ? StatesWithInput<SetupStateSchemasWithParentType<WithRootSetupStateSchemas<TStateSchema['states'], RootSetupStateSchemas<TSiblingStateSchemas>>, TStateSchema extends {
+  type: infer TType extends SetupStateType;
+} ? TType : never>, TStateSchema['states'], TContext, ActiveStateContextShape<TStateSchema, TContextShape>, TEvent, TChildren, TDelays, TTag, TOutput, TEmitted, TStateMeta, TTransitionMeta, TActionMap, TActorMap, TGuardMap, TDelayMap, TSystemRegistry> : { [K in string]?: StateNodeConfigWithNestedInput<UncheckedSetupStateSchemas, SetupStateSchema, TContext, ActiveStateContextShape<TStateSchema, TContextShape>, TEvent, TChildren, TDelays, TTag, TOutput, TEmitted, TStateMeta, TTransitionMeta, TActionMap, TActorMap, TGuardMap, TDelayMap, TSystemRegistry>; }>;
+type StateNodeConfigWithNestedInput<TSiblingStateSchemas extends Record<string, SetupStateSchema>, TStateSchema extends SetupStateSchema, TContext extends MachineContext, TContextShape, TEvent extends EventObject, TChildren extends Record<string, AnyActorRef | undefined>, TDelays extends string, TTag extends string, TOutput, TEmitted extends EventObject, TStateMeta extends MetaObject, TTransitionMeta extends MetaObject, TActionMap extends Sources['actions'], TActorMap extends Sources['actors'], TGuardMap extends Sources['guards'], TDelayMap extends Sources['delays'], TSystemRegistry extends SystemRegistry> = SetupStateNodeContract<TStateSchema, StateNodeConfigWithNestedInputBase<TSiblingStateSchemas, TStateSchema, TContext, TContextShape, TEvent, TChildren, TDelays, TTag, TOutput, TEmitted, TStateMeta, TTransitionMeta, TActionMap, TActorMap, TGuardMap, TDelayMap, TSystemRegistry>, TContext, TEvent, TSiblingStateSchemas>;
+type StateTransitions<TStateSchemas extends Record<string, SetupStateSchema>, TContext extends MachineContext, TContextShape, TEvent extends EventObject, TEmitted extends EventObject, TChildren extends Record<string, AnyActorRef | undefined>, TMeta extends MetaObject, TActionMap extends Sources['actions'], TActorMap extends Sources['actors'], TGuardMap extends Sources['guards'], TDelayMap extends Sources['delays'], TSystemRegistry extends SystemRegistry, TInput = undefined, TTarget extends string = SetupStateTarget<TStateSchemas>, TKnownTarget extends string = KnownSetupStateTarget<TStateSchemas>> = { [K in EventDescriptor<TEvent>]?: StateTransitionConfigOrTarget<TStateSchemas, TContext, TContextShape, ExtractEvent<TEvent, K>, TEvent, TEmitted, TChildren, TMeta, TActionMap, TActorMap, TGuardMap, TDelayMap, TSystemRegistry, TInput, TTarget, TKnownTarget>; } & (string extends TEvent['type'] ? unknown : { [K in `xstate.${string}`]?: StateTransitionConfigOrTarget<TStateSchemas, TContext, TContextShape, {
+  type: K;
+}, TEvent, TEmitted, TChildren, TMeta, TActionMap, TActorMap, TGuardMap, TDelayMap, TSystemRegistry, TInput, TTarget, TKnownTarget>; });
+type InvokeDoneEvent<TInvoke> = TInvoke extends {
+  onDone?: Next_TransitionConfigOrTarget<infer _TContext, infer TDoneEvent, infer _TEvent, infer _TEmitted, infer _TActionMap, infer _TActorMap, infer _TGuardMap, infer _TDelayMap, infer _TMeta>;
+} ? Cast<TDoneEvent, EventObject> : DoneActorEvent;
+type PlainSetupInvokeConfig<TStateSchemas extends Record<string, SetupStateSchema>, TContext extends MachineContext, TContextShape, TEvent extends EventObject, TEmitted extends EventObject, TChildren extends Record<string, AnyActorRef | undefined>, TMeta extends MetaObject, TActionMap extends Sources['actions'], TActorMap extends Sources['actors'], TGuardMap extends Sources['guards'], TDelayMap extends Sources['delays'], TSystemRegistry extends SystemRegistry, TStateInput = undefined> = Next_InvokeConfig<TContext, TEvent, TEmitted, TChildren, TActionMap, TActorMap, TGuardMap, TDelayMap, TMeta, TSystemRegistry, TStateInput> extends (infer TInvoke) ? TInvoke extends any ? DistributiveOmit<TInvoke, 'onDone' | 'onError' | 'onSnapshot' | 'onTimeout'> & {
+  onDone?: TInvoke extends {
+    onDone?: infer TOnDone;
+  } ? [Extract<NonNullable<TOnDone>, (...args: any[]) => unknown>] extends [never] ? undefined | StateTransitionObjectConfig<TStateSchemas, TContext, TContextShape, DoneActorEvent, TChildren, TMeta, TActionMap, TActorMap, TGuardMap, TDelayMap, TSystemRegistry, false> : StateTransitionConfigOrTarget<TStateSchemas, TContext, TContextShape, InvokeDoneEvent<TInvoke>, TEvent, TEmitted, TChildren, TMeta, TActionMap, TActorMap, TGuardMap, TDelayMap, TSystemRegistry> : never;
+  onError?: StateTransitionConfigOrTarget<TStateSchemas, TContext, TContextShape, InvokeErrorEvent<TInvoke, TActorMap>, TEvent, TEmitted, TChildren, TMeta, TActionMap, TActorMap, TGuardMap, TDelayMap, TSystemRegistry>;
+  onSnapshot?: StateTransitionConfigOrTarget<TStateSchemas, TContext, TContextShape, SnapshotEvent<any>, TEvent, TEmitted, TChildren, TMeta, TActionMap, TActorMap, TGuardMap, TDelayMap, TSystemRegistry>;
+  onTimeout?: StateTransitionConfigOrTarget<TStateSchemas, TContext, TContextShape, TEvent, TEvent, TEmitted, TChildren, TMeta, TActionMap, TActorMap, TGuardMap, TDelayMap, TSystemRegistry>;
+} : never : never;
+declare const createdInvoke: unique symbol;
+/** @public Type-only scope carried by setup-created invoke configs. */
+interface CreatedInvoke<TLogic extends AnyActorLogic, TContext extends MachineContext, TContextShape, TStateSchemas extends Record<string, SetupStateSchema>, TStateInput, TConfig = unknown> {
+  src: NoInfer<TLogic>;
+  readonly [createdInvoke]: {
+    context: TContext;
+    contextShape: TContextShape;
+    states: TStateSchemas;
+    input: TStateInput;
+    child: NoInfer<{
+      id: TConfig extends {
+        id: infer TId;
+      } ? TId : undefined;
+      ref: ActorRefFromLogic<TLogic>;
+    }>;
+  };
+  readonly [createdInvokeConfig]: NoInfer<TConfig>;
+}
+type CreatedInvokeTransitionData<TTransition> = TTransition extends ((...args: any[]) => infer TResult) ? CreatedInvokeTransitionData<TResult> : TTransition extends {
+  target: infer TTarget;
+} ? {
+  target: TTarget;
+} & (TTransition extends {
+  input: infer TInput;
+} ? {
+  input: TInput extends ((...args: any[]) => infer TResult) ? TResult : TInput;
+} : unknown) : {};
+type CreatedInvokeValidationConfig<TConfig> = TConfig extends unknown ? { [K in keyof TConfig as K extends 'id' | 'onDone' | 'onError' | 'onSnapshot' | 'onTimeout' ? K : never]: K extends 'id' ? TConfig[K] : CreatedInvokeTransitionData<TConfig[K]>; } : never;
+type CreatedInvokeId<TLogic extends AnyActorLogic, TChildren> = string extends keyof TChildren ? {
+  id?: string;
+} : [keyof TChildren] extends [never] ? {
+  id?: string;
+} : {
+  id: { [K in keyof TChildren & string]: ActorRefFromLogic<TLogic> extends NonNullable<TChildren[K]> ? K : never; }[keyof TChildren & string];
+};
+type CreatedInvokeChildContract<TChildren> = string extends keyof TChildren ? unknown : [keyof TChildren] extends [never] ? unknown : { [K in keyof TChildren & string]: {
+  id: K;
+  ref: NonNullable<TChildren[K]>;
+}; }[keyof TChildren & string];
+type ValidateCreatedInvokeChild<TInvoke, TChildren> = TInvoke extends {
+  readonly [createdInvoke]: unknown;
+} ? {
+  readonly [createdInvoke]: {
+    child: CreatedInvokeChildContract<TChildren>;
+  };
+} : TInvoke extends readonly unknown[] ? { [K in keyof TInvoke]: ValidateCreatedInvokeChild<TInvoke[K], TChildren>; } : unknown;
+type ValidateCreatedInvokeChildren<TConfig, TChildren> = (TConfig extends {
+  invoke: infer TInvoke;
+} ? {
+  invoke?: ValidateCreatedInvokeChild<TInvoke, TChildren>;
+} : unknown) & (TConfig extends {
+  states: infer TStates;
+} ? {
+  states?: { [K in keyof TStates]: ValidateCreatedInvokeChildren<TStates[K], TChildren>; };
+} : unknown);
+type CreatedInvokeInput<TLogic extends AnyActorLogic, TArgs, TInput = InputFrom<NoInfer<TLogic>>, TValue = TInput | ((args: TArgs) => TInput)> = undefined extends TInput ? {
+  input?: TValue;
+} : {
+  input: TValue;
+};
+/** @public An invoke config whose callbacks are checked against its source logic. */
+type CreateInvokeConfig<TLogic extends AnyActorLogic, TStateSchemas extends Record<string, SetupStateSchema>, TContext extends MachineContext, TContextShape, TEvent extends EventObject, TEmitted extends EventObject, TChildren extends Record<string, AnyActorRef | undefined>, TMeta extends MetaObject, TActionMap extends Sources['actions'], TActorMap extends Sources['actors'], TGuardMap extends Sources['guards'], TDelayMap extends Sources['delays'], TSystemRegistry extends SystemRegistry, TStateInput = undefined> = CreatedInvokeId<NoInfer<TLogic>, TChildren> & CreatedInvokeInput<TLogic, InvokeInputArgs<TContext, TEvent, TEmitted, TChildren, TStateInput>> & Omit<Next_InvokeConfigBase<TContext, TEvent, TEmitted, TChildren, TActionMap, TActorMap, TGuardMap, TDelayMap, TMeta, TSystemRegistry, DoneActorEvent<OutputFrom<NoInfer<TLogic>>>, ErrorActorEvent<ErrorFrom<NoInfer<TLogic>>>>, 'id' | 'onDone' | 'onError' | 'onSnapshot' | 'onTimeout'> & {
+  src: TLogic;
+  schemas?: never;
+  onDone?: StateTransitionConfigOrTarget<TStateSchemas, TContext, TContextShape, DoneActorEvent<OutputFrom<NoInfer<TLogic>>>, TEvent, TEmitted, TChildren, TMeta, TActionMap, TActorMap, TGuardMap, TDelayMap, TSystemRegistry>;
+  onError?: StateTransitionConfigOrTarget<TStateSchemas, TContext, TContextShape, ErrorActorEvent<ErrorFrom<NoInfer<TLogic>>>, TEvent, TEmitted, TChildren, TMeta, TActionMap, TActorMap, TGuardMap, TDelayMap, TSystemRegistry>;
+  onSnapshot?: StateTransitionConfigOrTarget<TStateSchemas, TContext, TContextShape, SnapshotEvent<SnapshotFrom<NoInfer<TLogic>>>, TEvent, TEmitted, TChildren, TMeta, TActionMap, TActorMap, TGuardMap, TDelayMap, TSystemRegistry>;
+  onTimeout?: StateTransitionConfigOrTarget<TStateSchemas, TContext, TContextShape, ActorTimeoutEvent, TEvent, TEmitted, TChildren, TMeta, TActionMap, TActorMap, TGuardMap, TDelayMap, TSystemRegistry>;
+};
+type AsyncInvokeSchemaOutput<TSchema extends StandardSchemaV1, TFallback> = StandardSchemaV1 extends TSchema ? TFallback : StandardSchemaV1.InferOutput<TSchema>;
+/** @public An inline async invoke whose schemas and function determine its actor types. */
+type CreateAsyncInvokeConfig<TOutput, TInputSchema extends StandardSchemaV1, TOutputSchema extends StandardSchemaV1, TErrorSchema extends StandardSchemaV1, TStateSchemas extends Record<string, SetupStateSchema>, TContext extends MachineContext, TContextShape, TEvent extends EventObject, TEmitted extends EventObject, TChildren extends Record<string, AnyActorRef | undefined>, TMeta extends MetaObject, TActionMap extends Sources['actions'], TActorMap extends Sources['actors'], TGuardMap extends Sources['guards'], TDelayMap extends Sources['delays'], TSystemRegistry extends SystemRegistry, TStateInput = undefined> = CreatedInvokeId<AsyncActorLogic<NoInfer<TOutput>, AsyncInvokeSchemaOutput<NoInfer<TInputSchema>, NonReducibleUnknown>, EventObject, AsyncInvokeSchemaOutput<NoInfer<TErrorSchema>, unknown>>, TChildren> & CreatedInvokeInput<AsyncActorLogic<unknown, AsyncInvokeSchemaOutput<NoInfer<TInputSchema>, NonReducibleUnknown>>, InvokeInputArgs<TContext, TEvent, TEmitted, TChildren, TStateInput>> & Omit<Next_InvokeConfigBase<TContext, TEvent, TEmitted, TChildren, TActionMap, TActorMap, TGuardMap, TDelayMap, TMeta, TSystemRegistry>, 'id' | 'onDone' | 'onError' | 'onSnapshot' | 'onTimeout'> & {
+  schemas?: {
+    input?: TInputSchema;
+    output?: StandardSchemaV1 extends TOutputSchema ? never : TOutputSchema;
+    error?: TErrorSchema;
+  };
+  src: (...args: Parameters<LogicFunction<AsyncInvokeSchemaOutput<NoInfer<TOutputSchema>, unknown>, AsyncInvokeSchemaOutput<NoInfer<TInputSchema>, NonReducibleUnknown>>>) => PromiseLike<TOutput>;
+  onDone?: StateTransitionConfigOrTarget<TStateSchemas, TContext, TContextShape, DoneActorEvent<NoInfer<TOutput>>, TEvent, TEmitted, TChildren, TMeta, TActionMap, TActorMap, TGuardMap, TDelayMap, TSystemRegistry, undefined, SetupStateTarget<TStateSchemas>, KnownSetupStateTarget<TStateSchemas>, NoInfer<TOutput>>;
+  onError?: NoInfer<StateTransitionConfigOrTarget<TStateSchemas, TContext, TContextShape, ErrorActorEvent<NoInfer<AsyncInvokeSchemaOutput<TErrorSchema, unknown>>>, TEvent, TEmitted, TChildren, TMeta, TActionMap, TActorMap, TGuardMap, TDelayMap, TSystemRegistry>>;
+  onSnapshot?: NoInfer<StateTransitionConfigOrTarget<TStateSchemas, TContext, TContextShape, SnapshotEvent<AsyncSnapshot<TOutput, NoInfer<AsyncInvokeSchemaOutput<TInputSchema, NonReducibleUnknown>>, NoInfer<AsyncInvokeSchemaOutput<TErrorSchema, unknown>>>>, TEvent, TEmitted, TChildren, TMeta, TActionMap, TActorMap, TGuardMap, TDelayMap, TSystemRegistry>>;
+  onTimeout?: StateTransitionConfigOrTarget<TStateSchemas, TContext, TContextShape, ActorTimeoutEvent, TEvent, TEmitted, TChildren, TMeta, TActionMap, TActorMap, TGuardMap, TDelayMap, TSystemRegistry>;
+};
+type SetupInvokeConfig<TStateSchemas extends Record<string, SetupStateSchema>, TContext extends MachineContext, TContextShape, TEvent extends EventObject, TEmitted extends EventObject, TChildren extends Record<string, AnyActorRef | undefined>, TMeta extends MetaObject, TActionMap extends Sources['actions'], TActorMap extends Sources['actors'], TGuardMap extends Sources['guards'], TDelayMap extends Sources['delays'], TSystemRegistry extends SystemRegistry, TStateInput = undefined> = (PlainSetupInvokeConfig<TStateSchemas, TContext, TContextShape, TEvent, TEmitted, TChildren, TMeta, TActionMap, TActorMap, TGuardMap, TDelayMap, TSystemRegistry, TStateInput> & {
+  readonly [createdInvoke]?: never;
+}) | {
+  readonly [createdInvoke]: {
+    context: TContext;
+    contextShape: TContextShape;
+    states: TStateSchemas extends UncheckedSetupStateSchemas ? Record<string, SetupStateSchema> : TStateSchemas;
+    input: TStateInput;
+  };
+};
+type InvokeErrorEvent<TInvoke, TActorMap extends Sources['actors']> = TInvoke extends {
+  src: infer TSrc;
+} ? TSrc extends keyof TActorMap & string ? ErrorActorEvent<ErrorFrom<TActorMap[TSrc]>> : TSrc extends AnyActorLogic ? ErrorActorEvent<ErrorFrom<TSrc>> : ErrorActorEvent : ErrorActorEvent;
+type StateTransitionConfigOrTarget<TStateSchemas extends Record<string, SetupStateSchema>, TContext extends MachineContext, TContextShape, TExpressionEvent extends EventObject, TEvent extends EventObject, TEmitted extends EventObject, TChildren extends Record<string, AnyActorRef | undefined>, TMeta extends MetaObject, TActionMap extends Sources['actions'], TActorMap extends Sources['actors'], TGuardMap extends Sources['guards'], TDelayMap extends Sources['delays'], TSystemRegistry extends SystemRegistry, TInput = undefined, TTarget extends string = SetupStateTarget<TStateSchemas>, TKnownTarget extends string = KnownSetupStateTarget<TStateSchemas>, TOutput = OutputArg<TExpressionEvent>['output']> = undefined | StateTransitionObjectConfig<TStateSchemas, TContext, TContextShape, TExpressionEvent, TChildren, TMeta, TActionMap, TActorMap, TGuardMap, TDelayMap, TSystemRegistry, true, TTarget, TKnownTarget> | StateTransitionFunction<TStateSchemas, TContext, TContextShape, TExpressionEvent, TEvent, TEmitted, TChildren, TMeta, TActionMap, TActorMap, TGuardMap, TDelayMap, TSystemRegistry, TInput, TTarget, TKnownTarget, TOutput>;
+type StateTransitionObjectConfig<TStateSchemas extends Record<string, SetupStateSchema>, TContext extends MachineContext, TContextShape, TExpressionEvent extends EventObject, TChildren extends Record<string, AnyActorRef | undefined>, TMeta extends MetaObject, TActionMap extends Sources['actions'], TActorMap extends Sources['actors'], TGuardMap extends Sources['guards'], TDelayMap extends Sources['delays'], TSystemRegistry extends SystemRegistry, TAllowContextMapper extends boolean = true, TTarget extends string = SetupStateTarget<TStateSchemas>, TKnownTarget extends string = KnownSetupStateTarget<TStateSchemas>> = (StateTransitionResult<TStateSchemas, TContext, TContextShape, TMeta, TExpressionEvent, TChildren, TActionMap, TActorMap, TGuardMap, TDelayMap, TSystemRegistry, TAllowContextMapper, TTarget, TKnownTarget> & {
+  description?: string;
+}) | {
+  target: TTarget[];
+  context?: StateTransitionContext<TAllowContextMapper, TContext, TContextShape, TContextShape, TContext, TExpressionEvent, TChildren, TActionMap, TActorMap, TGuardMap, TDelayMap, TSystemRegistry>;
+  description?: string;
+  reenter?: boolean;
+  meta?: TMeta;
+  input?: Record<string, unknown> | ((args: {
+    context: TContext;
+    event: TExpressionEvent;
+  } & OutputArg<TExpressionEvent>) => Record<string, unknown>);
+};
+type StateTransitionContextMapper<TContext extends MachineContext, TContextShape, TTargetContextShape, TResolvedTargetContext extends MachineContext, TExpressionEvent extends EventObject, TChildren extends Record<string, AnyActorRef | undefined>, TActionMap extends Sources['actions'], TActorMap extends Sources['actors'], TGuardMap extends Sources['guards'], TDelayMap extends Sources['delays'], TSystemRegistry extends SystemRegistry> = (args: {
+  context: TContext;
+  event: TExpressionEvent;
+  self: AnyActorRef;
+  parent: AnyActorRef | undefined;
+  value: StateValue;
+  children: TChildren;
+  system: SystemRuntime<TSystemRegistry>;
+  actions: TActionMap;
+  actors: Compute<CallbackActors<TActorMap>>;
+  guards: TGuardMap;
+  delays: TDelayMap;
+} & OutputArg<TExpressionEvent>) => ContextPatch<TContextShape, TTargetContextShape, TResolvedTargetContext>;
+type StateTransitionContextOrMapper<TContext extends MachineContext, TContextShape, TTargetContextShape, TResolvedTargetContext extends MachineContext, TExpressionEvent extends EventObject, TChildren extends Record<string, AnyActorRef | undefined>, TActionMap extends Sources['actions'], TActorMap extends Sources['actors'], TGuardMap extends Sources['guards'], TDelayMap extends Sources['delays'], TSystemRegistry extends SystemRegistry> = ContextPatch<TContextShape, TTargetContextShape, TResolvedTargetContext> | StateTransitionContextMapper<TContext, TContextShape, TTargetContextShape, TResolvedTargetContext, TExpressionEvent, TChildren, TActionMap, TActorMap, TGuardMap, TDelayMap, TSystemRegistry>;
+type StateTransitionContext<TAllowMapper extends boolean, TContext extends MachineContext, TContextShape, TTargetContextShape, TResolvedTargetContext extends MachineContext, TExpressionEvent extends EventObject, TChildren extends Record<string, AnyActorRef | undefined>, TActionMap extends Sources['actions'], TActorMap extends Sources['actors'], TGuardMap extends Sources['guards'], TDelayMap extends Sources['delays'], TSystemRegistry extends SystemRegistry> = TAllowMapper extends true ? StateTransitionContextOrMapper<TContext, TContextShape, TTargetContextShape, TResolvedTargetContext, TExpressionEvent, TChildren, TActionMap, TActorMap, TGuardMap, TDelayMap, TSystemRegistry> : ContextPatch<TContextShape, TTargetContextShape, TResolvedTargetContext>;
+type StateTransitionFunction<TStateSchemas extends Record<string, SetupStateSchema>, TContext extends MachineContext, TContextShape, TExpressionEvent extends EventObject, TEvent extends EventObject, TEmitted extends EventObject, TChildren extends Record<string, AnyActorRef | undefined>, TMeta extends MetaObject, TActionMap extends Sources['actions'], TActorMap extends Sources['actors'], TGuardMap extends Sources['guards'], TDelayMap extends Sources['delays'], TSystemRegistry extends SystemRegistry, TInput = undefined, TTarget extends string = SetupStateTarget<TStateSchemas>, TKnownTarget extends string = KnownSetupStateTarget<TStateSchemas>, TOutput = OutputArg<TExpressionEvent>['output']> = (args: {
+  context: TContext;
+  event: TExpressionEvent;
+  output: TOutput;
+  self: AnyActorRef;
+  parent: AnyActorRef | undefined;
+  value: StateValue;
+  children: TChildren;
+  system: SystemRuntime<TSystemRegistry>;
+  actions: TActionMap;
+  actors: Compute<CallbackActors<TActorMap>>;
+  guards: TGuardMap;
+  delays: TDelayMap;
+  input: TInput;
+}, enq: EnqueueObject<TEvent, TEmitted, TSystemRegistry, Compute<CallbackActors<TActorMap>>, TChildren>) => StateTransitionResult<TStateSchemas, TContext, TContextShape, TMeta, TExpressionEvent, TChildren, TActionMap, TActorMap, TGuardMap, TDelayMap, TSystemRegistry, false, TTarget, TKnownTarget> | void;
+type StateTransitionResult<TStateSchemas extends Record<string, SetupStateSchema>, TContext extends MachineContext, TContextShape, TMeta extends MetaObject, TExpressionEvent extends EventObject, TChildren extends Record<string, AnyActorRef | undefined>, TActionMap extends Sources['actions'], TActorMap extends Sources['actors'], TGuardMap extends Sources['guards'], TDelayMap extends Sources['delays'], TSystemRegistry extends SystemRegistry, TAllowContextMapper extends boolean, TTarget extends string = SetupStateTarget<TStateSchemas>, TKnownTarget extends string = KnownSetupStateTarget<TStateSchemas>> = {
+  target?: never;
+  context?: StateTransitionContext<TAllowContextMapper, TContext, TContextShape, TContextShape, TContext, TExpressionEvent, TChildren, TActionMap, TActorMap, TGuardMap, TDelayMap, TSystemRegistry>;
+  reenter?: boolean;
+  meta?: TMeta;
+} | { [K in TKnownTarget]: {
+  target: K;
+  reenter?: boolean;
+  meta?: TMeta;
+} & SetupStateInputConfig<SetupStateSchemaAtTarget<TStateSchemas, K>, TContext, TExpressionEvent, {
+  context: TContext;
+  event: TExpressionEvent;
+} & OutputArg<TExpressionEvent>> & ([TContextShape] extends [StateContextShape<SetupStateSchemaAtTarget<TStateSchemas, K>, TContextShape>] ? {
+  context?: StateTransitionContext<TAllowContextMapper, TContext, TContextShape, StateContextShape<SetupStateSchemaAtTarget<TStateSchemas, K>, TContextShape>, StateContext<SetupStateSchemaAtTarget<TStateSchemas, K>, TContext>, TExpressionEvent, TChildren, TActionMap, TActorMap, TGuardMap, TDelayMap, TSystemRegistry>;
+} : {
+  context: StateTransitionContext<TAllowContextMapper, TContext, TContextShape, StateContextShape<SetupStateSchemaAtTarget<TStateSchemas, K>, TContextShape>, StateContext<SetupStateSchemaAtTarget<TStateSchemas, K>, TContext>, TExpressionEvent, TChildren, TActionMap, TActorMap, TGuardMap, TDelayMap, TSystemRegistry>;
+}); }[TKnownTarget] | {
+  target: TStateSchemas extends StrictSetupStateTargetsFlag ? never : Exclude<TTarget, TKnownTarget>;
+  context?: StateTransitionContext<TAllowContextMapper, TContext, TContextShape, TContextShape, TContext, TExpressionEvent, TChildren, TActionMap, TActorMap, TGuardMap, TDelayMap, TSystemRegistry>;
+  reenter?: boolean;
+  meta?: TMeta;
+};
+type ContextPatch<TCurrentContext, TTargetContext, TResolvedTargetContext extends MachineContext> = Compute<Partial<TResolvedTargetContext> & Pick<TResolvedTargetContext, Extract<RequiredContextKeys<TCurrentContext, TTargetContext>, string>> & {
+  call?: never;
+  apply?: never;
+  bind?: never;
+}>;
+type RequiredContextKeys<TCurrentContext, TTargetContext> = { [K in keyof TTargetContext]-?: K extends keyof TCurrentContext ? [TCurrentContext[K]] extends [TTargetContext[K]] ? never : K : K; }[keyof TTargetContext];
+/** Initial transition with typed input based on target state */
+type SetupInitialStateKey<TStateSchemas extends Record<string, SetupStateSchema>, TStateKeys extends string> = { [K in TStateKeys]: K extends keyof TStateSchemas ? TStateSchemas[K] extends {
+  type: SetupStateType;
+} ? RequiresStateInput<TStateSchemas[K]> extends true ? never : K : K : K; }[TStateKeys];
+type InitialTransitionWithInput<TStateSchemas extends Record<string, SetupStateSchema>, TContext extends MachineContext, TEvent extends EventObject, TTransitionMeta extends MetaObject> = { [K in keyof TStateSchemas & string]: {
+  target: K;
+  meta?: TTransitionMeta;
+  description?: string;
+} & SetupStateInputConfig<TStateSchemas[K], TContext, TEvent>; }[keyof TStateSchemas & string];
+type RootInitialTransitionWithInput<TStateSchemas extends Record<string, SetupStateSchema>, TContext extends MachineContext, TEvent extends EventObject, TTransitionMeta extends MetaObject> = InitialTransitionWithInput<TStateSchemas, TContext, TEvent, TTransitionMeta> | { [K in RootSetupStateIdTarget<TStateSchemas>]: {
+  target: K;
+  meta?: TTransitionMeta;
+  description?: string;
+} & SetupStateInputConfig<SetupStateSchemaAtTarget<TStateSchemas, K>, TContext, TEvent>; }[RootSetupStateIdTarget<TStateSchemas>];
+/**
+ * Return type of setup()
+ *
+ * @public
+ */
+interface SetupReturn<TStates extends Record<string, SetupStateSchema> = Record<string, SetupStateSchema>, TSchemas extends SetupSchemas = {}, TSetupActionMap extends Sources['actions'] = {}, TSetupActorMap extends Sources['actors'] = {}, TSetupGuardMap extends Sources['guards'] = {}, TSetupDelayMap extends Sources['delays'] = {}, TSetupDelays extends string = Extract<keyof TSetupDelayMap, string>, TSystemRegistry extends SystemRegistry = SystemRegistry, TValidator extends ActorLogicValidator | undefined = undefined> {
+  /** Extends the setup configuration */
+  extend<const TExtendSchemas extends SetupSchemas = {}, const TExtendStates extends Record<string, SetupStateSchema> = {}, TExtendActionMap extends Sources['actions'] = {}, TExtendActorMap extends Sources['actors'] = {}, TExtendGuardMap extends Sources['guards'] = {}, TExtendDelayMap extends Sources['delays'] = {}, const TExtendValidator extends ActorLogicValidator | undefined | InheritedValidator = InheritedValidator>(config: SetupExtensionConfig<TSchemas, TStates, TValidator, TExtendSchemas, TExtendStates, TExtendActionMap, TExtendActorMap, TExtendGuardMap, TExtendDelayMap, TExtendValidator>): SetupReturn<MergeSetupStateSchemas<TStates, TExtendStates>, MergeSourceMaps<TSchemas, TExtendSchemas>, MergeSourceMaps<TSetupActionMap, TExtendActionMap>, MergeSourceMaps<TSetupActorMap, TExtendActorMap>, MergeSourceMaps<TSetupGuardMap, TExtendGuardMap>, MergeSourceMaps<TSetupDelayMap, TExtendDelayMap>, TSetupDelays | Extract<keyof TExtendDelayMap, string>, TSystemRegistry, ResolveExtendedValidator<TValidator, TExtendValidator>>;
+  /** Infers async output from src when no output schema is declared. */
+  createInvoke<TOutput, TContext extends SetupContext<TSchemas, StandardSchemaV1>, const TInputSchema extends StandardSchemaV1 = StandardSchemaV1, const TErrorSchema extends StandardSchemaV1 = StandardSchemaV1, TContextShape = SetupContextShape<TSchemas, StandardSchemaV1, TContext>, TStateSchemas extends Record<string, SetupStateSchema> = TStates, TStateInput = undefined, const TConfig = unknown>(config: TConfig & CreateAsyncInvokeConfig<TOutput, TInputSchema, StandardSchemaV1, TErrorSchema, TStateSchemas, TContext, TContextShape, SetupEvents<TSchemas, Record<string, StandardSchemaV1>>, SetupEmitted<TSchemas, Record<string, StandardSchemaV1>>, SetupChildren<TSchemas, Record<string, StandardSchemaV1>>, SetupTransitionMeta<TSchemas, StandardSchemaV1, StandardSchemaV1>, SetupActions<TSchemas, TSetupActionMap>, TSetupActorMap, SetupGuards<TSchemas, TSetupGuardMap>, TSetupDelayMap, TSystemRegistry, TStateInput>, ...check: unknown extends TConfig ? [] : [TConfig] extends [NoInfer<CreateAsyncInvokeConfig<TOutput, TInputSchema, StandardSchemaV1, TErrorSchema, TStateSchemas, TContext, TContextShape, SetupEvents<TSchemas, Record<string, StandardSchemaV1>>, SetupEmitted<TSchemas, Record<string, StandardSchemaV1>>, SetupChildren<TSchemas, Record<string, StandardSchemaV1>>, SetupTransitionMeta<TSchemas, StandardSchemaV1, StandardSchemaV1>, SetupActions<TSchemas, TSetupActionMap>, TSetupActorMap, SetupGuards<TSchemas, TSetupGuardMap>, TSetupDelayMap, TSystemRegistry, TStateInput>> & ValidateSystemInvoke<Omit<TConfig, 'src'> & {
+    src: AsyncActorLogic<AsyncInvokeSchemaOutput<StandardSchemaV1, TOutput>, AsyncInvokeSchemaOutput<TInputSchema, NonReducibleUnknown>, EventObject, AsyncInvokeSchemaOutput<TErrorSchema, unknown>>;
+  }, TSystemRegistry, TSetupActorMap>] ? [] : [invalidConfig: never]): CreatedInvoke<AsyncActorLogic<AsyncInvokeSchemaOutput<StandardSchemaV1, TOutput>, AsyncInvokeSchemaOutput<TInputSchema, NonReducibleUnknown>, EventObject, AsyncInvokeSchemaOutput<TErrorSchema, unknown>>, TContext, TContextShape, TStateSchemas, TStateInput, CreatedInvokeValidationConfig<TConfig>>;
+  /** Creates a typed inline invoke. Keep the call inline to infer its state scope. */
+  createInvoke<TContext extends SetupContext<TSchemas, StandardSchemaV1>, const TInputSchema extends StandardSchemaV1 = StandardSchemaV1, const TOutputSchema extends StandardSchemaV1 = StandardSchemaV1, const TErrorSchema extends StandardSchemaV1 = StandardSchemaV1, TContextShape = SetupContextShape<TSchemas, StandardSchemaV1, TContext>, TStateSchemas extends Record<string, SetupStateSchema> = TStates, TStateInput = undefined, const TConfig = unknown>(config: TConfig & CreateAsyncInvokeConfig<StandardSchemaV1.InferOutput<TOutputSchema>, TInputSchema, TOutputSchema, TErrorSchema, TStateSchemas, TContext, TContextShape, SetupEvents<TSchemas, Record<string, StandardSchemaV1>>, SetupEmitted<TSchemas, Record<string, StandardSchemaV1>>, SetupChildren<TSchemas, Record<string, StandardSchemaV1>>, SetupTransitionMeta<TSchemas, StandardSchemaV1, StandardSchemaV1>, SetupActions<TSchemas, TSetupActionMap>, TSetupActorMap, SetupGuards<TSchemas, TSetupGuardMap>, TSetupDelayMap, TSystemRegistry, TStateInput> & {
+    schemas: {
+      output: TOutputSchema;
+    };
+  }, ...check: unknown extends TConfig ? [] : [TConfig] extends [NoInfer<CreateAsyncInvokeConfig<StandardSchemaV1.InferOutput<TOutputSchema>, TInputSchema, TOutputSchema, TErrorSchema, TStateSchemas, TContext, TContextShape, SetupEvents<TSchemas, Record<string, StandardSchemaV1>>, SetupEmitted<TSchemas, Record<string, StandardSchemaV1>>, SetupChildren<TSchemas, Record<string, StandardSchemaV1>>, SetupTransitionMeta<TSchemas, StandardSchemaV1, StandardSchemaV1>, SetupActions<TSchemas, TSetupActionMap>, TSetupActorMap, SetupGuards<TSchemas, TSetupGuardMap>, TSetupDelayMap, TSystemRegistry, TStateInput>> & ValidateSystemInvoke<Omit<TConfig, 'src'> & {
+    src: AsyncActorLogic<StandardSchemaV1.InferOutput<TOutputSchema>, AsyncInvokeSchemaOutput<TInputSchema, NonReducibleUnknown>, EventObject, AsyncInvokeSchemaOutput<TErrorSchema, unknown>>;
+  }, TSystemRegistry, TSetupActorMap>] ? [] : [invalidConfig: never]): CreatedInvoke<AsyncActorLogic<StandardSchemaV1.InferOutput<TOutputSchema>, AsyncInvokeSchemaOutput<TInputSchema, NonReducibleUnknown>, EventObject, AsyncInvokeSchemaOutput<TErrorSchema, unknown>>, TContext, TContextShape, TStateSchemas, TStateInput, CreatedInvokeValidationConfig<TConfig>>;
+  /** Creates an invoke from actor logic with its existing source types. */
+  createInvoke<TLogic extends AnyActorLogic, TContext extends SetupContext<TSchemas, StandardSchemaV1>, TContextShape = SetupContextShape<TSchemas, StandardSchemaV1, TContext>, TStateSchemas extends Record<string, SetupStateSchema> = TStates, TStateInput = undefined, const TConfig = unknown>(config: TConfig & CreateInvokeConfig<TLogic, TStateSchemas, TContext, TContextShape, SetupEvents<TSchemas, Record<string, StandardSchemaV1>>, SetupEmitted<TSchemas, Record<string, StandardSchemaV1>>, SetupChildren<TSchemas, Record<string, StandardSchemaV1>>, SetupTransitionMeta<TSchemas, StandardSchemaV1, StandardSchemaV1>, SetupActions<TSchemas, TSetupActionMap>, TSetupActorMap, SetupGuards<TSchemas, TSetupGuardMap>, TSetupDelayMap, TSystemRegistry, TStateInput>, ...check: unknown extends TConfig ? [] : [TConfig] extends [NoInfer<CreateInvokeConfig<TLogic, TStateSchemas, TContext, TContextShape, SetupEvents<TSchemas, Record<string, StandardSchemaV1>>, SetupEmitted<TSchemas, Record<string, StandardSchemaV1>>, SetupChildren<TSchemas, Record<string, StandardSchemaV1>>, SetupTransitionMeta<TSchemas, StandardSchemaV1, StandardSchemaV1>, SetupActions<TSchemas, TSetupActionMap>, TSetupActorMap, SetupGuards<TSchemas, TSetupGuardMap>, TSetupDelayMap, TSystemRegistry, TStateInput>> & ValidateSystemInvoke<TConfig, TSystemRegistry, TSetupActorMap>] ? [] : [invalidConfig: never]): CreatedInvoke<TLogic, TContext, TContextShape, TStateSchemas, TStateInput, CreatedInvokeValidationConfig<TConfig>>;
+  /** Creates a state machine with the setup configuration */
+  createMachine<TContextSchema extends StandardSchemaV1 = StandardSchemaV1, const TEventSchemaMap extends Record<string, StandardSchemaV1> = Record<string, StandardSchemaV1>, const TInternalEventSchemaMap extends Record<string, StandardSchemaV1> = {}, TEmittedSchemaMap extends Record<string, StandardSchemaV1> = Record<string, StandardSchemaV1>, TInputSchema extends StandardSchemaV1 = StandardSchemaV1, TOutputSchema extends StandardSchemaV1 = StandardSchemaV1, TMetaSchema extends StandardSchemaV1 = StandardSchemaV1, TTransitionMetaSchema extends StandardSchemaV1 = TMetaSchema, TTagSchema extends StandardSchemaV1 = StandardSchemaV1, const TChildrenSchemaMap extends Record<string, StandardSchemaV1> = Record<string, StandardSchemaV1>, const TActionSchemaMap extends ActionSchemas = {}, const TGuardSchemaMap extends GuardSchemas = {}, _TEvent extends EventObject = EventObject, TActor extends ProvidedActor = ProvidedActor, TActionMap extends Sources['actions'] = {}, TActorMap extends Sources['actors'] = {}, TGuardMap extends Sources['guards'] = {}, TDelayMap extends Sources['delays'] = {}, TDelays extends string = Extract<keyof TDelayMap, string>, TTag extends SetupTags<TSchemas, TTagSchema> = SetupTags<TSchemas, TTagSchema>, _TInput = unknown, const TStateKeys extends string = SetupStateKey<TStates>, const TConfig extends SetupMachineConfig<TStates, TStateKeys, TSchemas, TContextSchema, TEventSchemaMap, TInternalEventSchemaMap, TEmittedSchemaMap, TInputSchema, TOutputSchema, TMetaSchema, TTransitionMetaSchema, TTagSchema, TChildrenSchemaMap, SetupContext<TSchemas, TContextSchema>, SetupEvents<TSchemas, TEventSchemaMap, TInternalEventSchemaMap> | ChildCompletionEvents<Cast<SetupMergeChildren<SetupChildren<TSchemas, TChildrenSchemaMap>, TActor>, Record<string, AnyActorRef | undefined>>>, Cast<SetupMergeChildren<SetupChildren<TSchemas, TChildrenSchemaMap>, TActor>, Record<string, AnyActorRef | undefined>>, TSetupDelays | TDelays, TTag, SetupEmitted<TSchemas, TEmittedSchemaMap>, SetupMeta<TSchemas, TMetaSchema>, SetupTransitionMeta<TSchemas, TMetaSchema, TTransitionMetaSchema>, MergeSourceMaps<SetupActions<TSchemas, TSetupActionMap>, MergeSourceMaps<InferActions<TActionSchemaMap>, TActionMap>>, MergeSourceMaps<TSetupActorMap, TActorMap>, MergeSourceMaps<SetupGuards<TSchemas, TSetupGuardMap>, MergeSourceMaps<InferGuards<TGuardSchemaMap>, TGuardMap>>, MergeSourceMaps<TSetupDelayMap, TDelayMap>, TSystemRegistry, SetupContextRequired<TSchemas, TContextSchema>, TDelays, TActionMap, TActorMap, TGuardMap> = SetupMachineConfig<TStates, TStateKeys, TSchemas, TContextSchema, TEventSchemaMap, TInternalEventSchemaMap, TEmittedSchemaMap, TInputSchema, TOutputSchema, TMetaSchema, TTransitionMetaSchema, TTagSchema, TChildrenSchemaMap, SetupContext<TSchemas, TContextSchema>, SetupEvents<TSchemas, TEventSchemaMap, TInternalEventSchemaMap> | ChildCompletionEvents<Cast<SetupMergeChildren<SetupChildren<TSchemas, TChildrenSchemaMap>, TActor>, Record<string, AnyActorRef | undefined>>>, Cast<SetupMergeChildren<SetupChildren<TSchemas, TChildrenSchemaMap>, TActor>, Record<string, AnyActorRef | undefined>>, TSetupDelays | TDelays, TTag, SetupEmitted<TSchemas, TEmittedSchemaMap>, SetupMeta<TSchemas, TMetaSchema>, SetupTransitionMeta<TSchemas, TMetaSchema, TTransitionMetaSchema>, MergeSourceMaps<SetupActions<TSchemas, TSetupActionMap>, MergeSourceMaps<InferActions<TActionSchemaMap>, TActionMap>>, MergeSourceMaps<TSetupActorMap, TActorMap>, MergeSourceMaps<SetupGuards<TSchemas, TSetupGuardMap>, MergeSourceMaps<InferGuards<TGuardSchemaMap>, TGuardMap>>, MergeSourceMaps<TSetupDelayMap, TDelayMap>, TSystemRegistry, SetupContextRequired<TSchemas, TContextSchema>, TDelays, TActionMap, TActorMap, TGuardMap>>(config: {
+    schemas?: {
+      events?: TEventSchemaMap;
+      internalEvents?: TInternalEventSchemaMap;
+      context?: TContextSchema;
+      emitted?: TEmittedSchemaMap;
+      actions?: TActionSchemaMap;
+      guards?: TGuardSchemaMap;
+      input?: TInputSchema;
+      output?: TOutputSchema;
+      meta?: TMetaSchema;
+      transitionMeta?: TTransitionMetaSchema;
+      tags?: TTagSchema;
+      children?: TChildrenSchemaMap;
+    } & ([TValidator] extends [ActorLogicValidator] ? ValidateSetupSchemas<InlineMachineSchemas<TContextSchema, TEventSchemaMap, TInternalEventSchemaMap, TEmittedSchemaMap, TActionSchemaMap, TGuardSchemaMap, TInputSchema, TOutputSchema, TMetaSchema, TTransitionMetaSchema, TTagSchema, TChildrenSchemaMap>> : unknown);
+    actions?: TActionMap;
+    actors?: TActorMap;
+    guards?: TGuardMap;
+    delays?: TDelayMap;
+    states?: Record<TStateKeys, unknown>;
+  } & TConfig & RuntimeValidationConstraint<NoInfer<MachineConfigSchemas<TConfig>>, NoInfer<MachineConfigStates<TConfig>>, TValidator> & ValidateSetupDelayReferences<TConfig, TSetupDelays> & ValidateSetupStateContracts<TConfig, TStates> & NoInfer<ValidateCreatedInvokeChildren<TConfig, SetupMergeChildren<SetupChildren<TSchemas, TChildrenSchemaMap>, TActor>>> & ValidateEventDescriptors<TConfig, NoInfer<SetupEvents<TSchemas, TEventSchemaMap, TInternalEventSchemaMap>>> & ValidateRegistryKeys<TConfig, TSystemRegistry, MergeSourceMaps<TSetupActorMap, TActorMap>>): [TConfig] extends [never] ? AnyStateMachine : StateMachine<SetupContext<TSchemas, TContextSchema>, SetupEvents<TSchemas, TEventSchemaMap, TInternalEventSchemaMap> | ([RoutableStateId<SetupMachineStateSchema<TConfig, TStates>>] extends [never] ? never : {
+    type: 'xstate.route';
+    to: RoutableStateId<SetupMachineStateSchema<TConfig, TStates>>;
+  }), Cast<SetupMergeChildren<SetupChildren<TSchemas, TChildrenSchemaMap>, TActor>, Record<string, AnyActorRef | undefined>>, StateValueFromStateSchema<SetupMachineStateSchema<TConfig, TStates>>, TTag & string, SetupInput<TSchemas, TInputSchema>, SetupOrConfigOutput<TSchemas, TOutputSchema, TConfig, TStates>, SetupEmitted<TSchemas, TEmittedSchemaMap>, SetupMeta<TSchemas, TMetaSchema>, PublicStateSchema<SetupMachineStateSchema<TConfig, TStates>>, MergeSourceMaps<SetupActions<TSchemas, TSetupActionMap>, MergeSourceMaps<InferActions<TActionSchemaMap>, TActionMap>>, MergeSourceMaps<TSetupActorMap, TActorMap>, MergeSourceMaps<SetupGuards<TSchemas, TSetupGuardMap>, MergeSourceMaps<InferGuards<TGuardSchemaMap>, TGuardMap>>, DelayMapFromNames<TSetupDelays | TDelays, MergeSourceMaps<TSetupDelayMap, TDelayMap>>, SetupInternalEvents<TSchemas, TInternalEventSchemaMap>, SetupTransitionMeta<TSchemas, TMetaSchema, TTransitionMetaSchema>> & SetupMachineIdentity<TConfig>;
+  /**
+   * Creates a state node config bound to a specific setup-declared state,
+   * addressed by a dotted path (e.g. `'loading'` or `'parent.child'`). The
+   * addressed state's own `input` schema is typed inside `entry`/`exit` args.
+   */
+  createStateConfig<const TPath extends StatePaths<TStates>, const TConfig extends SetupStateNodeConfig<StrictSetupStateSchemas<ResolveStateSiblingsForPath<TStates, TPath>, SetupStateTransitionChildSchemas<ResolveStatePath<TStates, TPath>>, TStates, SetupStateSelfSchema<ResolveStatePath<TStates, TPath>>>, ResolveStatePath<TStates, TPath>, TSchemas, TSetupActionMap, TSetupActorMap, TSetupGuardMap, TSetupDelayMap, TSystemRegistry>>(path: TPath, config: TConfig & ValidateEventDescriptors<TConfig, NoInfer<SetupEvents<TSchemas, Record<string, StandardSchemaV1>>>> & NoInfer<SetupStateNodeTargetArrayInputConstraint<TConfig, StrictSetupStateSchemas<ResolveStateSiblingsForPath<TStates, TPath>, SetupStateTransitionChildSchemas<ResolveStatePath<TStates, TPath>>, TStates, SetupStateSelfSchema<ResolveStatePath<TStates, TPath>>>, ResolveStatePath<TStates, TPath>, SetupStateChildSchemas<ResolveStatePath<TStates, TPath>>>> & NoInfer<SetupStateTargetSetLegality<TConfig, TStates, TPath>> & ValidateSetupHistoryStateInput<TConfig, ResolveStatePath<TStates, TPath>, WithRootSetupStateSchemas<ResolveStateSiblingsForPath<TStates, TPath>, TStates>>): TConfig;
+  /** Creates a state node config with the setup configuration */
+  createStateConfig<const TConfig extends SetupStateNodeConfig<TStates, SetupStateSchema, TSchemas, TSetupActionMap, TSetupActorMap, TSetupGuardMap, TSetupDelayMap, TSystemRegistry>>(config: TConfig & ValidateEventDescriptors<TConfig, NoInfer<SetupEvents<TSchemas, Record<string, StandardSchemaV1>>>>): TConfig;
+  /** State input schemas from setup config */
+  states: TStates;
+  /** Schemas from setup config */
+  schemas: TSchemas;
+}
+type SetupConfigSchemas<TConfig> = TConfig extends {
+  schemas?: infer TSchemas;
+} ? TSchemas extends SetupSchemas ? TSchemas : {} : {};
+type SetupConfigStates<TConfig> = TConfig extends {
+  states?: infer TStates;
+} ? TStates extends Record<string, SetupStateSchema> ? TStates : Record<string, SetupStateSchema> : Record<string, SetupStateSchema>;
+type SetupConfigActions<TConfig> = TConfig extends {
+  actions?: infer TActions;
+} ? TActions extends Sources['actions'] ? MergeSourceMaps<SetupActions<SetupConfigSchemas<TConfig>, {}>, TActions> : SetupActions<SetupConfigSchemas<TConfig>, {}> : SetupActions<SetupConfigSchemas<TConfig>, {}>;
+type SetupConfigActors<TConfig> = TConfig extends {
+  actors?: infer TActors;
+} ? TActors extends Sources['actors'] ? TActors : {} : {};
+type SetupConfigGuards<TConfig> = TConfig extends {
+  guards?: infer TGuards;
+} ? TGuards extends Sources['guards'] ? MergeSourceMaps<SetupGuards<SetupConfigSchemas<TConfig>, {}>, TGuards> : SetupGuards<SetupConfigSchemas<TConfig>, {}> : SetupGuards<SetupConfigSchemas<TConfig>, {}>;
+type SetupConfigDelays<TConfig> = TConfig extends {
+  delays?: infer TDelays;
+} ? TDelays extends Sources['delays'] ? TDelays : {} : {};
+/** @public */
+type SetupReturnFromConfig<TConfig extends AnySetupConfig, TSystemRegistry extends SystemRegistry = SystemRegistry> = SetupReturn<SetupConfigStates<TConfig>, SetupConfigSchemas<TConfig>, SetupConfigActions<TConfig>, SetupConfigActors<TConfig>, SetupConfigGuards<TConfig>, SetupConfigDelays<TConfig>, Extract<keyof SetupConfigDelays<TConfig>, string>, TSystemRegistry, TConfig extends {
+  validator: infer TValidator extends ActorLogicValidator;
+} ? TValidator : undefined>;
+type SetupFunction<TSystemRegistry extends SystemRegistry = SystemRegistry> = {
+  (): SetupReturn<Record<string, SetupStateSchema>, {}, {}, {}, {}, {}, never, TSystemRegistry>;
+  <const TSchemas extends SetupSchemas = {}, const TStates extends Record<string, SetupStateSchema> = Record<string, SetupStateSchema>, TActionMap extends Sources['actions'] = {}, TActorMap extends Sources['actors'] = {}, TGuardMap extends Sources['guards'] = {}, TDelayMap extends Sources['delays'] = {}, const TValidator extends ActorLogicValidator | undefined = undefined>(config: SetupConfig<TSchemas, TStates, TActionMap, TActorMap, TGuardMap, TDelayMap, TValidator> & RuntimeValidationConstraint<NoInfer<TSchemas>, NoInfer<TStates>, TValidator>): SetupReturn<TStates, TSchemas, TActionMap, TActorMap, TGuardMap, TDelayMap, Extract<keyof TDelayMap, string>, TSystemRegistry, TValidator>;
+  <const TConfig extends AnySetupConfig>(config: TConfig & SetupSourceCompanions<SetupConfigSchemas<TConfig>> & RuntimeValidationConstraint<NoInfer<SetupConfigSchemas<TConfig>>, NoInfer<SetupConfigStates<TConfig>>, TConfig extends {
+    validator: infer TValidator;
+  } ? TValidator : undefined>): SetupReturnFromConfig<TConfig, TSystemRegistry>;
+};
+/**
+ * Sets up a state machine with state input schemas and other configuration.
+ *
+ * @example
+ *
+ * ```ts
+ * import { setup } from '@systemfsoftware/xstate';
+ * import z from 'zod';
+ *
+ * const s = setup({
+ *   states: {
+ *     loading: {
+ *       schemas: {
+ *         input: z.object({
+ *           userId: z.string()
+ *         })
+ *       }
+ *     }
+ *   }
+ * });
+ *
+ * const machine = s.createMachine({
+ *   initial: {
+ *     target: 'loading',
+ *     input: { userId: '123' }
+ *   },
+ *   states: {
+ *     loading: {
+ *       entry: ({ input }) => {
+ *         console.log(input.userId);
+ *       }
+ *     }
+ *   }
+ * });
+ * ```
+ * @public
+ */
+declare const setup: SetupFunction;
+type SystemActorOptions<TLogic extends AnyActorLogic, TSystemRegistry extends SystemRegistry> = Omit<ActorOptions<TLogic>, 'registryKey'> & {
+  registryKey?: RegistryKeyForLogic<TLogic, TSystemRegistry>;
+};
+type SystemBuilder<TSystemRegistry extends SystemRegistry> = {
+  createActor<TLogic extends AnyActorLogic>(logic: TLogic, ...[options]: [RequiredActorOptionsKeys<TLogic>] extends [never] ? [options?: SystemActorOptions<TLogic, TSystemRegistry>] : [options: SystemActorOptions<TLogic, TSystemRegistry> & RequiredActorOptionsFor<TLogic>]): Actor<TLogic>;
+  get: SystemRuntime<TSystemRegistry>['get'];
+  getAll: SystemRuntime<TSystemRegistry>['getAll'];
+  inspect(observer: Observer<InspectionEvent> | ((inspectionEvent: InspectionEvent) => void)): Subscription;
+  onRejectedEvent: AnyActorSystem['onRejectedEvent'];
+  setup: SetupFunction<TSystemRegistry>;
+};
+/** @public */
+declare function createSystem<const TSystemRegistry extends SystemRegistry = {}>(_config?: SystemConfig<TSystemRegistry>): SystemBuilder<TSystemRegistry>;
+/** @public */
+interface SimulatedClock extends Clock {
+  start(speed: number): void;
+  increment(ms: number): void;
+  set(ms: number): void;
+}
+declare class SimulatedClock implements SimulatedClock {
+  private timeouts;
+  private readonly deadlines;
+  private _now;
+  private _id;
+  private _flushing;
+  now(): number;
+  private getId;
+  setTimeout(fn: (...args: any[]) => void, timeout: number): number;
+  clearTimeout(id: number): void;
+  private flushTimeouts;
+}
+/** Immutable definitions for a pure actor system. @experimental */
+interface SystemLogic<TLogic extends AnyActorLogic = AnyActorLogic> {
+  readonly root: TLogic;
+  /** Additional definitions used by dynamically spawned actors. */
+  readonly actors?: Readonly<Record<string, AnyActorLogic>>;
+  /** Stable names for callable external effects; implementations are never run here. */
+  readonly effects?: Readonly<Record<string, (...args: any[]) => unknown>>;
+  /** Pure, named event/snapshot mappers used by listen and subscribeTo. */
+  readonly mappers?: Readonly<Record<string, (...args: any[]) => AnyEventObject>>;
+}
+/** An actor identity, without a live actor or runtime. @experimental */
+interface SystemActorReference {
+  readonly $actor: string;
+  readonly incarnation: number;
+}
+/** Actor state and topology in a system snapshot. @experimental */
+interface SystemActorState {
+  readonly id: string;
+  readonly address: string;
+  readonly incarnation: number;
+  readonly logic: string;
+  readonly logicVersion?: string;
+  readonly parent?: SystemActorReference;
+  readonly registryKey?: string;
+  readonly syncSnapshot?: boolean;
+  readonly started: boolean;
+  readonly input: unknown;
+  readonly snapshot: Readonly<Record<string, any>>;
+}
+/** An accepted message waiting for a completed actor macrostep. @experimental */
+interface SystemMessage {
+  readonly source?: SystemActorReference | undefined;
+  readonly target: SystemActorReference;
+  readonly event: AnyEventObject;
+  readonly sequence: number;
+  /** Set only by the system scheduler, never by an ordinary send. */
+  readonly timerOccurrence?: number;
+}
+/** Absolute deadlines in the system's virtual time domain. @experimental */
+interface SystemTimer {
+  readonly source: SystemActorReference;
+  readonly id: string;
+  readonly occurrence: number;
+  readonly scheduledAt: number;
+  readonly dueAt: number;
+  readonly sequence: number;
+  readonly event?: AnyEventObject;
+}
+/** External work as data. Interpret it outside the pure reducer. @experimental */
+interface SystemExternalEffect {
+  readonly id: string;
+  readonly source: SystemActorReference;
+  readonly type: string;
+  readonly kind: 'action' | 'emit' | 'deadLetter';
+  readonly params?: unknown;
+  readonly args?: readonly unknown[];
+  readonly event?: AnyEventObject;
+  readonly reason?: string;
+}
+/** Acknowledges external work, optionally delivering its result to its owner. @experimental */
+interface SystemEffectResult {
+  type: 'xstate.system.effect.result';
+  effectId: string;
+  event?: AnyEventObject;
+}
+/** Complete immutable system state; no running actors are retained. @experimental */
+interface SystemSnapshot {
+  readonly executionId: string;
+  readonly root: string;
+  readonly now: number;
+  readonly actors: Readonly<Record<string, SystemActorState>>;
+  readonly registry: Readonly<Record<string, SystemActorReference>>;
+  readonly messages: readonly SystemMessage[];
+  readonly timers: Readonly<Record<string, SystemTimer>>;
+  readonly externalEffects: Readonly<Record<string, SystemExternalEffect>>;
+  readonly counters: Readonly<{
+    actor: number;
+    timer: number;
+    sequence: number;
+    effect: number;
+  }>;
+}
+/** Options for initializing an immutable system snapshot. @experimental */
+interface InitialSystemTransitionOptions<TLogic extends AnyActorLogic = AnyActorLogic> {
+  input?: InputFrom<TLogic>;
+  id?: string;
+  registryKey?: string;
+  /** Namespace external effect IDs when several executions share one host. */
+  executionId?: string;
+  time?: number;
+  /** Bound immediate message chains. Exhaustion throws; the input is unchanged. */
+  maxSteps?: number;
+}
+/** Initialize all actors and return external work without executing it. @experimental */
+declare function initialSystemTransition<TLogic extends AnyActorLogic>(systemLogic: SystemLogic<TLogic>, options?: InitialSystemTransitionOptions<TLogic>): [SystemSnapshot, SystemExternalEffect[]];
+/** Complete actor macrosteps and immediate communication in an immutable snapshot. @experimental */
+declare function systemTransition(systemLogic: SystemLogic, snapshot: SystemSnapshot, actorPath: string, event: AnyEventObject): [SystemSnapshot, SystemExternalEffect[]];
+/** Process every due timer chronologically across the entire system snapshot. @experimental */
+declare function advanceSystemTime(systemLogic: SystemLogic, snapshot: SystemSnapshot, options: {
+  time: number;
+  maxSteps?: number;
+}): [SystemSnapshot, SystemExternalEffect[]];
+/**
+ * Converts a delay (milliseconds or an ISO 8601 duration string) to
+ * milliseconds. Exported for `@xstate/scxml`; not part of the stable API.
+ *
+ * @experimental
+ */
+declare function parseDelayToMilliseconds(delay: string | number | undefined): number | undefined;
+/**
+ * Runs one keyed step of an async actor with the built-in journal: the
+ * result is memoized in the actor's own snapshot (`effects[key]`), so a
+ * restored actor skips completed steps when its logic function re-runs.
+ * Custom runtimes that implement `runStep` use this for the default local
+ * behavior, the same way `deliverEvent` exposes local delivery.
+ *
+ * @experimental
+ */
+declare function runStep<TStepOutput>(actor: AnyActor, key: string, exec: () => TStepOutput | PromiseLike<TStepOutput>, sendSelf?: (event: AnyEventObject) => void): Promise<TStepOutput>;
+/**
+ * Delivers an event directly to a target actor, bypassing any installed host
+ * runtime. Custom runtimes use this for the default local delivery behavior
+ * inside their own `sendEvent` implementations.
+ *
+ * @experimental
+ */
+declare function deliverEvent(source: AnyActor | undefined, target: AnyActor, event: AnyEventObject): void;
+/**
+ * Publishes an actor's terminal result, notifying its parent and observers.
+ * Custom runtimes use this for the default local behavior inside their own
+ * `terminateActor` implementations.
+ *
+ * @experimental
+ */
+declare function terminateActor(actor: AnyActor, termination: ActorTermination): void;
+/**
+ * Stops an actor without producing a completion result. Custom runtimes use
+ * this for the default local behavior inside their own `stopActor`
+ * implementations.
+ *
+ * @experimental
+ */
+declare function stopActor(actor: AnyActor): void;
+/** @public */
+declare const pathToStateValue: (statePath: readonly string[]) => StateValue;
+/** @public */
+declare function matchesState(childStateValue: StateValue): (parentStateValue: StateValue) => boolean;
+declare function matchesState(parentStateValue: StateValue, childStateValue: StateValue): boolean;
+/**
+ * Returns a promise that resolves to the `output` of the actor when it is done.
+ *
+ * @example
+ *
+ * ```ts
+ * const machine = createMachine({
+ *   // ...
+ *   output: {
+ *     count: 42
+ *   }
+ * });
+ *
+ * const actor = createActor(machine);
+ *
+ * actor.start();
+ *
+ * const output = await toPromise(actor);
+ *
+ * console.log(output);
+ * // logs { count: 42 }
+ * ```
+ * @public
+ */
+declare function toPromise<T extends AnyActorRef>(actor: T): Promise<OutputFrom<T>>;
+/**
+ * Given actor `logic`, a `snapshot`, and an `event`, returns a tuple of the
+ * `nextSnapshot` and `actions` to execute.
+ *
+ * This is a pure function that does not execute `actions`.
+ *
+ * @public
+ */
+declare function transition<T extends AnyActorLogic>(logic: T, snapshot: SnapshotFrom<T>, event: EventFromLogic<T>): [nextSnapshot: SnapshotFrom<T>, actions: ExecutableActionObjectFromLogic<T>[]];
+/**
+ * Returns `true` when `result` (from {@link transition}) means no transition
+ * handled the event: the snapshot is the same object as `previousSnapshot`
+ * and there are no effects. A handled event always yields a new snapshot
+ * object, even when nothing in it changed.
+ *
+ * @example
+ *
+ * ```ts
+ * const result = transition(machine, snapshot, event);
+ * if (isUnhandled(snapshot, result)) {
+ *   console.warn(`Unhandled event: ${event.type}`);
+ * }
+ * ```
+ *
+ * @public
+ */
+declare function isUnhandled(previousSnapshot: unknown, result: readonly [snapshot: unknown, effects: readonly unknown[]]): boolean;
+/**
+ * Given actor `logic` and optional `input`, returns a tuple of the
+ * `nextSnapshot` and `actions` to execute from the initial transition (no
+ * previous state).
+ *
+ * This is a pure function that does not execute `actions`.
+ *
+ * @public
+ */
+declare function initialTransition<T extends AnyActorLogic>(logic: T, ...[input]: undefined extends InputFrom<T> ? [input?: InputFrom<T>] : [input: InputFrom<T>]): [SnapshotFrom<T>, ExecutableActionObjectFromLogic<T>[]];
+/**
+ * Given a state `machine`, a `snapshot`, and an `event`, returns an array of
+ * microsteps, where each microstep is a tuple of
+ * `[snapshot, actions, transitions]`. `transitions` are the transitions taken
+ * in that microstep,
+ * including eventless transitions and transitions for raised events; it is
+ * empty for microsteps that take no transition (for example, a stop or timer
+ * microstep).
+ *
+ * This is a pure function that does not execute `actions`.
+ *
+ * @public
+ */
+declare function getMicrosteps<T extends AnyStateMachine>(machine: T, snapshot: SnapshotFrom<T>, event: EventFromLogic<T>): Array<[SnapshotFrom<T>, ExecutableActionObjectFromLogic<T>[], AnyTransitionDefinition[]]>;
+/**
+ * Given a state `machine` and optional `input`, returns an array of microsteps
+ * from the initial transition, where each microstep is a tuple of
+ * `[snapshot, actions, transitions]`. `transitions` are the transitions taken
+ * in that microstep (see {@link getMicrosteps}); it is empty for the first
+ * microstep, which enters the initial states.
+ *
+ * This is a pure function that does not execute `actions`.
+ *
+ * @public
+ */
+declare function getInitialMicrosteps<T extends AnyStateMachine>(machine: T, ...[input]: undefined extends InputFrom<T> ? [input?: InputFrom<T>] : [input: InputFrom<T>]): Array<[SnapshotFrom<T>, ExecutableActionObjectFromLogic<T>[], AnyTransitionDefinition[]]>;
+/**
+ * Gets all potential next transitions from the current state.
+ *
+ * Returns all transitions that are available from the current state, including:
+ *
+ * - All transitions from atomic states (leaf states in the current state
+ *   configuration)
+ * - All transitions from ancestor states (parent states that may handle events)
+ * - All guarded transitions (regardless of whether their guards would pass)
+ * - Always (eventless) transitions
+ * - After (delayed) transitions
+ *
+ * The order of transitions is deterministic:
+ *
+ * 1. Atomic states are processed in document order
+ * 2. For each atomic state, transitions are collected from the state itself first,
+ *    then its ancestors
+ * 3. Within each state node, transitions are in the order they appear in the state
+ *    definition
+ *
+ * @param state - The current machine snapshot
+ * @returns Array of transition definitions from the current state, in
+ *   deterministic order
+ * @public
+ */
+declare function getNextTransitions(state: AnyMachineSnapshot): AnyTransitionDefinition[];
+/** @public */
+declare function isBuiltInExecutableAction(action: ExecutableActionObject): action is SpecialExecutableAction;
+/**
+ * Executes transition effects sequentially, awaiting each runtime operation.
+ *
+ * @public
+ */
+declare function executeEffects(effects: readonly ExecutableActionObject[], runtime?: Partial<ActorSystemRuntime>): Promise<void>;
+/** @public */
+declare function toObserver<T>(nextHandler?: Observer<T> | ((value: T) => void), errorHandler?: (error: any) => void, completionHandler?: () => void): Observer<T>;
+/** @experimental */
+declare function getAllOwnEventDescriptors(snapshot: AnyMachineSnapshot): any[];
+interface WaitForOptions {
+  /**
+   * How long to wait before rejecting, if no emitted state satisfies the
+   * predicate.
+   *
+   * @defaultValue Infinity
+   */
+  timeout: number;
+  /** A signal which stops waiting when aborted. */
+  signal?: AbortSignal;
+}
+/**
+ * Subscribes to an actor ref and waits for its emitted value to satisfy a
+ * predicate, and then resolves with that value. Will throw if the desired state
+ * is not reached after an optional timeout. (defaults to Infinity).
+ *
+ * @example
+ *
+ * ```js
+ * const state = await waitFor(someService, (state) => {
+ *   return state.hasTag('loaded');
+ * });
+ *
+ * state.hasTag('loaded'); // true
+ * ```
+ *
+ * @param actorRef The actor ref to subscribe to
+ * @param predicate Determines if a value matches the condition to wait for
+ * @param options
+ * @returns A promise that eventually resolves to the emitted value that matches
+ *   the condition
+ * @public
+ */
+declare function waitFor<TActorRef extends AnyActorRef>(actorRef: TActorRef, predicate: (emitted: SnapshotFrom<TActorRef>) => boolean, options?: Partial<WaitForOptions>): Promise<SnapshotFrom<TActorRef>>;
+export { WithRootSetupStateSchemas as $, initialSystemTransition as A, RootContextMarker as B, SystemEffectResult as C, createMachineFromConfig as Ct, SystemSnapshot as D, assertEvent as Dt, SystemMessage as E, createStateConfig as Et, CreateAsyncInvokeConfig as F, SetupStateParentTypeMarker as G, SetupConfig as H, CreateInvokeConfig as I, StrictSetupStateTargetsFlag as J, SetupStateSchemasWithParentType as K, CreatedInvoke as L, SimulatedClock as M, ActiveStateContext as N, SystemTimer as O, AnySetupConfig as P, SystemRuntime as Q, CurrentSetupStateSchemaMarker as R, SystemActorState as S, TransitionJSON as St, SystemLogic as T, createMachineFromCompiledConfig as Tt, SetupReturn as U, RootSetupStateSchemasMarker as V, SetupReturnFromConfig as W, SystemActorMap as X, StrictSetupStateTargetsMarker as Y, SystemConfig as Z, stopActor as _, ActionJSON as _t, isBuiltInExecutableAction as a, serializeMachine as at, InitialSystemTransitionOptions as b, MachineJSON as bt, getNextTransitions as c, EventAdapterHandlers as ct, transition as d, MigrateSnapshotOptions as dt, createSystem as et, toPromise as f, ParsedPersistedSnapshot as ft, runStep as g, machineVersions as gt, deliverEvent as h, SnapshotMigrationHandlers as ht, executeEffects as i, machineConfigToJSON as it, systemTransition as j, advanceSystemTime as k, initialTransition as l, EventHistorySource as lt, pathToStateValue as m, PersistedSnapshotSource as mt, getAllOwnEventDescriptors as n, hotSwapActorLogic as nt, getInitialMicrosteps as o, mapState as ot, matchesState as p, PersistedSnapshotDataFrom as pt, StrictSetupStateSchemas as q, toObserver as r, CodeExpression as rt, getMicrosteps as s, AdaptEventsOptions as st, waitFor as t, setup as tt, isUnhandled as u, MachineVersionsOptions as ut, terminateActor as v, GuardJSON as vt, SystemExternalEffect as w, createMachine as wt, SystemActorReference as x, StateNodeJSON as xt, parseDelayToMilliseconds as y, InvokeJSON as yt, RelativeSetupStateSchemasMarker as z };