xstate 5.32.0 → 6.0.0-alpha.1

package/dist/declarations/src/types.v6.d.ts

@@ -0,0 +1,392 @@
+import { StandardSchemaV1 } from "./schema.types.js";
+import { MachineSnapshot } from "./State.js";
+import { Action, ActorSelf, AnyActorLogic, AnyActorRef, Compute, DoneActorEvent, DoNotInfer, EventDescriptor, EventObject, ExtractEvent, InitialContext, InputFrom, IsNever, MetaObject, NonReducibleUnknown, SingleOrArray, SnapshotEvent, StateValue, TODO, TransitionConfigFunction, Values, AnyStateNode } from "./types.js";
+import { MachineContext, Mapper } from "./types.js";
+import { LowInfer } from "./types.js";
+import { DoneStateEvent } from "./types.js";
+export type InferOutput<T extends StandardSchemaV1, U> = Compute<StandardSchemaV1.InferOutput<T> extends U ? StandardSchemaV1.InferOutput<T> : never>;
+/**
+ * Event payloads from schemas (e.g. Zod) are often inferred as optional in
+ * output types. Wrapping in Required<> ensures properties defined in the schema
+ * are required on the event.
+ */
+export type InferEvents<TEventSchemaMap extends Record<string, StandardSchemaV1>> = Values<{
+    [K in keyof TEventSchemaMap & string]: StandardSchemaV1.InferOutput<TEventSchemaMap[K]> extends infer O ? unknown extends O ? O & {
+        type: K;
+    } : Required<O> & {
+        type: K;
+    } : never;
+}>;
+type DistributiveOmit<T, K extends keyof any> = T extends any ? Omit<T, K> : never;
+type InternalEventDescriptorFor<TEvent extends EventObject> = [TEvent] extends [
+    never
+] ? string : EventDescriptor<TEvent>;
+/**
+ * Runtime options for state machine execution.
+ *
+ * @example
+ *
+ * ```ts
+ * const machine = createMachine({
+ *   // ... machine config
+ *   options: {
+ *     maxIterations: 5000
+ *     // other runtime options can be added here
+ *   }
+ * });
+ * ```
+ */
+export interface MachineOptions {
+    /**
+     * Maximum number of microsteps allowed before throwing an infinite loop
+     * error. Defaults to `Infinity` (no limit). Set to a finite number to enable
+     * infinite loop detection.
+     *
+     * @default Infinity
+     */
+    maxIterations?: number;
+}
+export type Next_MachineConfig<TContextSchema extends StandardSchemaV1, TEventSchemaMap extends Record<string, StandardSchemaV1>, TEmittedSchemaMap extends Record<string, StandardSchemaV1>, TInputSchema extends StandardSchemaV1, TOutputSchema extends StandardSchemaV1, TMetaSchema extends StandardSchemaV1, TTagSchema extends StandardSchemaV1, TContext extends MachineContext = InferOutput<TContextSchema, MachineContext>, TEvent extends EventObject = InferEvents<TEventSchemaMap>, TDelays extends string = string, _TTag extends string = string, TActionMap extends Implementations['actions'] = Implementations['actions'], TActorMap extends Implementations['actors'] = Implementations['actors'], TGuardMap extends Implementations['guards'] = Implementations['guards'], TDelayMap extends Implementations['delays'] = Implementations['delays'], TContextRequired extends boolean = IsNever<TContext> extends true ? false : true> = (DistributiveOmit<Next_StateNodeConfig<TContext, DoNotInfer<InferEvents<TEventSchemaMap>>, DoNotInfer<TDelays>, DoNotInfer<StandardSchemaV1.InferOutput<TTagSchema> & string>, DoNotInfer<StandardSchemaV1.InferOutput<TOutputSchema>>, DoNotInfer<InferEvents<TEmittedSchemaMap>>, DoNotInfer<InferOutput<TMetaSchema, MetaObject>>, DoNotInfer<TActionMap>, DoNotInfer<TActorMap>, DoNotInfer<TGuardMap>, DoNotInfer<TDelayMap>>, 'output'> & {
+    internalEvents?: readonly InternalEventDescriptorFor<InferEvents<TEventSchemaMap>>[];
+    schemas?: {
+        events?: TEventSchemaMap;
+        context?: TContextSchema;
+        emitted?: TEmittedSchemaMap;
+        input?: TInputSchema;
+        output?: TOutputSchema;
+        meta?: TMetaSchema;
+        tags?: TTagSchema;
+    };
+    actions?: TActionMap;
+    guards?: TGuardMap;
+    actors?: TActorMap;
+    /** The machine's own version. */
+    version?: string;
+    /**
+     * Migrates a persisted snapshot created by a different version of this
+     * machine to the current `version`. Called during restore when the persisted
+     * snapshot's `version` does not match the machine's `version` (`fromVersion`
+     * is the persisted version, possibly `undefined`). Restoring a
+     * version-mismatched snapshot without a `migrate` function throws.
+     */
+    migrate?: (persistedSnapshot: any, fromVersion: string | undefined) => unknown;
+    output?: Mapper<TContext, DoneStateEvent, InferOutput<TOutputSchema, unknown>, TEvent> | InferOutput<TOutputSchema, unknown>;
+    delays?: {
+        [K in TDelays | number]?: number | (({ context, event, stateNode }: {
+            context: TContext;
+            event: TEvent;
+            stateNode: AnyStateNode;
+        }) => number);
+    };
+    options?: MachineOptions;
+}) & (TContextRequired extends false ? {
+    context?: InitialContext<LowInfer<TContext>, TActorMap, InferOutput<TInputSchema, unknown>, TEvent>;
+} : {
+    context: InitialContext<LowInfer<TContext>, TActorMap, InferOutput<TInputSchema, unknown>, TEvent>;
+});
+/**
+ * Recursively widens literal types and strips `readonly`. Used to widen context
+ * inferred from a literal initial value (e.g. `{ count: 0 }` becomes `{ count:
+ * number }`), since `createMachine`'s `const` state-schema inference would
+ * otherwise freeze context at its initial literal type and make every context
+ * update a type error.
+ */
+export type WidenLiterals<T> = T extends string ? string : T extends number ? number : T extends boolean ? boolean : T extends bigint ? bigint : T extends (...args: any[]) => any ? T : T extends readonly (infer U)[] ? WidenLiterals<U>[] : T extends object ? {
+    -readonly [K in keyof T]: WidenLiterals<T[K]>;
+} : T;
+type InvokeSrcArgs<TContext extends MachineContext, TEvent extends EventObject, TActorMap extends Implementations['actors']> = {
+    actors: TActorMap;
+    context: TContext;
+    event: TEvent;
+    self: AnyActorRef;
+};
+type InvokeInputArgs<TContext extends MachineContext, TEvent extends EventObject, TEmitted extends EventObject> = {
+    context: TContext;
+    event: TEvent;
+    self: ActorSelf<MachineSnapshot<TContext, TEvent, Record<string, AnyActorRef | undefined>, StateValue, string, unknown, TODO, TODO>, TEvent, TEmitted>;
+};
+/**
+ * Invoke config. A union of:
+ *
+ * - One branch per registered actor (distributed over the `actors` map), where
+ *   `src` — a key, the logic itself, or a resolver function returning either —
+ *   is correlated with `input`, so static and mapped inputs typecheck against
+ *   that logic's input type.
+ * - A branch for inline (unregistered) actor logic values, whose `input` cannot
+ *   be correlated (the config is not generic over inline logic).
+ */
+export type Next_InvokeConfig<TContext extends MachineContext, TEvent extends EventObject, TEmitted extends EventObject, TActionMap extends Implementations['actions'], TActorMap extends Implementations['actors'], TGuardMap extends Implementations['guards'], TDelayMap extends Implementations['delays'], TMeta extends MetaObject> = string extends keyof TActorMap ? // No registered actors (permissive map): `src`/`input` cannot be
+Next_InvokeConfigBase<TContext, TEvent, TEmitted, TActionMap, TActorMap, TGuardMap, TDelayMap, TMeta> & {
+    src: string | AnyActorLogic | ((args: InvokeSrcArgs<TContext, TEvent, TActorMap>) => string | AnyActorLogic);
+    input?: ((args: InvokeInputArgs<TContext, TEvent, TEmitted>) => unknown) | NonReducibleUnknown;
+} : {
+    [K in keyof TActorMap & string]: Next_InvokeConfigBase<TContext, TEvent, TEmitted, TActionMap, TActorMap, TGuardMap, TDelayMap, TMeta> & {
+        src: K | TActorMap[K] | ((args: InvokeSrcArgs<TContext, TEvent, TActorMap>) => K | TActorMap[K]);
+        input?: ((args: InvokeInputArgs<TContext, TEvent, TEmitted>) => InputFrom<TActorMap[K]>) | InputFrom<TActorMap[K]>;
+    };
+}[keyof TActorMap & string] | (Next_InvokeConfigBase<TContext, TEvent, TEmitted, TActionMap, TActorMap, TGuardMap, TDelayMap, TMeta> & {
+    src: AnyActorLogic;
+    input?: ((args: InvokeInputArgs<TContext, TEvent, TEmitted>) => unknown) | NonReducibleUnknown;
+});
+interface Next_InvokeConfigBase<TContext extends MachineContext, TEvent extends EventObject, TEmitted extends EventObject, TActionMap extends Implementations['actions'], TActorMap extends Implementations['actors'], TGuardMap extends Implementations['guards'], TDelayMap extends Implementations['delays'], TMeta extends MetaObject> {
+    id?: string;
+    systemId?: string;
+    onDone?: Next_TransitionConfigOrTarget<TContext, DoneActorEvent<any>, TEvent, TEmitted, TActionMap, TActorMap, TGuardMap, TDelayMap, TMeta>;
+    onError?: Next_TransitionConfigOrTarget<TContext, ErrorEvent, TEvent, TEmitted, TActionMap, TActorMap, TGuardMap, TDelayMap, TMeta>;
+    onSnapshot?: Next_TransitionConfigOrTarget<TContext, SnapshotEvent<any>, TEvent, TEmitted, TActionMap, TActorMap, TGuardMap, TDelayMap, TMeta>;
+    /**
+     * The duration (in ms) after which this invocation will time out if it has
+     * not completed. "This task is taking too long."
+     *
+     * When the timeout expires, the `onTimeout` transition is taken. If the
+     * invoke completes first, the timeout is cancelled.
+     */
+    timeout?: number | ((args: {
+        context: TContext;
+        event: TEvent;
+    }) => number);
+    /**
+     * Transition taken when the invoke-level `timeout` expires. Required when
+     * `timeout` is set on an invoke.
+     */
+    onTimeout?: Next_TransitionConfigOrTarget<TContext, TEvent, TEvent, TEmitted, TActionMap, TActorMap, TGuardMap, TDelayMap, TMeta>;
+}
+/** Lookup state input type from an input map, with fallback to undefined */
+type LookupInput<TInputMap extends Record<string, unknown>, K extends string> = K extends keyof TInputMap ? TInputMap[K] : undefined;
+type StateAction<TContext extends MachineContext, TEvent extends EventObject, TEmittedEvent extends EventObject, TActionMap extends Implementations['actions'], TActorMap extends Implementations['actors'], TGuardMap extends Implementations['guards'], TDelayMap extends Implementations['delays'], TInput = Record<string, unknown> | undefined> = (_: Omit<Parameters<Action<TContext, TEvent, TEmittedEvent, TActionMap, TActorMap, TGuardMap, TDelayMap, never>>[0], 'params'> & {
+    input: TInput;
+}, enqueue: Parameters<Action<TContext, TEvent, TEmittedEvent, TActionMap, TActorMap, TGuardMap, TDelayMap, never>>[1]) => ReturnType<Action<TContext, TEvent, TEmittedEvent, TActionMap, TActorMap, TGuardMap, TDelayMap, never>>;
+type Next_ChoiceTarget<TMeta extends MetaObject> = {
+    target: string | string[];
+    description?: string;
+    reenter?: boolean;
+    meta?: TMeta;
+    input?: Record<string, unknown> | ((args: {
+        context: any;
+        event: any;
+    }) => Record<string, unknown>);
+};
+type Next_ChoiceArgs<TContext extends MachineContext, TCurrentEvent extends EventObject, TEvent extends EventObject, TActionMap extends Implementations['actions'], TActorMap extends Implementations['actors'], TGuardMap extends Implementations['guards'], TDelayMap extends Implementations['delays'], _TCtx = [TContext] extends [never] ? any : TContext> = Parameters<TransitionConfigFunction<TContext, TCurrentEvent, TEvent, EventObject, TActionMap, TActorMap, TGuardMap, TDelayMap, MetaObject, _TCtx>>[0];
+/**
+ * Route config: either a static config object, or a transition-style function
+ * that acts as the route's guard and resolver — returning `undefined`/`false`
+ * blocks the route; returning `true` or a config object allows it (optionally
+ * updating `context` and providing `input`/`reenter`/`meta`).
+ *
+ * Guard objects/strings on routes are only produced by the JSON layer
+ * (`createMachineFromConfig`) — authoring uses the function form.
+ */
+type Next_RouteConfig<TContext extends MachineContext, TEvent extends EventObject, TMeta extends MetaObject, TActionMap extends Implementations['actions'], TActorMap extends Implementations['actors'], TGuardMap extends Implementations['guards'], TDelayMap extends Implementations['delays']> = {
+    description?: string;
+    reenter?: boolean;
+    meta?: TMeta;
+    input?: Record<string, unknown> | ((args: {
+        context: any;
+        event: any;
+    }) => Record<string, unknown>);
+} | ((args: Next_ChoiceArgs<TContext, TEvent, TEvent, TActionMap, TActorMap, TGuardMap, TDelayMap>) => boolean | void | {
+    context?: TContext;
+    reenter?: boolean;
+    meta?: TMeta;
+    input?: Record<string, unknown> | ((args: {
+        context: any;
+        event: any;
+    }) => Record<string, unknown>);
+});
+type Next_ChoiceConfigFunction<TContext extends MachineContext, TCurrentEvent extends EventObject, TEvent extends EventObject, TActionMap extends Implementations['actions'], TActorMap extends Implementations['actors'], TGuardMap extends Implementations['guards'], TDelayMap extends Implementations['delays'], TMeta extends MetaObject, _TCtx = [TContext] extends [never] ? any : TContext> = (args: Next_ChoiceArgs<TContext, TCurrentEvent, TEvent, TActionMap, TActorMap, TGuardMap, TDelayMap, _TCtx>) => Next_ChoiceTarget<TMeta>;
+export type Next_StateNodeConfig<TContext extends MachineContext, TEvent extends EventObject, TDelays extends string, TTag extends string, _TOutput, TEmitted extends EventObject, TMeta extends MetaObject, TActionMap extends Implementations['actions'], TActorMap extends Implementations['actors'], TGuardMap extends Implementations['guards'], TDelayMap extends Implementations['delays'], TInput = Record<string, unknown> | undefined, TInputMap extends Record<string, unknown> = Record<string, unknown>> = Next_RegularStateNodeConfig<TContext, TEvent, TDelays, TTag, _TOutput, TEmitted, TMeta, TActionMap, TActorMap, TGuardMap, TDelayMap, TInput, TInputMap> | Next_ChoiceStateNodeConfig<TContext, TEvent, TTag, TMeta, TActionMap, TActorMap, TGuardMap, TDelayMap>;
+interface Next_ChoiceStateNodeConfig<TContext extends MachineContext, TEvent extends EventObject, TTag extends string, TMeta extends MetaObject, TActionMap extends Implementations['actions'], TActorMap extends Implementations['actors'], TGuardMap extends Implementations['guards'], TDelayMap extends Implementations['delays']> {
+    contextSchema?: StandardSchemaV1;
+    type: 'choice';
+    /** Function that resolves this choice state to a target. */
+    choice: Next_ChoiceConfigFunction<TContext, TEvent, TEvent, TActionMap, TActorMap, TGuardMap, TDelayMap, TMeta>;
+    id?: string | undefined;
+    order?: number;
+    tags?: TTag[];
+    description?: string;
+    meta?: TMeta;
+    route?: Next_RouteConfig<TContext, TEvent, TMeta, TActionMap, TActorMap, TGuardMap, TDelayMap> | undefined;
+    initial?: never;
+    history?: never;
+    states?: never;
+    invoke?: never;
+    on?: never;
+    entry?: never;
+    exit?: never;
+    onDone?: never;
+    after?: never;
+    timeout?: never;
+    onTimeout?: never;
+    always?: never;
+    output?: never;
+    target?: never;
+}
+interface Next_RegularStateNodeConfig<TContext extends MachineContext, TEvent extends EventObject, TDelays extends string, TTag extends string, _TOutput, TEmitted extends EventObject, TMeta extends MetaObject, TActionMap extends Implementations['actions'], TActorMap extends Implementations['actors'], TGuardMap extends Implementations['guards'], TDelayMap extends Implementations['delays'], TInput = Record<string, unknown> | undefined, TInputMap extends Record<string, unknown> = Record<string, unknown>> {
+    contextSchema?: StandardSchemaV1;
+    /** The initial state transition. */
+    initial?: string | {
+        target: string;
+        input?: Record<string, unknown> | ((args: {
+            context: TContext;
+            event: TEvent;
+        }) => Record<string, unknown>);
+    } | undefined;
+    /**
+     * The type of this state node:
+     *
+     * - `'atomic'` - no child state nodes
+     * - `'compound'` - nested child state nodes (XOR)
+     * - `'parallel'` - orthogonal nested child state nodes (AND)
+     * - `'history'` - history state node
+     * - `'final'` - final state node
+     */
+    type?: 'atomic' | 'compound' | 'parallel' | 'final' | 'history';
+    /**
+     * Indicates whether the state node is a history state node, and what type of
+     * history: shallow, deep, true (shallow), false (none), undefined (none)
+     */
+    history?: 'shallow' | 'deep' | boolean | undefined;
+    /**
+     * The mapping of state node keys to their state node configurations
+     * (recursive).
+     */
+    states?: {
+        [K in string]: Next_StateNodeConfig<TContext, TEvent, TDelays, TTag, any, // TOutput,
+        TEmitted, TMeta, TActionMap, TActorMap, TGuardMap, TDelayMap, LookupInput<TInputMap, K>, TInputMap>;
+    };
+    /**
+     * The services to invoke upon entering this state node. These services will
+     * be stopped upon exiting this state node.
+     */
+    invoke?: SingleOrArray<Next_InvokeConfig<TContext, TEvent, TEmitted, TActionMap, TActorMap, TGuardMap, TDelayMap, TMeta>>;
+    /** The mapping of event types to their potential transition(s). */
+    on?: {
+        [K in EventDescriptor<TEvent>]?: Next_TransitionConfigOrTarget<TContext, ExtractEvent<TEvent, K>, TEvent, TEmitted, TActionMap, TActorMap, TGuardMap, TDelayMap, TMeta>;
+    };
+    /**
+     * Enables routing to this state via `{ type: 'xstate.route', to: '#id' }`.
+     * Requires this state node to have an explicit `id`.
+     */
+    route?: Next_RouteConfig<TContext, TEvent, TMeta, TActionMap, TActorMap, TGuardMap, TDelayMap> | undefined;
+    entry?: StateAction<TContext, TEvent, TEmitted, TActionMap, TActorMap, TGuardMap, TDelayMap, TInput>;
+    exit?: StateAction<TContext, TEvent, TEmitted, TActionMap, TActorMap, TGuardMap, TDelayMap, TInput>;
+    /**
+     * The potential transition(s) to be taken upon reaching a final child state
+     * node.
+     *
+     * This is equivalent to defining a `[done(id)]` transition on this state
+     * node's `on` property.
+     */
+    onDone?: string | TransitionConfigFunction<TContext, DoneStateEvent, TEvent, TEmitted, TActionMap, TActorMap, TGuardMap, TDelayMap, TMeta> | undefined;
+    /**
+     * The mapping (or array) of delays (in milliseconds) to their potential
+     * transition(s). The delayed transitions are taken after the specified delay
+     * in an interpreter.
+     */
+    after?: {
+        [K in NoInfer<TDelays> | number]?: string | {
+            target: string;
+        } | TransitionConfigFunction<TContext, TEvent, TEvent, TODO, // TEmitted
+        TActionMap, TActorMap, TGuardMap, TDelayMap, TMeta>;
+    };
+    /**
+     * The duration (in ms) after which this state will transition via `onTimeout`
+     * if still active. "We've been in this state too long."
+     *
+     * Independent of `after` - both can coexist on the same state. Both cancel on
+     * state exit.
+     *
+     * Can be a static number, a delay reference string, or a dynamic function.
+     */
+    timeout?: number | NoInfer<TDelays> | ((args: {
+        context: TContext;
+        event: TEvent;
+        stateNode: AnyStateNode;
+    }) => number);
+    /** Transition taken when `timeout` expires. Required when `timeout` is set. */
+    onTimeout?: Next_TransitionConfigOrTarget<TContext, TEvent, TEvent, TEmitted, TActionMap, TActorMap, TGuardMap, TDelayMap, TMeta>;
+    /**
+     * An eventless transition that is always taken when this state node is
+     * active.
+     */
+    always?: Next_TransitionConfigOrTarget<TContext, TEvent, TEvent, TEmitted, TActionMap, TActorMap, TGuardMap, TDelayMap, TMeta>;
+    choice?: never;
+    /**
+     * The meta data associated with this state node, which will be returned in
+     * State instances.
+     */
+    meta?: TMeta;
+    /**
+     * The output data sent with the "xstate.done.state._id_" event if this is a
+     * final state node.
+     *
+     * The output data will be evaluated with the current `context` and placed on
+     * the `.data` property of the event.
+     */
+    output?: Mapper<TContext, TEvent, unknown, TEvent> | NonReducibleUnknown;
+    /**
+     * The unique ID of the state node, which can be referenced as a transition
+     * target via the `#id` syntax.
+     */
+    id?: string | undefined;
+    /**
+     * The order this state node appears. Corresponds to the implicit document
+     * order.
+     */
+    order?: number;
+    /**
+     * The tags for this state node, which are accumulated into the `state.tags`
+     * property.
+     */
+    tags?: TTag[];
+    /** A text description of the state node */
+    description?: string;
+    /** A default target for a history state */
+    target?: string | undefined;
+}
+export type Next_TransitionConfigOrTarget<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject, TEmitted extends EventObject, TActionMap extends Implementations['actions'], TActorMap extends Implementations['actors'], TGuardMap extends Implementations['guards'], TDelayMap extends Implementations['delays'], TMeta extends MetaObject> = string | undefined | {
+    target?: string | string[];
+    description?: string;
+    reenter?: boolean;
+    meta?: TMeta;
+    input?: Record<string, unknown> | ((args: {
+        context: any;
+        event: any;
+    }) => Record<string, unknown>);
+} | {
+    to?: TransitionConfigFunction<TContext, TExpressionEvent, TEvent, TEmitted, TActionMap, TActorMap, TGuardMap, TDelayMap, TMeta>;
+    description?: string;
+    reenter?: boolean;
+    meta?: TMeta;
+    input?: Record<string, unknown> | ((args: {
+        context: any;
+        event: any;
+    }) => Record<string, unknown>);
+} | TransitionConfigFunction<TContext, TExpressionEvent, TEvent, TEmitted, TActionMap, TActorMap, TGuardMap, TDelayMap, TMeta>;
+export type WithDefault<T, Default> = IsNever<T> extends true ? Default : T;
+export interface Implementations {
+    actions: Record<string, (...args: any[]) => void | {
+        context?: any;
+        children?: any;
+    }>;
+    guards: Record<string, (...args: any[]) => boolean>;
+    delays: Record<string, number | ((...args: any[]) => number)>;
+    actors: Record<string, AnyActorLogic>;
+}
+export type DelayMapFromNames<TDelays extends string, _TDelayMap extends Implementations['delays']> = string extends TDelays ? Implementations['delays'] : {
+    [K in TDelays]: Implementations['delays'][string];
+};
+type DelayNamesFromConfig<TConfig> = TConfig extends {
+    delays: infer TDelays;
+} ? Extract<keyof TDelays, string> : string;
+type InvalidDelayReferences<TConfig, TDelays extends string> = (TConfig extends {
+    after: infer TAfter;
+} ? Exclude<Extract<keyof TAfter, string>, TDelays> : never) | (TConfig extends {
+    timeout: infer TTimeout;
+} ? TTimeout extends string ? TTimeout extends TDelays ? never : TTimeout : never : never) | (TConfig extends {
+    states: infer TStates;
+} ? TStates extends Record<string, unknown> ? {
+    [K in keyof TStates]: InvalidDelayReferences<TStates[K], TDelays>;
+}[keyof TStates] : never : never);
+export type ValidateDelayReferences<TConfig> = string extends DelayNamesFromConfig<TConfig> ? unknown : InvalidDelayReferences<TConfig, DelayNamesFromConfig<TConfig>> extends never ? unknown : never;
+export {};

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

