@systemfsoftware/xstate 0.0.0-stage → 6.0.0-beta.65

package/dist/index-DDWoKIF5.d.ts

@@ -0,0 +1,512 @@
+import { f as StandardSchemaV1, n as EventObject } from "./base.types-DF8ZPiXj.js";
+import { Ar as ActorSystemRuntime, Bn as Subscribable, C as AnyActor, D as AnyEventObject, Hn as Subscription, T as AnyActorRef, Ur as ActorLogicValidator, Wt as NonReducibleUnknown, f as ActorRefFromLogic, h as ActorScope, hn as Snapshot, i as ActorFromLogic, jr as AnyActorSystem, s as ActorLogic, vt as ExecutableActionObject } from "./types-B2EAwOk-.js";
+/** @public */
+type LogicSnapshot<TContext, TOutput, TInput> = Snapshot<TOutput> & {
+  context: TContext;
+  input: TInput | undefined;
+  effects?: Record<string, LogicEffectState>;
+};
+/** @public */
+type LogicEffectState = {
+  status: 'active';
+} | {
+  status: 'done';
+  output?: unknown;
+} | {
+  status: 'error';
+  error: unknown;
+};
+/** @public */
+interface LogicArgs<TContext, TEvent extends EventObject, TInput> {
+  context: TContext;
+  event: TEvent;
+  input: TInput;
+  system: AnyActorSystem;
+  self: LogicActorRef<TContext, unknown, TEvent, TInput>;
+}
+/** @public */
+type LogicEffect<_TEvent extends EventObject, _TEmitted extends EventObject> = ExecutableActionObject;
+/** @public */
+interface LogicEnqueue<TEvent extends EventObject, TEmitted extends EventObject> {
+  emit: (emitted: TEmitted) => void;
+  sendBack: (event: EventObject) => void;
+  raise: (event: TEvent) => void;
+  effect: {
+    (exec: (runtime?: Partial<ActorSystemRuntime>) => void | (() => void)): void;
+    (key: string, exec: (runtime?: Partial<ActorSystemRuntime>) => void | (() => void)): void;
+  };
+}
+/** @public */
+type LogicPatch<TContext, TOutput, TInput> = Partial<{
+  context: TContext;
+  input: TInput | undefined;
+  status: LogicSnapshot<TContext, TOutput, TInput>['status'];
+  output: TOutput;
+  error: unknown;
+  effects: Record<string, LogicEffectState>;
+}>;
+/** @public */
+type LogicFunction<TContext, TOutput, TEvent extends EventObject, TInput, TEmitted extends EventObject> = (args: LogicArgs<TContext, TEvent, TInput>, enq: LogicEnqueue<TEvent, TEmitted>) => void | LogicPatch<TContext, TOutput, TInput>;
+/** @public */
+interface LogicConfig<TContext, TOutput, TEvent extends EventObject, TInput, TEmitted extends EventObject, TInputSchema extends StandardSchemaV1 = StandardSchemaV1, TOutputSchema extends StandardSchemaV1 = StandardSchemaV1> {
+  id?: string | undefined;
+  validator?: ActorLogicValidator | undefined;
+  schemas?: {
+    input?: TInputSchema;
+    output?: TOutputSchema;
+  } | undefined;
+  context: TContext | ((args: {
+    input: TInput;
+  }) => TContext);
+  run: LogicFunction<TContext, TOutput, TEvent, TInput, TEmitted>;
+}
+interface LogicTransition<TContext, TOutput, TEvent extends EventObject, TInput, TEmitted extends EventObject> {
+  (snapshot: LogicSnapshot<TContext, TOutput, TInput>, event: TEvent, actorScope: ActorScope<LogicSnapshot<TContext, TOutput, TInput>, TEvent, AnyActorSystem, TEmitted>): [LogicSnapshot<TContext, TOutput, TInput>, LogicEffect<TEvent, TEmitted>[]];
+  (snapshot: LogicSnapshot<TContext, TOutput, TInput>, event: TEvent, actorScope: ActorScope<LogicSnapshot<TContext, TOutput, TInput>, TEvent, AnyActorSystem, TEmitted>): LogicSnapshot<TContext, TOutput, TInput>;
+}
+/** @public */
+type LogicActorLogic<TContext, TOutput, TEvent extends EventObject = EventObject, TInput = NonReducibleUnknown, TEmitted extends EventObject = EventObject> = Omit<ActorLogic<LogicSnapshot<TContext, TOutput, TInput>, TEvent, TInput, AnyActorSystem, TEmitted>, 'transition'> & {
+  id?: string | undefined;
+  transition: LogicTransition<TContext, TOutput, TEvent, TInput, TEmitted>;
+};
+/** @public */
+type LogicActorRef<TContext, TOutput, TEvent extends EventObject, TInput> = ActorRefFromLogic<LogicActorLogic<TContext, TOutput, TEvent, TInput>>;
+/** @public */
+declare function createLogic<TContext, const TInputSchema extends StandardSchemaV1, const TOutputSchema extends StandardSchemaV1, TEvent extends EventObject = EventObject, TEmitted extends EventObject = EventObject>(config: LogicConfig<TContext, StandardSchemaV1.InferOutput<TOutputSchema>, TEvent, StandardSchemaV1.InferOutput<TInputSchema>, TEmitted, TInputSchema, TOutputSchema> & {
+  schemas: {
+    input: TInputSchema;
+    output: TOutputSchema;
+  };
+}): LogicActorLogic<TContext, StandardSchemaV1.InferOutput<TOutputSchema>, TEvent, StandardSchemaV1.InferOutput<TInputSchema>, TEmitted>;
+declare function createLogic<TContext, TOutput, const TInputSchema extends StandardSchemaV1, TEvent extends EventObject = EventObject, TEmitted extends EventObject = EventObject>(config: LogicConfig<TContext, TOutput, TEvent, StandardSchemaV1.InferOutput<TInputSchema>, TEmitted, TInputSchema> & {
+  schemas: {
+    input: TInputSchema;
+    output?: undefined;
+  };
+}): LogicActorLogic<TContext, TOutput, TEvent, StandardSchemaV1.InferOutput<TInputSchema>, TEmitted>;
+declare function createLogic<TContext, const TOutputSchema extends StandardSchemaV1, TEvent extends EventObject = EventObject, TInput = NonReducibleUnknown, TEmitted extends EventObject = EventObject>(config: LogicConfig<TContext, StandardSchemaV1.InferOutput<TOutputSchema>, TEvent, TInput, TEmitted, StandardSchemaV1, TOutputSchema> & {
+  schemas: {
+    input?: undefined;
+    output: TOutputSchema;
+  };
+}): LogicActorLogic<TContext, StandardSchemaV1.InferOutput<TOutputSchema>, TEvent, TInput, TEmitted>;
+declare function createLogic<TContext, TOutput = unknown, TEvent extends EventObject = EventObject, TInput = NonReducibleUnknown, TEmitted extends EventObject = EventObject>(config: LogicConfig<TContext, TOutput, TEvent, TInput, TEmitted>): LogicActorLogic<TContext, TOutput, TEvent, TInput, TEmitted>;
+/** @public */
+type CallbackSnapshot<TInput> = Snapshot<undefined> & {
+  input: TInput;
+  effects?: Record<string, {
+    status: 'active';
+  } | {
+    status: 'done';
+    output?: unknown;
+  } | {
+    status: 'error';
+    error: unknown;
+  }>;
+};
+/** @public */
+type CallbackActorLogic<TEvent extends EventObject, TInput = NonReducibleUnknown, TEmitted extends EventObject = EventObject> = ActorLogic<CallbackSnapshot<TInput>, TEvent, TInput, AnyActorSystem, TEmitted>;
+/**
+ * Represents an actor created by `createCallbackLogic`.
+ *
+ * The type of `self` within the actor's logic.
+ *
+ * @example
+ *
+ * ```ts
+ * import { createCallbackLogic, createActor } from '@systemfsoftware/xstate';
+ *
+ * // The events the actor receives.
+ * type Event = { type: 'someEvent' };
+ * // The actor's input.
+ * type Input = { name: string };
+ *
+ * // Actor logic that logs whenever it receives an event of type `someEvent`.
+ * const logic = createCallbackLogic<Event, Input>(
+ *   ({ self, input, receive }) => {
+ *     self;
+ *     // ^? CallbackActorRef<Event, Input>
+ *
+ *     receive((event) => {
+ *       if (event.type === 'someEvent') {
+ *         console.log(`${input.name}: received "someEvent" event`);
+ *         // logs 'myActor: received "someEvent" event'
+ *       }
+ *     });
+ *   }
+ * );
+ *
+ * const actor = createActor(logic, { input: { name: 'myActor' } });
+ * //    ^? CallbackActorRef<Event, Input>
+ * ```
+ *
+ * @see {@link (createCallbackLogic:1)}
+ * @public
+ */
+type CallbackActorRef<TEvent extends EventObject, TInput = NonReducibleUnknown> = ActorRefFromLogic<CallbackActorLogic<TEvent, TInput>>;
+type Receiver<TEvent extends EventObject> = (listener: {
+  bivarianceHack(event: TEvent): void;
+}['bivarianceHack']) => void;
+/** @public */
+type CallbackLogicFunction<TEvent extends EventObject = AnyEventObject, TSentEvent extends EventObject = AnyEventObject, TInput = NonReducibleUnknown, TEmitted extends EventObject = EventObject> = ({ input, system, self, sendBack, receive, emit }: {
+  /**
+   * Data that was provided to the callback actor
+   *
+   * @see {@link https://stately.ai/docs/input | Input docs}
+   */
+  input: TInput;
+  /** The actor system to which the callback actor belongs */
+  system: AnyActorSystem;
+  /** The parent actor of the callback actor */
+  self: CallbackActorRef<TEvent>;
+  /** A function that can send events back to the parent actor */
+  sendBack: (event: TSentEvent) => void;
+  /**
+   * A function that can be called with a listener function argument; the
+   * listener is then called whenever events are received by the callback actor
+   */
+  receive: Receiver<TEvent>;
+  emit: (emitted: TEmitted) => void;
+}) => (() => void) | void;
+/** @public */
+interface CallbackLogicConfig<TEvent extends EventObject = AnyEventObject, TSentEvent extends EventObject = AnyEventObject, TInput = NonReducibleUnknown, TEmitted extends EventObject = EventObject, TInputSchema extends StandardSchemaV1 = StandardSchemaV1> {
+  validator?: ActorLogicValidator;
+  schemas?: {
+    input?: TInputSchema;
+  };
+  run: CallbackLogicFunction<TEvent, TSentEvent, TInput, TEmitted>;
+}
+/**
+ * An actor logic creator which returns callback logic as defined by a callback
+ * function.
+ *
+ * @remarks
+ * Useful for subscription-based or other free-form logic that can send events
+ * back to the parent actor.
+ *
+ * Actors created from callback logic (“callback actors”) can:
+ *
+ * - Receive events via the `receive` function
+ * - Send events to the parent actor via the `sendBack` function
+ *
+ * Callback actors are a bit different from other actors in that they:
+ *
+ * - Do not work with `onDone`
+ * - Do not produce a snapshot using `.getSnapshot()`
+ * - Do not emit values when used with `.subscribe()`
+ * - Can not be stopped with `.stop()`
+ *
+ * @example
+ *
+ * ```typescript
+ * const callbackLogic = createCallbackLogic(({ sendBack, receive }) => {
+ *   let lockStatus = 'unlocked';
+ *
+ *   const handler = (event) => {
+ *     if (lockStatus === 'locked') {
+ *       return;
+ *     }
+ *     sendBack(event);
+ *   };
+ *
+ *   receive((event) => {
+ *     if (event.type === 'lock') {
+ *       lockStatus = 'locked';
+ *     } else if (event.type === 'unlock') {
+ *       lockStatus = 'unlocked';
+ *     }
+ *   });
+ *
+ *   document.body.addEventListener('click', handler);
+ *
+ *   return () => {
+ *     document.body.removeEventListener('click', handler);
+ *   };
+ * });
+ * ```
+ *
+ * @param callback - The callback function used to describe the callback logic
+ *   The callback function is passed an object with the following properties:
+ *
+ *   - `receive` - A function that can send events back to the parent actor; the
+ *       listener is then called whenever events are received by the callback
+ *       actor
+ *   - `sendBack` - A function that can send events back to the parent actor
+ *   - `input` - Data that was provided to the callback actor
+ *   - `self` - The parent actor of the callback actor
+ *   - `system` - The actor system to which the callback actor belongs The callback
+ *       function can (optionally) return a cleanup function, which is called
+ *       when the actor is stopped.
+ *
+ * @returns Callback logic
+ * @see {@link CallbackLogicFunction} for more information about the callback function and its object argument
+ * @see {@link https://stately.ai/docs/input | Input docs} for more information about how input is passed
+ * @public
+ */
+declare function createCallbackLogic<TEvent extends EventObject, const TInputSchema extends StandardSchemaV1, TEmitted extends EventObject = EventObject>(config: CallbackLogicConfig<TEvent, AnyEventObject, StandardSchemaV1.InferOutput<TInputSchema>, TEmitted, TInputSchema> & {
+  schemas: {
+    input: TInputSchema;
+  };
+}): CallbackActorLogic<TEvent, StandardSchemaV1.InferOutput<TInputSchema>, TEmitted>;
+declare function createCallbackLogic<TEvent extends EventObject, TInput = NonReducibleUnknown, TEmitted extends EventObject = EventObject>(config: CallbackLogicConfig<TEvent, AnyEventObject, TInput, TEmitted> & {
+  schemas?: undefined;
+}): CallbackActorLogic<TEvent, TInput, TEmitted>;
+declare function createCallbackLogic<TEvent extends EventObject, TInput = NonReducibleUnknown, TEmitted extends EventObject = EventObject>(callback: CallbackLogicFunction<TEvent, AnyEventObject, TInput, TEmitted>): CallbackActorLogic<TEvent, TInput, TEmitted>;
+/** @public */
+type ListenerSnapshot = Snapshot<undefined> & {
+  input: ListenerInput<any, any>;
+};
+/** @public */
+interface ListenerInput<TEmitted extends EventObject, TMappedEvent extends EventObject> {
+  actor: AnyActor;
+  eventType: string;
+  mapper: (event: TEmitted) => TMappedEvent;
+}
+/** @public */
+type ListenerActorLogic<TEmitted extends EventObject = EventObject, TMappedEvent extends EventObject = EventObject> = ActorLogic<ListenerSnapshot, EventObject, ListenerInput<TEmitted, TMappedEvent>, AnyActorSystem, EventObject>;
+/** @public */
+type ListenerActorRef<TEmitted extends EventObject = EventObject, TMappedEvent extends EventObject = EventObject> = ActorRefFromLogic<ListenerActorLogic<TEmitted, TMappedEvent>>;
+/**
+ * Creates actor logic for listening to emitted events from another actor. Used
+ * internally by `enq.listen()`.
+ *
+ * @public
+ */
+declare function createListenerLogic<TEmitted extends EventObject = EventObject, TMappedEvent extends EventObject = EventObject>(): ListenerActorLogic<TEmitted, TMappedEvent>;
+/** @public */
+declare const listenerLogic: ListenerActorLogic<EventObject, EventObject>;
+/** @public */
+type ObservableSnapshot<TContext, TInput extends NonReducibleUnknown> = Snapshot<undefined> & {
+  context: TContext | undefined;
+  input: TInput | undefined;
+  effects?: Record<string, {
+    status: 'active';
+  } | {
+    status: 'done';
+    output?: unknown;
+  } | {
+    status: 'error';
+    error: unknown;
+  }>;
+  _subscription: Subscription | undefined;
+};
+/** @public */
+type ObservableActorLogic<TContext, TInput extends NonReducibleUnknown, TEmitted extends EventObject = EventObject> = ActorLogic<ObservableSnapshot<TContext, TInput>, {
+  type: string;
+  [k: string]: unknown;
+}, TInput, AnyActorSystem, TEmitted>;
+/**
+ * Represents an actor created by `createObservableLogic` or
+ * `createEventObservableLogic`.
+ *
+ * The type of `self` within the actor's logic.
+ *
+ * @example
+ *
+ * ```ts
+ * import { createObservableLogic, createActor } from '@systemfsoftware/xstate';
+ * import { interval } from 'rxjs';
+ *
+ * // The type of the value observed by the actor's logic.
+ * type Context = number;
+ * // The actor's input.
+ * type Input = { period?: number };
+ *
+ * // Actor logic that observes a number incremented every `input.period`
+ * // milliseconds (default: 1_000).
+ * const logic = createObservableLogic<Context, Input>(
+ *   ({ input, self }) => {
+ *     self;
+ *     // ^? ObservableActor<Event, Input>
+ *
+ *     return interval(input.period ?? 1_000);
+ *   }
+ * );
+ *
+ * const actor = createActor(logic, { input: { period: 2_000 } });
+ * //    ^? ObservableActor<Event, Input>
+ * ```
+ *
+ * @see {@link (createObservableLogic:1)}
+ * @see {@link (createEventObservableLogic:1)}
+ * @public
+ */
+type ObservableActorRef<TContext> = ActorRefFromLogic<ObservableActorLogic<TContext, any>>;
+type ObservableActor<TContext, TInput extends NonReducibleUnknown = any, TEmitted extends EventObject = EventObject> = ActorFromLogic<ObservableActorLogic<TContext, TInput, TEmitted>>;
+/** @public */
+type ObservableLogicFunction<TContext, TInput extends NonReducibleUnknown, TEmitted extends EventObject = EventObject> = ({ input, system, self, emit }: {
+  input: TInput;
+  system: AnyActorSystem;
+  self: ObservableActor<TContext, TInput, TEmitted>;
+  emit: (emitted: TEmitted) => void;
+}) => Subscribable<TContext>;
+/** @public */
+interface ObservableLogicConfig<TContext, TInput extends NonReducibleUnknown, TEmitted extends EventObject = EventObject, TInputSchema extends StandardSchemaV1 = StandardSchemaV1> {
+  validator?: ActorLogicValidator;
+  schemas?: {
+    input?: TInputSchema;
+  };
+  run: ObservableLogicFunction<TContext, TInput, TEmitted>;
+}
+/** @public */
+type EventObservableLogicFunction<TEvent extends EventObject, TInput extends NonReducibleUnknown, TEmitted extends EventObject = EventObject> = ({ input, system, self, emit }: {
+  input: TInput;
+  system: AnyActorSystem;
+  self: ObservableActor<TEvent, TInput, TEmitted>;
+  emit: (emitted: TEmitted) => void;
+}) => Subscribable<TEvent>;
+/** @public */
+interface EventObservableLogicConfig<TEvent extends EventObject, TInput extends NonReducibleUnknown, TEmitted extends EventObject = EventObject, TInputSchema extends StandardSchemaV1 = StandardSchemaV1> {
+  validator?: ActorLogicValidator;
+  schemas?: {
+    input?: TInputSchema;
+  };
+  run: EventObservableLogicFunction<TEvent, TInput, TEmitted>;
+}
+/**
+ * Observable actor logic is described by an observable stream of values. Actors
+ * created from observable logic (“observable actors”) can:
+ *
+ * - Emit snapshots of the observable’s emitted value
+ *
+ * The observable’s emitted value is used as its observable actor’s `context`.
+ *
+ * Sending events to observable actors will have no effect.
+ *
+ * @example
+ *
+ * ```ts
+ * import { createObservableLogic, createActor } from '@systemfsoftware/xstate';
+ * import { interval } from 'rxjs';
+ *
+ * const logic = createObservableLogic((obj) => interval(1000));
+ *
+ * const actor = createActor(logic);
+ *
+ * actor.subscribe((snapshot) => {
+ *   console.log(snapshot.context);
+ * });
+ *
+ * actor.start();
+ * // At every second:
+ * // Logs 0
+ * // Logs 1
+ * // Logs 2
+ * // ...
+ * ```
+ *
+ * @param observableCreator A function that creates an observable. It receives
+ *   one argument, an object with the following properties:
+ *
+ *   - `input` - Data that was provided to the observable actor
+ *   - `self` - The parent actor
+ *   - `system` - The actor system to which the observable actor belongs
+ *
+ *   It should return a `Subscribable`, which is compatible with an RxJS
+ *   Observable, although RxJS is not required to create them.
+ * @see {@link https://rxjs.dev} for documentation on RxJS Observable and observable creators.
+ * @see `Subscribable` interface in XState, which is based on and compatible with RxJS Observable.
+ * @public
+ */
+declare function createObservableLogic<TContext, const TInputSchema extends StandardSchemaV1, TEmitted extends EventObject = EventObject>(config: ObservableLogicConfig<TContext, StandardSchemaV1.InferOutput<TInputSchema>, TEmitted, TInputSchema> & {
+  schemas: {
+    input: TInputSchema;
+  };
+}): ObservableActorLogic<TContext, StandardSchemaV1.InferOutput<TInputSchema>, TEmitted>;
+declare function createObservableLogic<TContext, TInput extends NonReducibleUnknown, TEmitted extends EventObject = EventObject>(config: ObservableLogicConfig<TContext, TInput, TEmitted> & {
+  schemas?: undefined;
+}): ObservableActorLogic<TContext, TInput, TEmitted>;
+declare function createObservableLogic<TContext, TInput extends NonReducibleUnknown, TEmitted extends EventObject = EventObject>(observableCreator: ObservableLogicFunction<TContext, TInput, TEmitted>): ObservableActorLogic<TContext, TInput, TEmitted>;
+/**
+ * Creates event observable logic that listens to an observable that delivers
+ * event objects.
+ *
+ * Event observable actor logic is described by an observable stream of
+ * {@link https://stately.ai/docs/transitions#event-objects | event objects}.
+ * Actors created from event observable logic (“event observable actors”) can:
+ *
+ * - Implicitly send events to its parent actor
+ * - Emit snapshots of its emitted event objects
+ *
+ * Sending events to event observable actors will have no effect.
+ *
+ * @example
+ *
+ * ```ts
+ * import {
+ *   createEventObservableLogic,
+ *   Subscribable,
+ *   EventObject,
+ *   createMachine,
+ *   createActor
+ * } from '@systemfsoftware/xstate';
+ * import { fromEvent } from 'rxjs';
+ *
+ * const mouseClickLogic = createEventObservableLogic(
+ *   () => fromEvent(document.body, 'click') as Subscribable<EventObject>
+ * );
+ *
+ * const canvasMachine = createMachine({
+ *   invoke: {
+ *     // Will send mouse `click` events to the canvas actor
+ *     src: mouseClickLogic
+ *   }
+ * });
+ *
+ * const canvasActor = createActor(canvasMachine);
+ * canvasActor.start();
+ * ```
+ *
+ * @param lazyObservable A function that creates an observable that delivers
+ *   event objects. It receives one argument, an object with the following
+ *   properties:
+ *
+ *   - `input` - Data that was provided to the event observable actor
+ *   - `self` - The parent actor
+ *   - `system` - The actor system to which the event observable actor belongs.
+ *
+ *   It should return a `Subscribable`, which is compatible with an RxJS
+ *   Observable, although RxJS is not required to create them.
+ * @public
+ */
+declare function createEventObservableLogic<TEvent extends EventObject, const TInputSchema extends StandardSchemaV1, TEmitted extends EventObject = EventObject>(config: EventObservableLogicConfig<TEvent, StandardSchemaV1.InferOutput<TInputSchema>, TEmitted, TInputSchema> & {
+  schemas: {
+    input: TInputSchema;
+  };
+}): ObservableActorLogic<TEvent, StandardSchemaV1.InferOutput<TInputSchema>, TEmitted>;
+declare function createEventObservableLogic<TEvent extends EventObject, TInput extends NonReducibleUnknown, TEmitted extends EventObject = EventObject>(config: EventObservableLogicConfig<TEvent, TInput, TEmitted> & {
+  schemas?: undefined;
+}): ObservableActorLogic<TEvent, TInput, TEmitted>;
+declare function createEventObservableLogic<TEvent extends EventObject, TInput extends NonReducibleUnknown, TEmitted extends EventObject = EventObject>(lazyObservable: EventObservableLogicFunction<TEvent, TInput, TEmitted>): ObservableActorLogic<TEvent, TInput, TEmitted>;
+/** @public */
+type SubscriptionSnapshot = Snapshot<undefined> & {
+  input: SubscriptionInput<any, any, any, any>;
+};
+/** @public */
+interface SubscriptionMappers<TSnapshot extends Snapshot<unknown>, TOutput, TMappedEvent extends EventObject> {
+  snapshot?: (snapshot: TSnapshot) => TMappedEvent;
+  done?: (output: TOutput) => TMappedEvent;
+  error?: (error: unknown) => TMappedEvent;
+}
+/** @public */
+interface SubscriptionInput<TSnapshot extends Snapshot<unknown>, TOutput, TMappedEvent extends EventObject, TMappers extends SubscriptionMappers<TSnapshot, TOutput, TMappedEvent>> {
+  actor: AnyActorRef;
+  mappers: TMappers;
+}
+/** @public */
+type SubscriptionActorLogic<TSnapshot extends Snapshot<unknown> = Snapshot<unknown>, TOutput = unknown, TMappedEvent extends EventObject = EventObject> = ActorLogic<SubscriptionSnapshot, EventObject, SubscriptionInput<TSnapshot, TOutput, TMappedEvent, SubscriptionMappers<TSnapshot, TOutput, TMappedEvent>>, AnyActorSystem, EventObject>;
+/** @public */
+type SubscriptionActorRef<TSnapshot extends Snapshot<unknown> = Snapshot<unknown>, TOutput = unknown, TMappedEvent extends EventObject = EventObject> = ActorRefFromLogic<SubscriptionActorLogic<TSnapshot, TOutput, TMappedEvent>>;
+/**
+ * Creates actor logic for subscribing to lifecycle events (done/error/snapshot)
+ * from another actor. Used internally by `enq.subscribeTo()`.
+ *
+ * @public
+ */
+declare function createSubscriptionLogic<TSnapshot extends Snapshot<unknown> = Snapshot<unknown>, TOutput = unknown, TMappedEvent extends EventObject = EventObject>(): SubscriptionActorLogic<TSnapshot, TOutput, TMappedEvent>;
+/** @public */
+declare const subscriptionLogic: SubscriptionActorLogic<Snapshot<unknown>, unknown, EventObject>;
+declare const emptyLogic: LogicActorLogic<undefined, undefined, EventObject, NonReducibleUnknown, EventObject>;
+/** @public */
+declare function createEmptyActor(): ActorFromLogic<typeof emptyLogic>;
+export { LogicActorLogic as A, createLogic as B, listenerLogic as C, CallbackLogicFunction as D, CallbackLogicConfig as E, LogicEffectState as F, LogicEnqueue as I, LogicFunction as L, LogicArgs as M, LogicConfig as N, CallbackSnapshot as O, LogicEffect as P, LogicPatch as R, createListenerLogic as S, CallbackActorRef as T, createObservableLogic as _, SubscriptionMappers as a, ListenerInput as b, subscriptionLogic as c, ObservableActorLogic as d, ObservableActorRef as f, createEventObservableLogic as g, ObservableSnapshot as h, SubscriptionInput as i, LogicActorRef as j, createCallbackLogic as k, EventObservableLogicConfig as l, ObservableLogicFunction as m, SubscriptionActorLogic as n, SubscriptionSnapshot as o, ObservableLogicConfig as p, SubscriptionActorRef as r, createSubscriptionLogic as s, createEmptyActor as t, EventObservableLogicFunction as u, ListenerActorLogic as v, CallbackActorLogic as w, ListenerSnapshot as x, ListenerActorRef as y, LogicSnapshot as z };

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+import { c as SetupStateSchema, d as SetupStateSchemas, f as StandardSchemaV1, h as types, i as InferEvents, l as SetupStateType, m as isTypeSchema, n as EventObject, o as MachineContext, p as TypeSchema, s as SetupSchemas, u as Values } from "./base.types-DF8ZPiXj.js";
+import { $ as DelayExpr, $n as TransitionConfigFunction, $t as PersistedSnapshotFor, A as AnyInvokeConfig, An as StateMachineTypes, Ar as ActorSystemRuntime, At as InteropSubscribable, B as BaseActorRef, Bn as Subscribable, Br as InspectionEvent, Bt as MachineTypes, C as AnyActor, Cn as StateConfig, Cr as LogicArgs, Ct as HomomorphicOmit, D as AnyEventObject, Dn as StateIdInputs, Dr as TimeoutError, Dt as InitialTransitionDefinition, E as AnyActorScope, En as StateId, Er as LogicFunction, Et as InitialTransitionConfig, F as AnyStateNode, Fn as StateValue, Fr as EventRejection, Ft as IsNotNever, G as Cast, Gn as TagsFrom, Gr as ActorValidationEventOrigin, Gt as NormalizeDescriptor, H as BuiltInExecutableActionObject, Hn as Subscription, Hr as TransitionInspectionEvent, Ht as MaybeLazy, I as AnyStateNodeConfig, In as StateValueFrom, Ir as EventRejectionReason, It as Lazy, J as ContextFactory, Jn as TimerEvent, Jr as MachineSnapshotSchema, Jt as OutputFrom, K as Compute, Kn as TerminateExecutableActionObject, Kr as ActorValidationRequest, Kt as Observer, L as AnyTransitionConfig, Ln as StateValueFromStateSchema, Lr as WallClock, Lt as LogicalTimer, M as AnyMachineSnapshot, Mn as StateSchema, Mt as IsAny, N as AnyStateConfig, Nn as StateSchemaFrom, Nr as CryptoSource, Nt as IsLiteralString, O as AnyFunction, Oi as MachineSnapshot, On as StateKey, Or as createAsyncLogic, Ot as InputFrom, P as AnyStateMachine, Pn as StateTypes, Pr as DeadLetterDetail, Pt as IsNever, Q as DelayConfig, Qn as TransitionConfig, Qt as PersistedMachineIdentity, R as AnyTransitionConfigFunction, Rn as StateValueMap, Rr as ActionRecord, Rt as LowInfer, S as AnyAction, Sn as StartExecutableActionObject, Sr as AsyncSnapshot, St as HistoryValue, T as AnyActorRef, Ti as WidenLiterals, Tn as StateFrom, Tr as LogicEnqueue, Tt as InitialContext, U as CallbackActors, Un as SystemRegistry, Ur as ActorLogicValidator, Ut as MetaObject, V as BaseExecutableActionObject, Vn as SubscribeToMappers, Vr as SentRecord, Vt as Mapper, W as CancelExecutableActionObject, Wn as TODO, Wr as ActorValidationBoundary, Wt as NonReducibleUnknown, X as CustomExecutableActionObject, Xn as ToExecutableAction, Xr as PersistedMachineSnapshot, Xt as PersistedActorRef, Y as ContextFrom, Yn as ToChildren, Yr as MachineVersionDescriptor, Yt as ParameterizedObject, Z as DeadLetterExecutableActionObject, Zn as ToStateValue, Zt as PersistedHistoryValue, _ as ActorSystemInfo, _n as SnapshotFrom, _r as RequiredActorOptionsFor, _t as EventPayloadPattern, a as ActorInstance, an as Readable, ar as TransitionTarget, at as DoneStateEvent, b as ActorTrigger, bn as SpecialExecutableAction, br as AsyncActorLogic, bt as ExtractEvent, c as ActorLogicTransitionResult, cn as RequiredLogicInput, cr as UnknownActorLogic, ct as EnqueueObject, d as ActorRefFrom, dn as SendToExecutableActionObject, dr as InfiniteTransitionError, dt as ErrorEvent, en as PersistedSnapshotFrom, er as TransitionConfigTarget, et as DelayedTransitionDefinition, f as ActorRefFromLogic, fi as Next_MachineConfig, fn as SendableEventFromLogic, fr as getStateNodes, ft as ErrorFrom, g as ActorSelf, gn as SnapshotEvent, gr as Actor, gt as EventFromLogic, h as ActorScope, hi as Next_TransitionConfigOrTarget, hn as Snapshot, hr as Spawner, ht as EventFrom, i as ActorFromLogic, in as RaiseExecutableActionObject, ir as TransitionDefinitionMap, it as DoneActorEvent, j as AnyInvokeDefinition, jn as StateNodesConfig, jr as AnyActorSystem, jt as InvokeDefinition, k as AnyHistoryValue, ki as isMachineSnapshot, kn as StateLike, kr as ActorSystem, kt as InteropObservable, l as ActorOptions, li as Next_ChoiceStateNodeConfig, ln as RestorablePersistedSnapshotFor, lr as UnknownActorRef, lt as Equals, m as ActorRuntime, mi as Next_StateNodeConfig, mn as SingleOrArray, mr as StateNode, mt as EventDescriptor, n as ActionArgs, nn as Prop, nr as TransitionContextPatch, nt as DevToolsAdapter, o as ActorLike, on as RegistryKeyForLogic, or as TransitionsConfig, ot as EmitExecutableActionObject, p as ActorRefLike, pi as Next_RegularStateNodeConfig, pn as SetupTypes, pr as checkStateIn, pt as ErrorPlatformEvent, q as ConditionalRequired, qn as TimeoutEvent, qr as MachineEventSchema, qt as OutputArg, r as ActionExecutor, rn as ProvidedActor, rr as TransitionDefinition, rt as DoNotInfer, s as ActorLogic, sn as RequiredActorOptions, sr as UnifiedArg, st as EmittedFrom, t as Action, tn as PersistedSnapshotOf, tr as TransitionContextMapper, tt as DelayedTransitions, u as ActorRef, ui as Next_InvokeConfig, un as RoutableStateId, ur as StateMachine, ut as ErrorActorEvent, v as ActorTermination, vi as Sources, vn as SnapshotStatus, vr as RequiredActorOptionsKeys, vt as ExecutableActionObject, w as AnyActorLogic, wn as StateContextFromStateValue, wr as LogicConfig, wt as InferEvent, x as AfterEvent, xn as SpecialTargets, xr as AsyncActorRef, xt as HistoryStateNode, y as ActorTimeoutEvent, yn as SpawnExecutableActionObject, yr as createActor, yt as ExecutableActionObjectFromLogic, z as AnyTransitionDefinition, zn as StopExecutableActionObject, zr as ActorInspectionEvent, zt as MachineSourcesFrom } from "./types-B2EAwOk-.js";
+import { A as LogicActorLogic, B as createLogic, C as listenerLogic, D as CallbackLogicFunction, E as CallbackLogicConfig, F as LogicEffectState, I as LogicEnqueue$1, L as LogicFunction$1, M as LogicArgs$1, N as LogicConfig$1, O as CallbackSnapshot, P as LogicEffect, R as LogicPatch, S as createListenerLogic, T as CallbackActorRef, _ as createObservableLogic, a as SubscriptionMappers, b as ListenerInput, c as subscriptionLogic, d as ObservableActorLogic, f as ObservableActorRef, g as createEventObservableLogic, h as ObservableSnapshot, i as SubscriptionInput, j as LogicActorRef, k as createCallbackLogic, l as EventObservableLogicConfig, m as ObservableLogicFunction, n as SubscriptionActorLogic, o as SubscriptionSnapshot, p as ObservableLogicConfig, r as SubscriptionActorRef, s as createSubscriptionLogic, t as createEmptyActor, u as EventObservableLogicFunction, v as ListenerActorLogic, w as CallbackActorLogic, x as ListenerSnapshot, y as ListenerActorRef, z as LogicSnapshot } from "./index-DDWoKIF5.js";
+import { n as getEffectDescriptor, t as EffectDescriptor } from "./effectDescriptor-EvNuy6U3.js";
+import { $ as WithRootSetupStateSchemas, A as initialSystemTransition, B as RootContextMarker, C as SystemEffectResult, Ct as createMachineFromConfig, D as SystemSnapshot, Dt as assertEvent, E as SystemMessage, Et as createStateConfig, F as CreateAsyncInvokeConfig, G as SetupStateParentTypeMarker, H as SetupConfig, I as CreateInvokeConfig, J as StrictSetupStateTargetsFlag, K as SetupStateSchemasWithParentType, L as CreatedInvoke, M as SimulatedClock, N as ActiveStateContext, O as SystemTimer, P as AnySetupConfig, Q as SystemRuntime, R as CurrentSetupStateSchemaMarker, S as SystemActorState, St as TransitionJSON, T as SystemLogic, Tt as createMachineFromCompiledConfig, U as SetupReturn, V as RootSetupStateSchemasMarker, W as SetupReturnFromConfig, X as SystemActorMap, Y as StrictSetupStateTargetsMarker, Z as SystemConfig, _ as stopActor, _t as ActionJSON, a as isBuiltInExecutableAction, at as serializeMachine, b as InitialSystemTransitionOptions, bt as MachineJSON, c as getNextTransitions, ct as EventAdapterHandlers, d as transition, dt as MigrateSnapshotOptions, et as createSystem, f as toPromise, ft as ParsedPersistedSnapshot, g as runStep, gt as machineVersions, h as deliverEvent, ht as SnapshotMigrationHandlers, i as executeEffects, it as machineConfigToJSON, j as systemTransition, k as advanceSystemTime, l as initialTransition, lt as EventHistorySource, m as pathToStateValue, mt as PersistedSnapshotSource, n as getAllOwnEventDescriptors, nt as hotSwapActorLogic, o as getInitialMicrosteps, ot as mapState, p as matchesState, pt as PersistedSnapshotDataFrom, q as StrictSetupStateSchemas, r as toObserver, rt as CodeExpression, s as getMicrosteps, st as AdaptEventsOptions, t as waitFor, tt as setup, u as isUnhandled, ut as MachineVersionsOptions, v as terminateActor, vt as GuardJSON, w as SystemExternalEffect, wt as createMachine, x as SystemActorReference, xt as StateNodeJSON, y as parseDelayToMilliseconds, yt as InvokeJSON, z as RelativeSetupStateSchemasMarker } from "./index-CKUyiMZC.js";
+export { type Action, type ActionArgs, type ActionExecutor, type ActionJSON, type ActionRecord, type ActiveStateContext, Actor, type ActorFromLogic, type ActorInspectionEvent, type ActorInstance, type ActorLike, type ActorLogic, type ActorLogicTransitionResult, type ActorLogicValidator, type ActorOptions, type ActorRef, type ActorRefFrom, type ActorRefFromLogic, type ActorRefLike, type ActorRuntime, type ActorScope, type ActorSelf, type ActorSystem, type ActorSystemInfo, type ActorSystemRuntime, type ActorTermination, type ActorTimeoutEvent, type ActorTrigger, type ActorValidationBoundary, type ActorValidationEventOrigin, type ActorValidationRequest, type AdaptEventsOptions, type AfterEvent, type AnyAction, type AnyActor, type AnyActorLogic, type AnyActorRef, type AnyActorScope, type AnyActorSystem, type AnyEventObject, type AnyFunction, type AnyHistoryValue, type AnyInvokeConfig, type AnyInvokeDefinition, type AnyMachineSnapshot, type AnySetupConfig, type AnyStateConfig, type AnyStateMachine, type AnyStateNode, type AnyStateNodeConfig, type AnyTransitionConfig, type AnyTransitionConfigFunction, type AnyTransitionDefinition, type AsyncActorLogic, type AsyncActorRef, type LogicArgs as AsyncLogicArgs, type LogicConfig as AsyncLogicConfig, type LogicEnqueue as AsyncLogicEnqueue, type LogicFunction as AsyncLogicFunction, type AsyncSnapshot, type BaseActorRef, type BaseExecutableActionObject, type BuiltInExecutableActionObject, type CallbackActorLogic, type CallbackActorRef, type CallbackActors, type CallbackLogicConfig, type CallbackLogicFunction, type CallbackSnapshot, type CancelExecutableActionObject, type Cast, type Next_ChoiceStateNodeConfig as ChoiceStateNodeConfig, type CodeExpression, type Compute, type ConditionalRequired, type ContextFactory, type ContextFrom, type CreateAsyncInvokeConfig, type CreateInvokeConfig, type CreatedInvoke, type CryptoSource, type CurrentSetupStateSchemaMarker, type CustomExecutableActionObject, type DeadLetterDetail, type DeadLetterExecutableActionObject, type DelayConfig, type DelayExpr, type DelayedTransitionDefinition, type DelayedTransitions, type DevToolsAdapter, type DoNotInfer, type DoneActorEvent, type DoneStateEvent, type EffectDescriptor, type EmitExecutableActionObject, type EmittedFrom, type EnqueueObject, type Equals, type ErrorActorEvent, type ErrorEvent, type ErrorFrom, type ErrorPlatformEvent, type EventAdapterHandlers, type EventDescriptor, type EventFrom, type EventFromLogic, type EventHistorySource, type EventObject, type EventObservableLogicConfig, type EventObservableLogicFunction, type EventPayloadPattern, type EventRejection, type EventRejectionReason, type ExecutableActionObject, type ExecutableActionObjectFromLogic, type ExtractEvent, type GuardJSON, type HistoryStateNode, type HistoryValue, type HomomorphicOmit, type InferEvent, type InferEvents, InfiniteTransitionError, type InitialContext, type InitialSystemTransitionOptions, type InitialTransitionConfig, type InitialTransitionDefinition, type InputFrom, type InspectionEvent, type InteropObservable, type InteropSubscribable, type Next_InvokeConfig as InvokeConfig, type InvokeDefinition, type InvokeJSON, type IsAny, type IsLiteralString, type IsNever, type IsNotNever, type Lazy, type ListenerActorLogic, type ListenerActorRef, type ListenerInput, type ListenerSnapshot, type LogicActorLogic, type LogicActorRef, type LogicArgs$1 as LogicArgs, type LogicConfig$1 as LogicConfig, type LogicEffect, type LogicEffectState, type LogicEnqueue$1 as LogicEnqueue, type LogicFunction$1 as LogicFunction, type LogicPatch, type LogicSnapshot, type LogicalTimer, type LowInfer, type Next_MachineConfig as MachineConfig, type MachineContext, type MachineEventSchema, type MachineJSON, type MachineSnapshot, type MachineSnapshotSchema, type MachineSourcesFrom, type MachineTypes, type MachineVersionDescriptor, type MachineVersionsOptions, type Mapper, type MaybeLazy, type MetaObject, type MigrateSnapshotOptions, type NonReducibleUnknown, type NormalizeDescriptor, type ObservableActorLogic, type ObservableActorRef, type ObservableLogicConfig, type ObservableLogicFunction, type ObservableSnapshot, type Observer, type OutputArg, type OutputFrom, type ParameterizedObject, type ParsedPersistedSnapshot, type PersistedActorRef, type PersistedHistoryValue, type PersistedMachineIdentity, type PersistedMachineSnapshot, type PersistedSnapshotDataFrom, type PersistedSnapshotFor, type PersistedSnapshotFrom, type PersistedSnapshotOf, type PersistedSnapshotSource, type Prop, type ProvidedActor, type RaiseExecutableActionObject, type Readable, type RegistryKeyForLogic, type Next_RegularStateNodeConfig as RegularStateNodeConfig, type RelativeSetupStateSchemasMarker, type RequiredActorOptions, type RequiredActorOptionsFor, type RequiredActorOptionsKeys, type RequiredLogicInput, type RestorablePersistedSnapshotFor, type RootContextMarker, type RootSetupStateSchemasMarker, type RoutableStateId, type SendToExecutableActionObject, type SendableEventFromLogic, type SentRecord, type SetupConfig, type SetupReturn, type SetupReturnFromConfig, type SetupSchemas, type SetupStateParentTypeMarker, type SetupStateSchema, type SetupStateSchemas, type SetupStateSchemasWithParentType, type SetupStateType, type SetupTypes, SimulatedClock, type SingleOrArray, type Snapshot, type SnapshotEvent, type SnapshotFrom, type SnapshotMigrationHandlers, type SnapshotStatus, type Sources, type SpawnExecutableActionObject, type Spawner, type SpecialExecutableAction, SpecialTargets, type StandardSchemaV1, type StartExecutableActionObject, type StateConfig, type StateContextFromStateValue, type StateFrom, type StateId, type StateIdInputs, type StateKey, type StateLike, StateMachine, type StateMachineTypes, StateNode, type Next_StateNodeConfig as StateNodeConfig, type StateNodeJSON, type StateNodesConfig, type StateSchema, type StateSchemaFrom, type StateTypes, type StateValue, type StateValueFrom, type StateValueFromStateSchema, type StateValueMap, type StopExecutableActionObject, type StrictSetupStateSchemas, type StrictSetupStateTargetsFlag, type StrictSetupStateTargetsMarker, type Subscribable, type SubscribeToMappers, type Subscription, type SubscriptionActorLogic, type SubscriptionActorRef, type SubscriptionInput, type SubscriptionMappers, type SubscriptionSnapshot, type SystemActorMap, type SystemActorReference, type SystemActorState, type SystemConfig, type SystemEffectResult, type SystemExternalEffect, type SystemLogic, type SystemMessage, type SystemRegistry, type SystemRuntime, type SystemSnapshot, type SystemTimer, type TODO, type TagsFrom, type TerminateExecutableActionObject, TimeoutError, type TimeoutEvent, type TimerEvent, type ToChildren, type ToExecutableAction, type ToStateValue, type TransitionConfig, type TransitionConfigFunction, type Next_TransitionConfigOrTarget as TransitionConfigOrTarget, type TransitionConfigTarget, type TransitionContextMapper, type TransitionContextPatch, type TransitionDefinition, type TransitionDefinitionMap, type TransitionInspectionEvent, type TransitionJSON, type TransitionTarget, type TransitionsConfig, type TypeSchema, type UnifiedArg, type UnknownActorLogic, type UnknownActorRef, type Values, type WallClock, type WidenLiterals, type WithRootSetupStateSchemas, getAllOwnEventDescriptors as __unsafe_getAllOwnEventDescriptors, createMachineFromCompiledConfig as _createMachineFromCompiledConfig, hotSwapActorLogic as _hotSwapActorLogic, parseDelayToMilliseconds as _parseDelayToMilliseconds, advanceSystemTime, assertEvent, checkStateIn, createActor, createAsyncLogic, createCallbackLogic, createEmptyActor, createEventObservableLogic, createListenerLogic, createLogic, createMachine, createMachineFromConfig, createObservableLogic, createStateConfig, createSubscriptionLogic, createSystem, deliverEvent, executeEffects, getEffectDescriptor, getInitialMicrosteps, getMicrosteps, getNextTransitions, getStateNodes, initialSystemTransition, initialTransition, isBuiltInExecutableAction, isMachineSnapshot, isTypeSchema, isUnhandled, listenerLogic, machineConfigToJSON, machineVersions, mapState, matchesState, pathToStateValue, runStep, serializeMachine, setup, stopActor, subscriptionLogic, systemTransition, terminateActor, toObserver, toPromise, transition, types, waitFor };

