xstate 5.4.0 → 5.5.0

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

@@ -1,10 +1,11 @@
 import { MachineSnapshot } from "./State.js";
 import { StateNode } from "./StateNode.js";
-import type { AreAllImplementationsAssumedToBeProvided, MarkAllImplementationsAsProvided, ResolveTypegenMeta, TypegenDisabled } from "./typegenTypes.js";
-import type { ActorScope, ActorLogic, EventObject, InternalMachineImplementations, MachineConfig, MachineContext, MachineImplementationsSimplified, NoInfer, StateMachineDefinition, StateValue, TransitionDefinition, ParameterizedObject, AnyActorScope, ProvidedActor, AnyActorRef, Equals, TODO, Snapshot, HistoryValue, EventDescriptor } from "./types.js";
+import { AnyActorSystem } from "./system.js";
+import { ResolveTypegenMeta, TypegenDisabled } from "./typegenTypes.js";
+import type { ActorLogic, ActorScope, AnyActorRef, AnyActorScope, Equals, EventDescriptor, EventObject, HistoryValue, InternalMachineImplementations, MachineConfig, MachineContext, MachineImplementationsSimplified, NoInfer, ParameterizedObject, ProvidedActor, Snapshot, StateMachineDefinition, StateValue, TransitionDefinition } from "./types.js";
 export declare const STATE_IDENTIFIER = "#";
 export declare const WILDCARD = "*";
-export declare class StateMachine<TContext extends MachineContext, TEvent extends EventObject, TChildren extends Record<string, AnyActorRef | undefined>, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string, TStateValue extends StateValue, TTag extends string, TInput, TOutput, TResolvedTypesMeta = ResolveTypegenMeta<TypegenDisabled, NoInfer<TEvent>, TActor, TAction, TGuard, TDelay, TTag>> implements ActorLogic<MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TResolvedTypesMeta>, TEvent, TInput, TODO> {
+export declare class StateMachine<TContext extends MachineContext, TEvent extends EventObject, TChildren extends Record<string, AnyActorRef | undefined>, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string, TStateValue extends StateValue, TTag extends string, TInput, TOutput, TResolvedTypesMeta = ResolveTypegenMeta<TypegenDisabled, NoInfer<TEvent>, TActor, TAction, TGuard, TDelay, TTag>> implements ActorLogic<MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput>, TEvent, TInput, AnyActorSystem> {
     /**
      * The raw config used to create the machine.
      */
@@ -14,8 +15,6 @@ export declare class StateMachine<TContext extends MachineContext, TEvent extend
      */
     version?: string;
     implementations: MachineImplementationsSimplified<TContext, TEvent>;
-    __xstatenode: true;
-    idMap: Map<string, StateNode<TContext, TEvent>>;
     root: StateNode<TContext, TEvent>;
     id: string;
     states: StateNode<TContext, TEvent>['states'];
@@ -34,7 +33,7 @@ export declare class StateMachine<TContext extends MachineContext, TEvent extend
      *
      * @returns A new `StateMachine` instance with the provided implementations.
      */
-    provide(implementations: InternalMachineImplementations<TContext, TResolvedTypesMeta, true>): StateMachine<TContext, TEvent, TChildren, TActor, TAction, TGuard, TDelay, TStateValue, TTag, TInput, TOutput, AreAllImplementationsAssumedToBeProvided<TResolvedTypesMeta> extends false ? MarkAllImplementationsAsProvided<TResolvedTypesMeta> : TResolvedTypesMeta>;
+    provide(implementations: InternalMachineImplementations<TContext, TResolvedTypesMeta, true>): StateMachine<TContext, TEvent, TChildren, TActor, TAction, TGuard, TDelay, TStateValue, TTag, TInput, TOutput, TResolvedTypesMeta>;
     resolveState(config: {
         value: StateValue;
         context?: TContext;
@@ -44,7 +43,7 @@ export declare class StateMachine<TContext extends MachineContext, TEvent extend
         error?: unknown;
     } & (Equals<TContext, MachineContext> extends false ? {
         context: unknown;
-    } : {})): MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TResolvedTypesMeta>;
+    } : {})): MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput>;
     /**
      * Determines the next snapshot given the current `snapshot` and received `event`.
      * Calculates a full macrostep from all microsteps.
@@ -52,7 +51,7 @@ export declare class StateMachine<TContext extends MachineContext, TEvent extend
      * @param snapshot The current snapshot
      * @param event The received event
      */