@@ -1,15 +1,16 @@
 import type { StateNode } from "./StateNode.js";
-import type { AnyActorRef, AnyEventObject, AnyMachineSnapshot, AnyStateMachine, AnyTransitionConfig, ErrorActorEvent, EventObject, MachineContext, Mapper, NonReducibleUnknown, Observer, SingleOrArray, StateValue, TransitionConfigTarget } from "./types.js";
+import type { AnyActor, AnyEventObject, AnyMachineSnapshot, AnyStateMachine, AnyTransitionConfig, AnyTransitionConfigFunction, ErrorActorEvent, EventObject, MachineContext, Mapper, NonReducibleUnknown, Observer, SingleOrArray, StateValue, TransitionConfigTarget } from "./types.js";
 export declare function matchesState(parentStateId: StateValue, childStateId: StateValue): boolean;
+export declare function checkStateIn(snapshot: AnyMachineSnapshot, stateValue: StateValue): boolean;
 export declare function toStatePath(stateId: string | string[]): string[];
 export declare function pathToStateValue(statePath: string[]): StateValue;
 export declare function mapValues<P, O extends Record<string, unknown>>(collection: O, iteratee: (item: O[keyof O], key: keyof O, collection: O, i: number) => P): {
     [key in keyof O]: P;
 };
 export declare function toArray<T>(value: readonly T[] | T | undefined): readonly T[];