package/dist/index.mjs

@@ -0,0 +1,7 @@
+import { n as getAllOwnEventDescriptors, p as toObserver } from "./utils-CXBxxp3Z.mjs";
+import { $ as matchesState, A as executeEffects, B as createListenerLogic, M as isBuiltInExecutableAction, R as createSubscriptionLogic, V as listenerLogic, X as isMachineSnapshot, _t as stopActor, a as InfiniteTransitionError, at as parseDelayToMilliseconds, et as pathToStateValue, gt as runStep, ht as deliverEvent, i as StateNode, n as Actor, r as createActor, u as getStateNodes, v as checkStateIn, vt as terminateActor, z as subscriptionLogic } from "./createActor-BGHd7i8Q.mjs";
+import { _ as createStateConfig, a as systemTransition, b as SpecialTargets, c as setup, d as serializeMachine, f as mapState, g as createMachineFromCompiledConfig, h as createMachine, i as initialSystemTransition, l as hotSwapActorLogic, m as createMachineFromConfig, n as toPromise, o as SimulatedClock, p as machineVersions, r as advanceSystemTime, s as createSystem, t as waitFor, u as machineConfigToJSON, v as StateMachine, y as assertEvent } from "./src-zLWug7SF.mjs";
+import { a as createObservableLogic, i as createEventObservableLogic, n as TimeoutError, o as createCallbackLogic, r as createAsyncLogic, s as createLogic, t as createEmptyActor } from "./actors-LxMBvgxO.mjs";
+import { n as types, t as isTypeSchema } from "./schema.types-tsIbgQd-.mjs";
+import { a as isUnhandled, i as initialTransition, n as getMicrosteps, o as transition, r as getNextTransitions, s as getEffectDescriptor, t as getInitialMicrosteps } from "./transition-ZMXyPI-x.mjs";
+export { Actor, InfiniteTransitionError, SimulatedClock, SpecialTargets, StateMachine, StateNode, TimeoutError, getAllOwnEventDescriptors as __unsafe_getAllOwnEventDescriptors, createMachineFromCompiledConfig as _createMachineFromCompiledConfig, hotSwapActorLogic as _hotSwapActorLogic, parseDelayToMilliseconds as _parseDelayToMilliseconds, advanceSystemTime, assertEvent, checkStateIn, createActor, createAsyncLogic, createCallbackLogic, createEmptyActor, createEventObservableLogic, createListenerLogic, createLogic, createMachine, createMachineFromConfig, createObservableLogic, createStateConfig, createSubscriptionLogic, createSystem, deliverEvent, executeEffects, getEffectDescriptor, getInitialMicrosteps, getMicrosteps, getNextTransitions, getStateNodes, initialSystemTransition, initialTransition, isBuiltInExecutableAction, isMachineSnapshot, isTypeSchema, isUnhandled, listenerLogic, machineConfigToJSON, machineVersions, mapState, matchesState, pathToStateValue, runStep, serializeMachine, setup, stopActor, subscriptionLogic, systemTransition, terminateActor, toObserver, toPromise, transition, types, waitFor };