-    transition(snapshot: MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TResolvedTypesMeta>, event: TEvent, actorScope: ActorScope<typeof snapshot, TEvent>): MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TResolvedTypesMeta>;
+    transition(snapshot: MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput>, event: TEvent, actorScope: ActorScope<typeof snapshot, TEvent>): MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput>;
     /**
      * Determines the next state given the current `state` and `event`.
      * Calculates a microstep.
@@ -60,8 +59,8 @@ export declare class StateMachine<TContext extends MachineContext, TEvent extend
      * @param state The current state
      * @param event The received event
      */
-    microstep(snapshot: MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TResolvedTypesMeta>, event: TEvent, actorScope: AnyActorScope): Array<MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TResolvedTypesMeta>>;
-    getTransitionData(snapshot: MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TResolvedTypesMeta>, event: TEvent): Array<TransitionDefinition<TContext, TEvent>>;
+    microstep(snapshot: MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput>, event: TEvent, actorScope: AnyActorScope): Array<MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput>>;
+    getTransitionData(snapshot: MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput>, event: TEvent): Array<TransitionDefinition<TContext, TEvent>>;
     /**
      * The initial state _before_ evaluating any microsteps.
      * This "pre-initial" state is provided to initial actions executed in the initial state.
@@ -70,13 +69,15 @@ export declare class StateMachine<TContext extends MachineContext, TEvent extend
     /**
      * Returns the initial `State` instance, with reference to `self` as an `ActorRef`.
      */
-    getInitialSnapshot(actorScope: ActorScope<MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TResolvedTypesMeta>, TEvent>, input?: TInput): MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TResolvedTypesMeta>;
-    start(snapshot: MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TResolvedTypesMeta>): void;
+    getInitialSnapshot(actorScope: ActorScope<MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput>, TEvent>, input?: TInput): MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput>;
+    start(snapshot: MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput>): void;
     getStateNodeById(stateId: string): StateNode<TContext, TEvent>;
     get definition(): StateMachineDefinition<TContext, TEvent>;
     toJSON(): StateMachineDefinition<TContext, TEvent>;
-    getPersistedSnapshot(snapshot: MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TResolvedTypesMeta>, options?: unknown): Snapshot<unknown>;
-    restoreSnapshot(snapshot: Snapshot<unknown>, _actorScope: ActorScope<MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TResolvedTypesMeta>, TEvent>): MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TResolvedTypesMeta>;
-    /** @deprecated an internal property acting as a "phantom" type, not meant to be used at runtime */
+    getPersistedSnapshot(snapshot: MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput>, options?: unknown): Snapshot<unknown>;
+    restoreSnapshot(snapshot: Snapshot<unknown>, _actorScope: ActorScope<MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput>, TEvent>): MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput>;
+    /**
+     * @deprecated an internal property that was acting as a "phantom" type, it's not used by anything right now but it's kept around for compatibility reasons
+     **/
     __TResolvedTypesMeta: TResolvedTypesMeta;
 }

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