-export declare function resolveOutput<TContext extends MachineContext, TExpressionEvent extends EventObject>(mapper: Mapper<TContext, TExpressionEvent, unknown, EventObject> | NonReducibleUnknown, context: TContext, event: TExpressionEvent, self: AnyActorRef): unknown;
+export declare function resolveOutput<TContext extends MachineContext, TExpressionEvent extends EventObject>(mapper: Mapper<TContext, TExpressionEvent, unknown, EventObject> | NonReducibleUnknown, context: TContext, event: TExpressionEvent, self: AnyActor): unknown;
 export declare function isErrorActorEvent(event: AnyEventObject): event is ErrorActorEvent;
-export declare function toTransitionConfigArray(configLike: SingleOrArray<AnyTransitionConfig | TransitionConfigTarget>): Array<AnyTransitionConfig>;
+export declare function toTransitionConfigArray(configLike: SingleOrArray<AnyTransitionConfig | TransitionConfigTarget | AnyTransitionConfigFunction>): Array<AnyTransitionConfig>;
 export declare function normalizeTarget<TContext extends MachineContext, TEvent extends EventObject>(target: SingleOrArray<string | StateNode<TContext, TEvent>> | undefined): ReadonlyArray<string | StateNode<TContext, TEvent>> | undefined;
 export declare function toObserver<T>(nextHandler?: Observer<T> | ((value: T) => void), errorHandler?: (error: any) => void, completionHandler?: () => void): Observer<T>;
 export declare function createInvokeId(stateNodeId: string, index: number): string;