package/dist/schema.types-tsIbgQd-.mjs

@@ -0,0 +1,46 @@
+// src/schema.types.ts
+/**
+* Declares schema types for inference only — no runtime validation.
+*
+* Use in a machine's `schemas` when you want TypeScript types without pulling
+* in a schema library like Zod. The returned value is a valid Standard Schema
+* whose validation is the identity function, so it carries types but never
+* rejects input.
+*
+* @example
+*
+* ```ts
+* import { createMachine, types } from '@systemfsoftware/xstate';
+*
+* const machine = createMachine({
+*   schemas: {
+*     context: types<{ count: number }>(),
+*     events: {
+*       inc: types<{ by: number }>(),
+*       reset: types<void>()
+*     }
+*   },
+*   context: { count: 0 }
+*   // ...
+* });
+* ```
+*
+* Use `types<void>()` for events without a payload.
+* @public
+*/
+function types() {
+	return { "~standard": {
+		version: 1,
+		vendor: "xstate.types",
+		validate: (value) => ({ value })
+	} };
+}
+/**
+* Returns true if the value is a type-only schema created by {@link types}.
+*
+* @public
+*/
+function isTypeSchema(value) {
+	return !!value && typeof value === "object" && "~standard" in value && value["~standard"].vendor === "xstate.types";
+}
+export { types as n, isTypeSchema as t };