@@ -1,4 +1,3 @@
-import { MachineSnapshot } from "./State.js";
 import type { StateMachine } from "./StateMachine.js";
 import type { DelayedTransitionDefinition, EventObject, InitialTransitionDefinition, InvokeDefinition, MachineContext, Mapper, StateNodeConfig, StateNodeDefinition, StateNodesConfig, TransitionDefinition, TransitionDefinitionMap, TODO, UnknownAction, ParameterizedObject, AnyStateMachine, ProvidedActor, NonReducibleUnknown, EventDescriptor } from "./types.js";
 interface StateNodeOptions<TContext extends MachineContext, TEvent extends EventObject> {
@@ -99,12 +98,10 @@ export declare class StateNode<TContext extends MachineContext = MachineContext,
     TODO, // guards
     TODO, // delays
     TODO>, options: StateNodeOptions<TContext, TEvent>);
-    _initialize(): void;
     /**
      * The well-structured state node definition.
      */
     get definition(): StateNodeDefinition<TContext, TEvent>;
-    toJSON(): StateNodeDefinition<TContext, TEvent>;
     /**
      * The logic invoked as actors by this state node.
      */
@@ -115,7 +112,6 @@ export declare class StateNode<TContext extends MachineContext = MachineContext,
     get on(): TransitionDefinitionMap<TContext, TEvent>;
     get after(): Array<DelayedTransitionDefinition<TContext, TEvent>>;
     get initial(): InitialTransitionDefinition<TContext, TEvent>;
-    next(snapshot: MachineSnapshot<TContext, TEvent, any, any, any, any>, event: TEvent): TransitionDefinition<TContext, TEvent>[] | undefined;
     /**
      * All the event types accepted by this state node and its descendants.
      */

package/dist/declarations/src/actions/assign.d.ts

@@ -10,7 +10,34 @@ export interface AssignAction<TContext extends MachineContext, TExpressionEvent
 /**
  * Updates the current context of the machine.
  *
- * @param assignment An object that represents the partial context to update.
+ * @param assignment An object that represents the partial context to update, or a
+ * function that returns an object that represents the partial context to update.
+ *
+ * @example
+  ```ts
+  import { createMachine, assign } from 'xstate';
+
+  const countMachine = createMachine({
+    context: {
+      count: 0,
+      message: ''
+    },
+    on: {
+      inc: {
+        actions: assign({
+          count: ({ context }) => context.count + 1
+        })
+      },
+      updateMessage: {
+        actions: assign(({ context, event }) => {
+          return {
+            message: event.message.trim()
+          }
+        })
+      }
+    }
+  });
+  ```
  */
 export declare function assign<TContext extends MachineContext, TExpressionEvent extends AnyEventObject = AnyEventObject, // TODO: consider using a stricter `EventObject` here
 TParams extends ParameterizedObject['params'] | undefined = ParameterizedObject['params'] | undefined, TEvent extends EventObject = EventObject, TActor extends ProvidedActor = ProvidedActor>(assignment: Assigner<LowInfer<TContext>, TExpressionEvent, TParams, TEvent, TActor> | PropertyAssigner<LowInfer<TContext>, TExpressionEvent, TParams, TEvent, TActor>): AssignAction<TContext, TExpressionEvent, TParams, TEvent, TActor>;

package/dist/declarations/src/actions/cancel.d.ts

@@ -4,11 +4,30 @@ export interface CancelAction<TContext extends MachineContext, TExpressionEvent
     (args: ActionArgs<TContext, TExpressionEvent, TEvent>, params: TParams): void;
 }
 /**
- * Cancels an in-flight `send(...)` action. A canceled sent action will not
- * be executed, nor will its event be sent, unless it has already been sent
- * (e.g., if `cancel(...)` is called after the `send(...)` action's `delay`).
+ * Cancels a delayed `sendTo(...)` action that is waiting to be executed. The canceled `sendTo(...)` action
+ * will not send its event or execute, unless the `delay` has already elapsed before `cancel(...)` is called.
  *
- * @param sendId The `id` of the `send(...)` action to cancel.
+ * @param sendId The `id` of the `sendTo(...)` action to cancel.
+ *
+ * @example
+  ```ts
+  import { createMachine, sendTo, cancel } from 'xstate';
+
+  const machine = createMachine({
+    // ...
+    on: {
+      sendEvent: {
+        actions: sendTo('some-actor', { type: 'someEvent' }, {
+          id: 'some-id',
+          delay: 1000
+        })
+      },
+      cancelEvent: {
+        actions: cancel('some-id')
+      }
+    }
+  });
+  ```
  */
 export declare function cancel<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject>(sendId: ResolvableSendId<TContext, TExpressionEvent, TParams, TEvent>): CancelAction<TContext, TExpressionEvent, TParams, TEvent>;
 export {};

package/dist/declarations/src/actions/enqueueActions.d.ts

@@ -28,5 +28,25 @@ interface CollectActionsArg<TContext extends MachineContext, TExpressionEvent ex
     enqueue: ActionEnqueuer<TContext, TExpressionEvent, TEvent, TActor, TAction, TGuard, TDelay>;
 }
 type CollectActions<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string> = ({ context, event, check, enqueue, self }: CollectActionsArg<TContext, TExpressionEvent, TEvent, TActor, TAction, TGuard, TDelay>) => void;
+/**
+ * Creates an action object that will execute actions that are queued by the `enqueue(action)` function.
+ *
+ * @example
+  ```ts
+  import { createMachine, enqueueActions } from 'xstate';
+
+  const machine = createMachine({
+    entry: enqueueActions(({ enqueue, check }) => {
+      enqueue.assign({ count: 0 });
+
+      if (check('someGuard')) {
+        enqueue.assign({ count: 1 });
+      }
+
+      enqueue('someAction');
+    })
+  })
+  ```
+ */
 export declare function enqueueActions<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject = TExpressionEvent, TActor extends ProvidedActor = ProvidedActor, TAction extends ParameterizedObject = ParameterizedObject, TGuard extends ParameterizedObject = ParameterizedObject, TDelay extends string = string>(collect: CollectActions<TContext, TExpressionEvent, TEvent, TActor, TAction, TGuard, TDelay>): EnqueueActionsAction<TContext, TExpressionEvent, TEvent, TActor, TAction, TGuard, TDelay>;
 export {};

package/dist/declarations/src/actions/send.d.ts

@@ -22,9 +22,9 @@ export declare function sendTo<TContext extends MachineContext, TExpressionEvent
 export declare function sendParent<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TSentEvent extends EventObject = AnyEventObject, TEvent extends EventObject = AnyEventObject, TDelay extends string = string>(event: TSentEvent | SendExpr<TContext, TExpressionEvent, TParams, TSentEvent, TEvent>, options?: SendToActionOptions<TContext, TExpressionEvent, TParams, TEvent, TDelay>): SendToAction<TContext, TExpressionEvent, TParams, TEvent, TDelay>;
 type Target<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject> = string | ActorRef<any, any> | ((args: ActionArgs<TContext, TExpressionEvent, TEvent>, params: TParams) => string | ActorRef<any, any>);
 /**
- * Forwards (sends) an event to a specified service.
+ * Forwards (sends) an event to the `target` actor.
  *
- * @param target The target service to forward the event to.
+ * @param target The target actor to forward the event to.
  * @param options Options to pass into the send action creator.
  */
 export declare function forwardTo<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject, TDelay extends string>(target: Target<TContext, TExpressionEvent, TParams, TEvent>, options?: SendToActionOptions<TContext, TExpressionEvent, TParams, TEvent, TDelay>): SendToAction<TContext, TExpressionEvent, TParams, TEvent, TDelay>;

package/dist/declarations/src/{interpreter.d.ts → createActor.d.ts}

@@ -1,7 +1,6 @@
 import { symbolObservable } from "./symbolObservable.js";
 import { AnyActorSystem, Clock } from "./system.js";
-import { AreAllImplementationsAssumedToBeProvided, MissingImplementationsError } from "./typegenTypes.js";
-import type { AnyActorLogic, AnyStateMachine, EventFromLogic, Snapshot, SnapshotFrom } from "./types.js";
+import type { AnyActorLogic, EventFromLogic, Snapshot, SnapshotFrom } from "./types.js";
 import { ActorOptions, ActorRef, EventObject, InteropSubscribable, Observer, Subscription } from "./types.js";
 export declare const $$ACTOR_TYPE = 1;
 export type SnapshotListener<TLogic extends AnyActorLogic> = (snapshot: SnapshotFrom<TLogic>) => void;
@@ -35,7 +34,6 @@ export declare class Actor<TLogic extends AnyActorLogic> implements ActorRef<Sna
     private observers;
     private logger;
     _parent?: ActorRef<any, any>;
-    _syncSnapshot?: boolean;
     ref: ActorRef<SnapshotFrom<TLogic>, EventFromLogic<TLogic>>;
     private _actorScope;
     private _systemId;
@@ -196,7 +194,7 @@ export declare class Actor<TLogic extends AnyActorLogic> implements ActorRef<Sna
  * @param logic - The actor logic to create an actor from. For a state machine actor logic creator, see {@link createMachine}. Other actor logic creators include {@link fromCallback}, {@link fromEventObservable}, {@link fromObservable}, {@link fromPromise}, and {@link fromTransition}.
  * @param options - Actor options
  */
-export declare function createActor<TLogic extends AnyActorLogic>(logic: TLogic extends AnyStateMachine ? AreAllImplementationsAssumedToBeProvided<TLogic['__TResolvedTypesMeta']> extends true ? TLogic : MissingImplementationsError<TLogic['__TResolvedTypesMeta']> : TLogic, options?: ActorOptions<TLogic>): Actor<TLogic>;
+export declare function createActor<TLogic extends AnyActorLogic>(logic: TLogic, options?: ActorOptions<TLogic>): Actor<TLogic>;
 /**
  * Creates a new Interpreter instance for the given machine with the provided options, if any.
  *

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

@@ -15,6 +15,46 @@ type FilterLeafValues<TLeafCandidate extends string, TNonLeaf extends {
 type ToStateValue<TTestValue extends string | TestValue> = FilterLeafValues<GroupTestValues<TTestValue>['leafCandidates'], GroupTestValues<TTestValue>['nonLeaf']> | (IsNever<GroupTestValues<TTestValue>['nonLeaf']> extends false ? {
     [K in keyof GroupTestValues<TTestValue>['nonLeaf']]: ToStateValue<NonNullable<GroupTestValues<TTestValue>['nonLeaf'][K]>>;
 } : never);
+/**
+ * Creates a state machine (statechart) with the given configuration.
+ *
+ * The state machine represents the pure logic of a state machine actor.
+ *
+ * @param config The state machine configuration.
+ * @param options DEPRECATED: use `setup({ ... })` or `machine.provide({ ... })` to provide machine implementations instead.
+ *
+ * @example
+  ```ts
+  import { createMachine } from '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' });
+  ```
+ */
 export declare function createMachine<TContext extends MachineContext, TEvent extends AnyEventObject, // TODO: consider using a stricter `EventObject` here
 TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string, TTag extends string, TInput, TOutput extends NonReducibleUnknown, TTypesMeta extends TypegenConstraint = TypegenDisabled>(config: MachineConfig<TContext, TEvent, TActor, TAction, TGuard, TDelay, TTag, TInput, TOutput, TTypesMeta>, implementations?: InternalMachineImplementations<TContext, ResolveTypegenMeta<TTypesMeta, TEvent, TActor, TAction, TGuard, TDelay, TTag>>): StateMachine<TContext, TEvent, Cast<ToChildren<TActor>, Record<string, AnyActorRef | undefined>>, TActor, TAction, TGuard, TDelay, 'matchesStates' extends keyof TTypesMeta ? ToStateValue<Cast<TTypesMeta['matchesStates'], TestValue>> : StateValue, Prop<ResolveTypegenMeta<TTypesMeta, TEvent, TActor, TAction, TGuard, TDelay, TTag>['resolved'], 'tags'> & string, TInput, TOutput, ResolveTypegenMeta<TTypesMeta, TEvent, TActor, TAction, TGuard, TDelay, TTag>>;
 export {};

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

@@ -0,0 +1,32 @@
+import { AnyActorLogic, EventFromLogic, InputFrom, SnapshotFrom } from "./types.js";
+export declare function getInitialSnapshot<T extends AnyActorLogic>(actorLogic: T, ...[input]: undefined extends InputFrom<T> ? [input?: InputFrom<T>] : [input: InputFrom<T>]): SnapshotFrom<T>;
+/**
+ * Determines the next snapshot for the given `actorLogic` based on
+ * the given `snapshot` and `event`.
+ *
+ * If the `snapshot` is `undefined`, the initial snapshot of the
+ * `actorLogic` is used.
+ *
+ * @example
+  ```ts
+  import { getNextSnapshot } from 'xstate';
+  import { trafficLightMachine } from './trafficLightMachine.ts';
+
+  const nextSnapshot = getNextSnapshot(
+    trafficLightMachine, // actor logic
+    undefined, // snapshot (or initial state if undefined)
+    { type: 'TIMER' }); // event object
+
+  console.log(nextSnapshot.value);
+  // => 'yellow'
+
+  const nextSnapshot2 = getNextSnapshot(
+    trafficLightMachine, // actor logic
+    nextSnapshot, // snapshot
+    { type: 'TIMER' }); // event object
+
+  console.log(nextSnapshot2.value);
+  // =>'red'
+  ```
+ */
+export declare function getNextSnapshot<T extends AnyActorLogic>(actorLogic: T, snapshot: SnapshotFrom<T>, event: EventFromLogic<T>): SnapshotFrom<T>;

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

@@ -26,12 +26,98 @@ export type UnknownGuard = UnknownReferencedGuard | UnknownInlineGuard;
 type UnknownReferencedGuard = Guard<MachineContext, EventObject, ParameterizedObject['params'], ParameterizedObject>;
 type UnknownInlineGuard = Guard<MachineContext, EventObject, undefined, ParameterizedObject>;
 export declare function stateIn<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined>(stateValue: StateValue): GuardPredicate<TContext, TExpressionEvent, TParams, any>;
+/**
+ * Higher-order guard that evaluates to `true` if the `guard` passed to it evaluates to `false`.
+ *
+ * @category Guards
+ * @example
+  ```ts
+  import { setup, not } from 'xstate';
+
+  const machine = setup({
+    guards: {
+      someNamedGuard: () => false
+    }
+  }).createMachine({
+    on: {
+      someEvent: {
+        guard: not('someNamedGuard'),
+        actions: () => {
+          // will be executed if guard in `not(...)`
+          // evaluates to `false`
+        }
+      }
+    }
+  });
+  ```
+ * @returns A guard
+ */
 export declare function not<TContext extends MachineContext, TExpressionEvent extends EventObject, TArg>(guard: SingleGuardArg<TContext, TExpressionEvent, unknown, TArg>): GuardPredicate<TContext, TExpressionEvent, unknown, NormalizeGuardArg<NoInfer<TArg>>>;
+/**
+ * Higher-order guard that evaluates to `true` if all `guards` passed to it
+ * evaluate to `true`.
+ *
+ * @category Guards
+ * @example
+  ```ts
+  import { setup, and } from 'xstate';
+
+  const machine = setup({
+    guards: {
+      someNamedGuard: () => true
+    }
+  }).createMachine({
+    on: {
+      someEvent: {
+        guard: and([
+          ({ context }) => context.value > 0,
+          'someNamedGuard'
+        ]),
+        actions: () => {
+          // will be executed if all guards in `and(...)`
+          // evaluate to true
+        }
+      }
+    }
+  });
+  ```
+ * @returns A guard action object
+ */
 export declare function and<TContext extends MachineContext, TExpressionEvent extends EventObject, TArg extends unknown[]>(guards: readonly [
     ...{
         [K in keyof TArg]: SingleGuardArg<TContext, TExpressionEvent, unknown, TArg[K]>;
     }
 ]): GuardPredicate<TContext, TExpressionEvent, unknown, NormalizeGuardArgArray<NoInfer<TArg>>>;
+/**
+ * Higher-order guard that evaluates to `true` if any of the `guards` passed to it
+ * evaluate to `true`.
+ *
+ * @category Guards
+ * @example
+  ```ts
+  import { setup, or } from 'xstate';
+
+  const machine = setup({
+    guards: {
+      someNamedGuard: () => true
+    }
+  }).createMachine({
+    on: {
+      someEvent: {
+        guard: or([
+          ({ context }) => context.value > 0,
+          'someNamedGuard'
+        ]),
+        actions: () => {
+          // will be executed if any of the guards in `or(...)`
+          // evaluate to true
+        }
+      }
+    }
+  });
+  ```
+ * @returns A guard action object
+ */
 export declare function or<TContext extends MachineContext, TExpressionEvent extends EventObject, TArg extends unknown[]>(guards: readonly [
     ...{
         [K in keyof TArg]: SingleGuardArg<TContext, TExpressionEvent, unknown, TArg[K]>;

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

@@ -9,7 +9,8 @@ export * from "./typegenTypes.js";
 export * from "./types.js";
 export { waitFor } from "./waitFor.js";
 import { createMachine } from "./createMachine.js";
-import { Actor, createActor, interpret, Interpreter } from "./interpreter.js";
+export { getNextSnapshot } from "./getNextSnapshot.js";
+import { Actor, createActor, interpret, Interpreter } from "./createActor.js";
 import { StateNode } from "./StateNode.js";
 export { and, not, or, stateIn } from "./guards.js";
 export { setup } from "./setup.js";

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

@@ -1,4 +1,4 @@
-import { ActorRefFrom, AnyActorScope, AnyActorLogic, AnyActorRef, AnyEventObject, AnyMachineSnapshot, InputFrom, IsLiteralString, ProvidedActor, RequiredActorOptions, IsNotNever, ConditionalRequired } from "./types.js";
+import { ActorRefFrom, AnyActorLogic, AnyActorRef, AnyActorScope, AnyEventObject, AnyMachineSnapshot, ConditionalRequired, InputFrom, IsLiteralString, IsNotNever, ProvidedActor, RequiredActorOptions } from "./types.js";
 type SpawnOptions<TActor extends ProvidedActor, TSrc extends TActor['src']> = TActor extends {
     src: TSrc;
 } ? ConditionalRequired<[
@@ -17,7 +17,7 @@ type GetConcreteLogic<TActor extends ProvidedActor, TSrc extends TActor['src']>
 export type Spawner<TActor extends ProvidedActor> = IsLiteralString<TActor['src']> extends true ? <TSrc extends TActor['src']>(logic: TSrc, ...[options]: SpawnOptions<TActor, TSrc>) => ActorRefFrom<GetConcreteLogic<TActor, TSrc>> : <TLogic extends AnyActorLogic | string>(src: TLogic, options?: {
     id?: string;
     systemId?: string;
-    input?: unknown;
+    input?: TLogic extends string ? unknown : InputFrom<TLogic>;
     syncSnapshot?: boolean;
 }) => TLogic extends string ? AnyActorRef : ActorRefFrom<TLogic>;
 export declare function createSpawner(actorScope: AnyActorScope, { machine, context }: AnyMachineSnapshot, event: AnyEventObject, spawnedChildren: Record<string, AnyActorRef>): Spawner<any>;

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

@@ -1,10 +1,19 @@
-import { Compute, EventObject, IndexByType, IsNever, Prop, Values, IsAny, ParameterizedObject, ProvidedActor, OutputFrom, AnyActorLogic, IndexByProp } from "./types.js";
+import { EventObject, IndexByType, IsNever, Prop, ParameterizedObject, ProvidedActor, OutputFrom, AnyActorLogic, IndexByProp } from "./types.js";
+/**
+ * @deprecated
+ */
 export interface TypegenDisabled {
     '@@xstate/typegen': false;
 }
+/**
+ * @deprecated
+ */
 export interface TypegenEnabled {
     '@@xstate/typegen': true;
 }
+/**
+ * @deprecated
+ */
 export interface TypegenMeta extends TypegenEnabled {
     /**
      * Allows you to specify all the results of state.matches
@@ -77,6 +86,9 @@ export interface TypegenMeta extends TypegenEnabled {
      */
     eventsCausingActors: Record<string, string>;
 }
+/**
+ * @deprecated
+ */
 export interface ResolvedTypegenMeta extends TypegenMeta {
     resolved: TypegenMeta & {
         indexedActors: Record<string, ProvidedActor>;
@@ -86,16 +98,17 @@ export interface ResolvedTypegenMeta extends TypegenMeta {
         indexedDelays: Record<string, ParameterizedObject>;
     };
 }
+/**
+ * @deprecated
+ */
 export type TypegenConstraint = TypegenEnabled | TypegenDisabled;
-export type AreAllImplementationsAssumedToBeProvided<TResolvedTypesMeta, TMissingImplementations = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'missingImplementations'>> = IsAny<TResolvedTypesMeta> extends true ? true : TResolvedTypesMeta extends TypegenEnabled ? IsNever<Values<{
-    [K in keyof TMissingImplementations]: TMissingImplementations[K];
-}>> extends true ? true : false : true;
-export type MissingImplementationsError<TResolvedTypesMeta, TMissingImplementations = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'missingImplementations'>> = Compute<[
-    'Some implementations missing',
-    Values<{
-        [K in keyof TMissingImplementations]: TMissingImplementations[K];
-    }>
-]>;
+/**
+ * @deprecated Always resolves to `true`
+ */
+export type AreAllImplementationsAssumedToBeProvided<_TResolvedTypesMeta, _TMissingImplementations> = true;
+/**
+ * @deprecated
+ */
 interface AllImplementationsProvided {
     missingImplementations: {
         actions: never;
@@ -104,10 +117,6 @@ interface AllImplementationsProvided {
         guards: never;
     };
 }
-export interface MarkAllImplementationsAsProvided<TResolvedTypesMeta> {
-    '@@xstate/typegen': Prop<TResolvedTypesMeta, '@@xstate/typegen'>;
-    resolved: Prop<TResolvedTypesMeta, 'resolved'> & AllImplementationsProvided;
-}
 type GenerateActorEvents<TActor extends ProvidedActor, TInvokeSrcNameMap> = string extends TActor['src'] ? never : TActor extends any ? {
     type: TActor['id'] extends string ? `xstate.done.actor.${TActor['id']}` : TActor['src'] extends keyof TInvokeSrcNameMap ? `xstate.done.actor.${TInvokeSrcNameMap[TActor['src']] & string}` : `xstate.done.actor.${string}`;
     output: OutputFrom<TActor['logic']>;
@@ -123,6 +132,9 @@ type IndexParameterizedImplementation<TParameterizedImplementation extends Param
 type WrapIntoParameterizedObject<T extends string> = T extends any ? {
     type: T;
 } : never;
+/**
+ * @deprecated
+ */
 export interface ResolveTypegenMeta<TTypesMeta extends TypegenConstraint, TEvent extends EventObject, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string, TTag extends string> {
     '@@xstate/typegen': TTypesMeta['@@xstate/typegen'];
     resolved: {