xstate 5.0.0-beta.8 → 5.0.0

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

@@ -1,30 +1,63 @@
-import type { StateNode } from './StateNode.ts';
-import type { State } from './State.ts';
-import type { ActorStatus, Clock, Interpreter } from './interpreter.ts';
-import type { StateMachine } from './StateMachine.ts';
-import type { LifecycleSignal } from './actors/index.ts';
-import { TypegenDisabled, ResolveTypegenMeta, TypegenConstraint, MarkAllImplementationsAsProvided, AreAllImplementationsAssumedToBeProvided } from './typegenTypes.ts';
+import type { StateNode } from "./StateNode.js";
+import type { MachineSnapshot } from "./State.js";
+import type { Clock, Actor } from "./interpreter.js";
+import type { StateMachine } from "./StateMachine.js";
+import { TypegenDisabled, ResolveTypegenMeta, TypegenConstraint, MarkAllImplementationsAsProvided, AreAllImplementationsAssumedToBeProvided } from "./typegenTypes.js";
+import { PromiseActorLogic } from "./actors/promise.js";
+import { Guard, GuardPredicate, UnknownGuard } from "./guards.js";
+import { Spawner } from "./spawn.js";
+import { AssignArgs } from "./actions/assign.js";
+import { InspectionEvent } from './system.js';
+export type Identity<T> = {
+    [K in keyof T]: T[K];
+};
+export type HomomorphicPick<T, K extends keyof any> = {
+    [P in keyof T as P & K]: T[P];
+};
+export type HomomorphicOmit<T, K extends keyof any> = {
+    [P in keyof T as Exclude<P, K>]: T[P];
+};
+export type Invert<T extends Record<PropertyKey, PropertyKey>> = {
+    [K in keyof T as T[K]]: K;
+};
+export type GetParameterizedParams<T extends ParameterizedObject | undefined> = T extends any ? ('params' extends keyof T ? T['params'] : undefined) : never;
+/**
+ *
+ * @remarks
+ *
+ * `T | unknown` reduces to `unknown` and that can be problematic when it comes to contextual typing.
+ * It especially is a problem when the union has a function member, like here:
+ *
+ * ```ts
+ * declare function test(cbOrVal: ((arg: number) => unknown) | unknown): void;
+ * test((arg) => {}) // oops, implicit any
+ * ```
+ *
+ * This type can be used to avoid this problem. This union represents the same value space as `unknown`.
+ */
+export type NonReducibleUnknown = {} | null | undefined;
 export type AnyFunction = (...args: any[]) => any;
 type ReturnTypeOrValue<T> = T extends AnyFunction ? ReturnType<T> : T;
 export type IsNever<T> = [T] extends [never] ? true : false;
+export type IsNotNever<T> = [T] extends [never] ? false : true;
 export type Compute<A extends any> = {
     [K in keyof A]: A[K];
 } & unknown;
 export type Prop<T, K> = K extends keyof T ? T[K] : never;
 export type Values<T> = T[keyof T];
+export type Elements<T> = T[keyof T & `${number}`];
 export type Merge<M, N> = Omit<M, keyof N> & N;
+export type IndexByProp<T extends Record<P, string>, P extends keyof T> = {
+    [E in T as E[P]]: E;
+};
 export type IndexByType<T extends {
     type: string;
-}> = {
-    [K in T['type']]: T extends any ? (K extends T['type'] ? T : never) : never;
-};
+}> = IndexByProp<T, 'type'>;
 export type Equals<A1 extends any, A2 extends any> = (<A>() => A extends A2 ? true : false) extends <A>() => A extends A1 ? true : false ? true : false;
 export type IsAny<T> = Equals<T, any>;
 export type Cast<A, B> = A extends B ? A : B;
 export type NoInfer<T> = [T][T extends any ? 0 : any];
 export type LowInfer<T> = T & {};
-export type EventType = string;
-export type ActionType = string;
 export type MetaObject = Record<string, any>;
 export type Lazy<T> = () => T;
 export type MaybeLazy<T> = T | Lazy<T>;
@@ -42,215 +75,143 @@ export interface AnyEventObject extends EventObject {
 }
 export interface ParameterizedObject {
     type: string;
-    params?: Record<string, any>;
-}
-export interface BaseActionObject extends ParameterizedObject {
-    execute?: (actorCtx: AnyActorContext) => void;
-}
-export interface BuiltInActionObject extends ParameterizedObject {
-    type: `xstate.${string}`;
-    params: Record<string, any>;
+    params?: NonReducibleUnknown;
 }
-export interface UnifiedArg<TContext extends MachineContext, TEvent extends EventObject> {
+export interface UnifiedArg<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject> {
     context: TContext;
-    event: TEvent;
-}
-export interface BaseDynamicActionObject<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject, TResolvedAction extends BaseActionObject, TDynamicParams extends Record<string, any>> {
-    type: `xstate.${string}`;
-    params: TDynamicParams;
-    resolve: (_event: SCXML.Event<TExpressionEvent>, extra: {
-        state: State<TContext, TEvent>;
-        /**
-         * The original action object
-         */
-        action: ParameterizedObject;
-        actorContext: AnyActorContext | undefined;
-    }) => [AnyState, TResolvedAction];
-    /** @deprecated an internal signature that doesn't exist at runtime. Its existence helps TS to choose a better code path in the inference algorithm  */
-    (args: {
-        context: TContext;
-        event: TExpressionEvent;
-    } & ActionMeta<TEvent, ParameterizedObject>): void;
+    event: TExpressionEvent;
+    self: ActorRef<MachineSnapshot<TContext, TEvent, Record<string, AnyActorRef | undefined>, // TODO: this should be replaced with `TChildren`
+    StateValue, string, unknown>, TEvent>;
+    system: ActorSystem<any>;
 }
 export type MachineContext = Record<string, any>;
-export interface ActionMeta<TEvent extends EventObject, TAction extends ParameterizedObject = ParameterizedObject> extends StateMeta<TEvent> {
-    action: TAction;
-    _event: SCXML.Event<TEvent>;
-}
-export type Spawner = <T extends ActorBehavior<any, any> | string>(// TODO: read string from machine behavior keys
-behavior: T, options?: Partial<{
-    id: string;
-    input: any;
-}>) => T extends ActorBehavior<infer TActorEvent, infer TActorEmitted> ? ActorRef<TActorEvent, TActorEmitted> : ActorRef<any, any>;
-export interface AssignMeta<TExpressionEvent extends EventObject, _TEvent extends EventObject> extends StateMeta<TExpressionEvent> {
-    action: BaseActionObject;
-    _event: SCXML.Event<TExpressionEvent>;
-    spawn: Spawner;
-}
-export type ActionFunction<TContext extends MachineContext, TExpressionEvent extends EventObject, TAction extends ParameterizedObject = ParameterizedObject, TEvent extends EventObject = TExpressionEvent> = (args: {
-    context: TContext;
-    event: TExpressionEvent;
-} & ActionMeta<TEvent, TAction>) => void;
-export interface ChooseCondition<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject = TExpressionEvent> {
-    guard?: GuardConfig<TContext, TEvent>;
-    actions: Actions<TContext, TExpressionEvent, TEvent>;
+export interface ActionArgs<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject> extends UnifiedArg<TContext, TExpressionEvent, TEvent> {
+}
+export type InputFrom<T extends AnyActorLogic> = T extends StateMachine<infer _TContext, infer _TEvent, infer _TChildren, infer _TActor, infer _TAction, infer _TGuard, infer _TDelay, infer _TStateValue, infer _TTag, infer TInput, infer _TOutput, infer _TResolvedTypesMeta> ? TInput : T extends ActorLogic<infer _TSnapshot, infer _TEvent, infer TInput, infer _TSystem> ? TInput : never;
+export type OutputFrom<T extends AnyActorLogic> = T extends ActorLogic<infer TSnapshot, infer _TEvent, infer _TInput, infer _TSystem> ? (TSnapshot & {
+    status: 'done';
+})['output'] : never;
+export type ActionFunction<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string> = {
+    (args: ActionArgs<TContext, TExpressionEvent, TEvent>, params: TParams): void;
+    _out_TEvent?: TEvent;
+    _out_TActor?: TActor;
+    _out_TAction?: TAction;
+    _out_TGuard?: TGuard;
+    _out_TDelay?: TDelay;
+};
+export interface ChooseBranch<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> {
+    guard?: Guard<TContext, TExpressionEvent, undefined, TGuard>;
+    actions: Actions<TContext, TExpressionEvent, TEvent, undefined, TActor, TAction, TGuard, TDelay>;
 }
-export type Action<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject = TExpressionEvent> = ActionType | ParameterizedObject | ActionFunction<TContext, TExpressionEvent, ParameterizedObject, TEvent> | BaseDynamicActionObject<TContext, TExpressionEvent, TEvent, any, any>;
-/**
- * Extracts action objects that have no extra properties.
- */
-type SimpleActionsFrom<T extends ParameterizedObject> = ParameterizedObject extends T ? T : ExtractWithSimpleSupport<T>;
-export type BaseAction<TContext extends MachineContext, TExpressionEvent extends EventObject, TAction extends ParameterizedObject, TEvent extends EventObject> = BaseDynamicActionObject<TContext, TExpressionEvent, TEvent, any, // TODO: at the very least this should include TAction, but probably at a covariant position or something, we really need to rethink how action objects are typed
-any> | TAction | SimpleActionsFrom<TAction>['type'] | ActionFunction<TContext, TExpressionEvent, TAction, TEvent>;
-export type BaseActions<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject, TAction extends ParameterizedObject> = SingleOrArray<BaseAction<TContext, TExpressionEvent, TAction, TEvent>>;
-export type Actions<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject = TExpressionEvent> = SingleOrArray<Action<TContext, TEvent>>;
-export type StateKey = string | AnyState;
+export type NoRequiredParams<T extends ParameterizedObject> = T extends any ? undefined extends T['params'] ? T['type'] : never : never;
+export type ConditionalRequired<T, Condition extends boolean> = Condition extends true ? Required<T> : T;
+export type WithDynamicParams<TContext extends MachineContext, TExpressionEvent extends EventObject, T extends ParameterizedObject> = T extends any ? ConditionalRequired<{
+    type: T['type'];
+    params?: T['params'] | (({ context, event }: {
+        context: TContext;
+        event: TExpressionEvent;
+    }) => T['params']);
+}, undefined extends T['params'] ? false : true> : never;
+export type Action<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string> = NoRequiredParams<TAction> | WithDynamicParams<TContext, TExpressionEvent, TAction> | ActionFunction<TContext, TExpressionEvent, TEvent, TParams, TActor, TAction, TGuard, TDelay>;
+export type UnknownAction = Action<MachineContext, EventObject, EventObject, ParameterizedObject['params'] | undefined, ProvidedActor, ParameterizedObject, ParameterizedObject, string>;
+export type Actions<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string> = SingleOrArray<Action<TContext, TExpressionEvent, TEvent, TParams, TActor, TAction, TGuard, TDelay>>;
+export type StateKey = string | AnyMachineSnapshot;
 export interface StateValueMap {
     [key: string]: StateValue;
 }
 /**
  * The string or object representing the state value relative to the parent state node.
  *
+ * @remarks
+ *
  * - For a child atomic state node, this is a string, e.g., `"pending"`.
+ *
  * - For complex state nodes, this is an object, e.g., `{ success: "someChildState" }`.
  */
 export type StateValue = string | StateValueMap;
-export type GuardPredicate<TContext extends MachineContext, TEvent extends EventObject> = (args: {
-    context: TContext;
-    event: TEvent;
-} & GuardMeta<TContext, TEvent>) => boolean;
-export interface DefaultGuardObject<TContext extends MachineContext, TEvent extends EventObject> extends ParameterizedObject {
-    /**
-     * Nested guards
-     */
-    children?: Array<GuardObject<TContext, TEvent>>;
-    predicate?: GuardPredicate<TContext, TEvent>;
-}
-export type GuardEvaluator<TContext extends MachineContext, TEvent extends EventObject> = (guard: GuardDefinition<TContext, TEvent>, context: TContext, _event: SCXML.Event<TEvent>, state: State<TContext, TEvent>) => boolean;
-export interface GuardMeta<TContext extends MachineContext, TEvent extends EventObject> {
-    state: State<TContext, TEvent, any>;
-    _event: SCXML.Event<TEvent>;
-    guard: GuardDefinition<TContext, TEvent>;
-    evaluate: GuardEvaluator<TContext, TEvent>;
-}
-export type GuardConfig<TContext extends MachineContext, TEvent extends EventObject> = string | GuardPredicate<TContext, TEvent> | GuardObject<TContext, TEvent>;
-export type GuardObject<TContext extends MachineContext, TEvent extends EventObject> = BooleanGuardObject<TContext, TEvent> | DefaultGuardObject<TContext, TEvent>;
-export interface GuardDefinition<TContext extends MachineContext, TEvent extends EventObject> {
-    type: string;
-    children?: Array<GuardDefinition<TContext, TEvent>>;
-    predicate?: GuardPredicate<TContext, TEvent>;
-    params: {
-        [key: string]: any;
-    };
-}
-export interface BooleanGuardObject<TContext extends MachineContext, TEvent extends EventObject> extends ParameterizedObject {
-    type: 'xstate.boolean';
-    children: Array<GuardConfig<TContext, TEvent>>;
-    params: {
-        op: 'and' | 'or' | 'not';
-    };
-    predicate: undefined;
-}
-export interface BooleanGuardDefinition<TContext extends MachineContext, TEvent extends EventObject> extends GuardDefinition<TContext, TEvent> {
-    type: 'xstate.boolean';
-    params: {
-        op: 'and' | 'or' | 'not';
-    };
-}
 export type TransitionTarget = SingleOrArray<string>;
-export interface TransitionConfig<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject = TExpressionEvent, TAction extends ParameterizedObject = ParameterizedObject> {
-    guard?: GuardConfig<TContext, TExpressionEvent>;
-    actions?: BaseActions<TContext, TExpressionEvent, TEvent, TAction>;
+export interface TransitionConfig<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string> {
+    guard?: Guard<TContext, TExpressionEvent, undefined, TGuard>;
+    actions?: Actions<TContext, TExpressionEvent, TEvent, undefined, TActor, TAction, TGuard, TDelay>;
     reenter?: boolean;
     target?: TransitionTarget | undefined;
     meta?: Record<string, any>;
     description?: string;
 }
-export interface TargetTransitionConfig<TContext extends MachineContext, TEvent extends EventObject> extends TransitionConfig<TContext, TEvent> {
-    target: TransitionTarget;
+export interface InitialTransitionConfig<TContext extends MachineContext, TEvent extends EventObject, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string> extends TransitionConfig<TContext, TEvent, TEvent, TActor, TAction, TGuard, TDelay> {
+    target: string;
 }
-export type ConditionalTransitionConfig<TContext extends MachineContext, TEvent extends EventObject = EventObject> = Array<TransitionConfig<TContext, TEvent>>;
-export interface InitialTransitionConfig<TContext extends MachineContext, TEvent extends EventObject> extends TransitionConfig<TContext, TEvent> {
-    guard?: never;
-    target: TransitionTarget;
-}
-export type Transition<TContext extends MachineContext, TEvent extends EventObject = EventObject> = string | TransitionConfig<TContext, TEvent> | ConditionalTransitionConfig<TContext, TEvent>;
-type ExtractWithSimpleSupport<T extends {
-    type: string;
-}> = T extends any ? {
-    type: T['type'];
-} extends T ? T : never : never;
-export type Receiver<TEvent extends EventObject> = (listener: {
-    bivarianceHack(event: TEvent): void;
-}['bivarianceHack']) => void;
-export type InvokeCallback<TEvent extends EventObject = AnyEventObject, TSentEvent extends EventObject = AnyEventObject> = (sendBack: (event: TSentEvent) => void, onReceive: Receiver<TEvent>, { input }: {
-    input: any;
-}) => (() => void) | Promise<any> | void;
-export type ActorBehaviorCreator<TContext extends MachineContext, TEvent extends EventObject, TActorBehavior extends AnyActorBehavior = AnyActorBehavior> = (context: TContext, event: TEvent, meta: {
-    id: string;
-    data?: any;
-    src: string;
-    _event: SCXML.Event<TEvent>;
-    meta: MetaObject | undefined;
-    input: any;
-}) => TActorBehavior;
-export interface InvokeMeta {
-    src: string;
-    meta: MetaObject | undefined;
-}
-export interface InvokeDefinition<TContext extends MachineContext, TEvent extends EventObject> {
+export type AnyTransitionConfig = TransitionConfig<any, any, any, any, any, any, any>;
+export interface InvokeDefinition<TContext extends MachineContext, TEvent extends EventObject, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string> {
     id: string;
     systemId: string | undefined;
     /**
-     * The source of the actor's behavior to be invoked
+     * The source of the actor logic to be invoked
      */
-    src: string;
-    input?: Mapper<TContext, TEvent, any> | any;
+    src: AnyActorLogic | string;
+    input?: Mapper<TContext, TEvent, NonReducibleUnknown, TEvent> | NonReducibleUnknown;
     /**
      * The transition to take upon the invoked child machine reaching its final top-level state.
      */
-    onDone?: string | SingleOrArray<TransitionConfig<TContext, DoneInvokeEvent<any>>>;
+    onDone?: string | SingleOrArray<TransitionConfig<TContext, DoneActorEvent<unknown>, TEvent, TActor, TAction, TGuard, TDelay>>;
     /**
      * The transition to take upon the invoked child machine sending an error event.
      */
-    onError?: string | SingleOrArray<TransitionConfig<TContext, ErrorEvent<any>>>;
-    onSnapshot?: string | SingleOrArray<TransitionConfig<TContext, SnapshotEvent<any>>>;
-    toJSON: () => Omit<InvokeDefinition<TContext, TEvent>, 'onDone' | 'onError' | 'toJSON'>;
-    meta: MetaObject | undefined;
+    onError?: string | SingleOrArray<TransitionConfig<TContext, ErrorActorEvent, TEvent, TActor, TAction, TGuard, TDelay>>;
+    onSnapshot?: string | SingleOrArray<TransitionConfig<TContext, SnapshotEvent, TEvent, TActor, TAction, TGuard, TDelay>>;
+    toJSON: () => Omit<InvokeDefinition<TContext, TEvent, TActor, TAction, TGuard, TDelay>, 'onDone' | 'onError' | 'toJSON'>;
 }
-export interface Delay {
-    id: string;
-    /**
-     * The time to delay the event, in milliseconds.
-     */
-    delay: number;
-}
-export type DelayedTransitions<TContext extends MachineContext, TEvent extends EventObject> = Record<string | number, string | SingleOrArray<TransitionConfig<TContext, TEvent>>> | Array<TransitionConfig<TContext, TEvent> & {
-    delay: number | string | Expr<TContext, TEvent, number>;
-}>;
+type Delay<TDelay extends string> = TDelay | number;
+export type DelayedTransitions<TContext extends MachineContext, TEvent extends EventObject, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string> = {
+    [K in Delay<TDelay>]?: string | SingleOrArray<TransitionConfig<TContext, TEvent, TEvent, TActor, TAction, TGuard, TDelay>>;
+};
 export type StateTypes = 'atomic' | 'compound' | 'parallel' | 'final' | 'history' | string;
-export type SingleOrArray<T> = T[] | T;
+export type SingleOrArray<T> = readonly T[] | T;
 export type StateNodesConfig<TContext extends MachineContext, TEvent extends EventObject> = {
     [K in string]: StateNode<TContext, TEvent>;
 };
-export type StatesConfig<TContext extends MachineContext, TEvent extends EventObject, TAction extends ParameterizedObject = ParameterizedObject> = {
-    [K in string]: StateNodeConfig<TContext, TEvent, TAction>;
+export type StatesConfig<TContext extends MachineContext, TEvent extends EventObject, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string, TTag extends string, TOutput> = {
+    [K in string]: StateNodeConfig<TContext, TEvent, TActor, TAction, TGuard, TDelay, TTag, TOutput>;
 };
 export type StatesDefinition<TContext extends MachineContext, TEvent extends EventObject> = {
     [K in string]: StateNodeDefinition<TContext, TEvent>;
 };
 export type TransitionConfigTarget = string | undefined;
-export type TransitionConfigOrTarget<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject = TExpressionEvent> = SingleOrArray<TransitionConfigTarget | TransitionConfig<TContext, TExpressionEvent, TEvent>>;
-export type TransitionsConfigMap<TContext extends MachineContext, TEvent extends EventObject> = {
-    [K in TEvent['type'] | '' | '*']?: K extends '' | '*' ? TransitionConfigOrTarget<TContext, TEvent> : TransitionConfigOrTarget<TContext, ExtractEvent<TEvent, K>, TEvent>;
+export type TransitionConfigOrTarget<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string> = SingleOrArray<TransitionConfigTarget | TransitionConfig<TContext, TExpressionEvent, TEvent, TActor, TAction, TGuard, TDelay>>;
+export type TransitionsConfig<TContext extends MachineContext, TEvent extends EventObject, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string> = {
+    [K in EventDescriptor<TEvent>]?: TransitionConfigOrTarget<TContext, ExtractEvent<TEvent, K>, TEvent, TActor, TAction, TGuard, TDelay>;
 };
-type TransitionsConfigArray<TContext extends MachineContext, TEvent extends EventObject> = Array<(TEvent extends EventObject ? TransitionConfig<TContext, TEvent> & {
-    event: TEvent['type'];
-} : never) | (TransitionConfig<TContext, TEvent> & {
-    event: '*';
-})>;
-export type TransitionsConfig<TContext extends MachineContext, TEvent extends EventObject> = TransitionsConfigMap<TContext, TEvent> | TransitionsConfigArray<TContext, TEvent>;
-export interface InvokeConfig<TContext extends MachineContext, TEvent extends EventObject> {
+type PartialEventDescriptor<TEventType extends string> = TEventType extends `${infer TLeading}.${infer TTail}` ? `${TLeading}.*` | `${TLeading}.${PartialEventDescriptor<TTail>}` : never;
+export type EventDescriptor<TEvent extends EventObject> = TEvent['type'] | PartialEventDescriptor<TEvent['type']> | '*';
+type NormalizeDescriptor<TDescriptor extends string> = TDescriptor extends '*' ? string : TDescriptor extends `${infer TLeading}.*` ? `${TLeading}.${string}` : TDescriptor;
+export type IsLiteralString<T extends string> = string extends T ? false : true;
+type DistributeActors<TContext extends MachineContext, TEvent extends EventObject, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string, TSpecificActor extends ProvidedActor> = TSpecificActor extends {
+    src: infer TSrc;
+} ? Compute<{
+    systemId?: string;
+    /**
+     * The source of the machine to be invoked, or the machine itself.
+     */
+    src: TSrc;
+    /**
+     * The unique identifier for the invoked machine. If not specified, this
+     * will be the machine's own `id`, or the URL (from `src`).
+     */
+    id?: TSpecificActor['id'];
+    input?: Mapper<TContext, TEvent, InputFrom<TSpecificActor['logic']>, TEvent> | InputFrom<TSpecificActor['logic']>;
+    /**
+     * The transition to take upon the invoked child machine reaching its final top-level state.
+     */
+    onDone?: string | SingleOrArray<TransitionConfigOrTarget<TContext, DoneActorEvent<OutputFrom<TSpecificActor['logic']>>, TEvent, TActor, TAction, TGuard, TDelay>>;
+    /**
+     * The transition to take upon the invoked child machine sending an error event.
+     */
+    onError?: string | SingleOrArray<TransitionConfigOrTarget<TContext, ErrorActorEvent, TEvent, TActor, TAction, TGuard, TDelay>>;
+    onSnapshot?: string | SingleOrArray<TransitionConfigOrTarget<TContext, SnapshotEvent<SnapshotFrom<TSpecificActor['logic']>>, TEvent, TActor, TAction, TGuard, TDelay>>;
+} & {
+    [K in RequiredActorOptions<TSpecificActor>]: unknown;
+}> : never;
+export type InvokeConfig<TContext extends MachineContext, TEvent extends EventObject, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string> = IsLiteralString<TActor['src']> extends true ? DistributeActors<TContext, TEvent, TActor, TAction, TGuard, TDelay, TActor> : {
     /**
      * The unique identifier for the invoked machine. If not specified, this
      * will be the machine's own `id`, or the URL (from `src`).
@@ -260,27 +221,25 @@ export interface InvokeConfig<TContext extends MachineContext, TEvent extends Ev
     /**
      * The source of the machine to be invoked, or the machine itself.
      */
-    src: string | ActorBehavior<any, any>;
-    input?: Mapper<TContext, TEvent, any> | any;
+    src: AnyActorLogic | string;
+    input?: Mapper<TContext, TEvent, NonReducibleUnknown, TEvent> | NonReducibleUnknown;
     /**
      * The transition to take upon the invoked child machine reaching its final top-level state.
      */
-    onDone?: string | SingleOrArray<TransitionConfigOrTarget<TContext, DoneInvokeEvent<any>, TEvent>>;
+    onDone?: string | SingleOrArray<TransitionConfigOrTarget<TContext, DoneActorEvent<any>, // TODO: consider replacing with `unknown`
+    TEvent, TActor, TAction, TGuard, TDelay>>;
     /**
      * The transition to take upon the invoked child machine sending an error event.
      */
-    onError?: string | SingleOrArray<TransitionConfigOrTarget<TContext, ErrorEvent<any>, TEvent>>;
-    onSnapshot?: string | SingleOrArray<TransitionConfigOrTarget<TContext, SnapshotEvent<any>, TEvent>>;
-    /**
-     * Meta data related to this invocation
-     */
-    meta?: MetaObject;
-}
-export interface StateNodeConfig<TContext extends MachineContext, TEvent extends EventObject, TAction extends ParameterizedObject = ParameterizedObject> {
+    onError?: string | SingleOrArray<TransitionConfigOrTarget<TContext, ErrorActorEvent, TEvent, TActor, TAction, TGuard, TDelay>>;
+    onSnapshot?: string | SingleOrArray<TransitionConfigOrTarget<TContext, SnapshotEvent, TEvent, TActor, TAction, TGuard, TDelay>>;
+};
+export type AnyInvokeConfig = InvokeConfig<any, any, any, any, any, any>;
+export interface StateNodeConfig<TContext extends MachineContext, TEvent extends EventObject, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string, TTag extends string, TOutput> {
     /**
      * The initial state transition.
      */
-    initial?: InitialTransitionConfig<TContext, TEvent> | SingleOrArray<string> | undefined;
+    initial?: InitialTransitionConfig<TContext, TEvent, TActor, TAction, TGuard, TDelay> | string | undefined;
     /**
      * The type of this state node:
      *
@@ -300,70 +259,63 @@ export interface StateNodeConfig<TContext extends MachineContext, TEvent extends
     /**
      * The mapping of state node keys to their state node configurations (recursive).
      */
-    states?: StatesConfig<TContext, TEvent, TAction> | undefined;
+    states?: StatesConfig<TContext, TEvent, TActor, TAction, TGuard, TDelay, TTag, NonReducibleUnknown> | undefined;
     /**
      * The services to invoke upon entering this state node. These services will be stopped upon exiting this state node.
      */
-    invoke?: SingleOrArray<string | InvokeConfig<TContext, TEvent>>;
+    invoke?: SingleOrArray<InvokeConfig<TContext, TEvent, TActor, TAction, TGuard, TDelay>>;
     /**
      * The mapping of event types to their potential transition(s).
      */
-    on?: TransitionsConfig<TContext, TEvent>;
+    on?: TransitionsConfig<TContext, TEvent, TActor, TAction, TGuard, TDelay>;
     /**
      * The action(s) to be executed upon entering the state node.
      */
-    entry?: BaseActions<TContext, TEvent, TEvent, TAction>;
+    entry?: Actions<TContext, TEvent, TEvent, undefined, TActor, TAction, TGuard, TDelay>;
     /**
      * The action(s) to be executed upon exiting the state node.
      */
-    exit?: BaseActions<TContext, TEvent, TEvent, TAction>;
+    exit?: Actions<TContext, TEvent, TEvent, undefined, TActor, TAction, TGuard, TDelay>;
     /**
      * 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 | SingleOrArray<TransitionConfig<TContext, DoneEventObject>> | undefined;
+    onDone?: string | SingleOrArray<TransitionConfig<TContext, DoneStateEvent, TEvent, TActor, TAction, TGuard, TDelay>> | 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?: DelayedTransitions<TContext, TEvent>;
+    after?: DelayedTransitions<TContext, TEvent, TActor, TAction, TGuard, TDelay>;
     /**
      * An eventless transition that is always taken when this state node is active.
      */
-    always?: TransitionConfigOrTarget<TContext, TEvent>;
-    /**
-     * @private
-     */
+    always?: TransitionConfigOrTarget<TContext, TEvent, TEvent, TActor, TAction, TGuard, TDelay>;
     parent?: StateNode<TContext, TEvent>;
     /**
      * The meta data associated with this state node, which will be returned in State instances.
      */
     meta?: any;
     /**
-     * The output data sent with the "done.state._id_" event if this is a final state node.
+     * 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, any> | PropertyMapper<TContext, TEvent, any>;
+    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 string delimiter for serializing the path to a string. The default is "."
-     */
-    delimiter?: string;
-    /**
-     * The order this state node appears. Corresponds to the implicit SCXML document order.
+     * 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?: SingleOrArray<string>;
+    tags?: SingleOrArray<TTag>;
     /**
      * A text description of the state node
      */
@@ -373,6 +325,7 @@ export interface StateNodeConfig<TContext extends MachineContext, TEvent extends
      */
     target?: string;
 }
+export type AnyStateNodeConfig = StateNodeConfig<any, any, any, any, any, any, any, any>;
 export interface StateNodeDefinition<TContext extends MachineContext, TEvent extends EventObject> {
     id: string;
     version?: string | undefined;
@@ -383,24 +336,36 @@ export interface StateNodeDefinition<TContext extends MachineContext, TEvent ext
     states: StatesDefinition<TContext, TEvent>;
     on: TransitionDefinitionMap<TContext, TEvent>;
     transitions: Array<TransitionDefinition<TContext, TEvent>>;
-    entry: BaseActionObject[];
-    exit: BaseActionObject[];
+    entry: UnknownAction[];
+    exit: UnknownAction[];
     meta: any;
     order: number;
-    output?: FinalStateNodeConfig<TContext, TEvent>['output'];
-    invoke: Array<InvokeDefinition<TContext, TEvent>>;
+    output?: StateNodeConfig<TContext, TEvent, ProvidedActor, ParameterizedObject, ParameterizedObject, string, string, unknown>['output'];
+    invoke: Array<InvokeDefinition<TContext, TEvent, TODO, TODO, TODO, TODO>>;
     description?: string;
     tags: string[];
 }
 export interface StateMachineDefinition<TContext extends MachineContext, TEvent extends EventObject> extends StateNodeDefinition<TContext, TEvent> {
-    context: TContext;
 }
 export type AnyStateNode = StateNode<any, any>;
 export type AnyStateNodeDefinition = StateNodeDefinition<any, any>;
-export type AnyState = State<any, any, any>;
-export type AnyStateMachine = StateMachine<any, any, any, any, any>;
+export type AnyMachineSnapshot = MachineSnapshot<any, any, any, any, any, any, any>;
+/** @deprecated use `AnyMachineSnapshot` instead */
+export type AnyState = AnyMachineSnapshot;
+export type AnyStateMachine = StateMachine<any, // context
+any, // event
+any, // children
+any, // actor
+any, // action
+any, // guard
+any, // delay
+any, // state value
+any, // tag
+any, // input
+any, // output
+any>;
 export type AnyStateConfig = StateConfig<any, AnyEventObject>;
-export interface AtomicStateNodeConfig<TContext extends MachineContext, TEvent extends EventObject> extends StateNodeConfig<TContext, TEvent> {
+export interface AtomicStateNodeConfig<TContext extends MachineContext, TEvent extends EventObject> extends StateNodeConfig<TContext, TEvent, TODO, TODO, TODO, TODO, TODO, TODO> {
     initial?: undefined;
     parallel?: false | undefined;
     states?: undefined;
@@ -410,47 +375,40 @@ export interface HistoryStateNodeConfig<TContext extends MachineContext, TEvent
     history: 'shallow' | 'deep' | true;
     target: string | undefined;
 }
-export interface FinalStateNodeConfig<TContext extends MachineContext, TEvent extends EventObject> extends AtomicStateNodeConfig<TContext, TEvent> {
-    type: 'final';
-    /**
-     * The data to be sent with the "done.state.<id>" event. The data can be
-     * static or dynamic (based on assigners).
-     */
-    output?: Mapper<TContext, TEvent, any> | PropertyMapper<TContext, TEvent, any>;
-}
-export type SimpleOrStateNodeConfig<TContext extends MachineContext, TEvent extends EventObject> = AtomicStateNodeConfig<TContext, TEvent> | StateNodeConfig<TContext, TEvent>;
-export type ActionFunctionMap<TContext extends MachineContext, TEvent extends EventObject, TAction extends ParameterizedObject = ParameterizedObject> = {
-    [K in TAction['type']]?: BaseDynamicActionObject<TContext, TEvent, TEvent, TAction, any> | ActionFunction<TContext, TEvent, TAction extends {
+export type SimpleOrStateNodeConfig<TContext extends MachineContext, TEvent extends EventObject> = AtomicStateNodeConfig<TContext, TEvent> | StateNodeConfig<TContext, TEvent, TODO, TODO, TODO, TODO, TODO, TODO>;
+export type ActionFunctionMap<TContext extends MachineContext, TEvent extends EventObject, TActor extends ProvidedActor, TAction extends ParameterizedObject = ParameterizedObject, TGuard extends ParameterizedObject = ParameterizedObject, TDelay extends string = string> = {
+    [K in TAction['type']]?: ActionFunction<TContext, TEvent, TEvent, GetParameterizedParams<TAction extends {
         type: K;
-    } ? TAction : never>;
+    } ? TAction : never>, TActor, TAction, TGuard, TDelay>;
 };
-export type DelayFunctionMap<TContext extends MachineContext, TEvent extends EventObject> = Record<string, DelayConfig<TContext, TEvent>>;
-export type DelayConfig<TContext extends MachineContext, TEvent extends EventObject> = number | DelayExpr<TContext, TEvent>;
-export interface MachineImplementationsSimplified<TContext extends MachineContext, TEvent extends EventObject, TAction extends ParameterizedObject = ParameterizedObject> {
-    guards: Record<string, GuardPredicate<TContext, TEvent>>;
-    actions: ActionFunctionMap<TContext, TEvent, TAction>;
-    actors: Record<string, AnyActorBehavior | {
-        src: AnyActorBehavior;
-        input: Mapper<TContext, TEvent, any> | any;
+type GuardMap<TContext extends MachineContext, TEvent extends EventObject, TGuard extends ParameterizedObject> = {
+    [K in TGuard['type']]?: GuardPredicate<TContext, TEvent, GetParameterizedParams<TGuard extends {
+        type: K;
+    } ? TGuard : never>, TGuard>;
+};
+export type DelayFunctionMap<TContext extends MachineContext, TEvent extends EventObject, TAction extends ParameterizedObject> = Record<string, DelayConfig<TContext, TEvent, TAction['params'], TEvent>>;
+export type DelayConfig<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject> = number | DelayExpr<TContext, TExpressionEvent, TParams, TEvent>;
+export interface MachineImplementationsSimplified<TContext extends MachineContext, TEvent extends EventObject, TActor extends ProvidedActor = ProvidedActor, TAction extends ParameterizedObject = ParameterizedObject, TGuard extends ParameterizedObject = ParameterizedObject> {
+    guards: GuardMap<TContext, TEvent, TGuard>;
+    actions: ActionFunctionMap<TContext, TEvent, TActor, TAction>;
+    actors: Record<string, AnyActorLogic | {
+        src: AnyActorLogic;
+        input: Mapper<TContext, TEvent, unknown, TEvent> | NonReducibleUnknown;
     }>;
-    delays: DelayFunctionMap<TContext, TEvent>;
+    delays: DelayFunctionMap<TContext, TEvent, TAction>;
 }
-type MachineImplementationsActions<TContext extends MachineContext, TResolvedTypesMeta, TEventsCausingActions = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'eventsCausingActions'>, TIndexedEvents = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'indexedEvents'>> = {
-    [K in keyof TEventsCausingActions]?: BaseDynamicActionObject<TContext, Cast<Prop<TIndexedEvents, TEventsCausingActions[K]>, EventObject>, Cast<Prop<TIndexedEvents, keyof TIndexedEvents>, EventObject>, any, // TODO: this should receive something like `Cast<Prop<TIndexedActions, K>, ParameterizedObject>`, but at the moment builtin actions expect Resolved*Action here and this should be simplified somehow
-    any> | ActionFunction<TContext, Cast<Prop<TIndexedEvents, TEventsCausingActions[K]>, EventObject>, ParameterizedObject, // TODO: when bringing back parametrized actions this should accept something like `Cast<Prop<TIndexedActions, K>, ParameterizedObject>`. At the moment we need to keep this type argument consistent with what is provided to the fake callable signature within `BaseDynamicActionObject`
-    Cast<Prop<TIndexedEvents, keyof TIndexedEvents>, EventObject>>;
+type MaybeNarrowedEvent<TIndexedEvents, TCausingLookup, K> = Cast<Prop<TIndexedEvents, K extends keyof TCausingLookup ? TCausingLookup[K] : TIndexedEvents[keyof TIndexedEvents]>, EventObject>;
+type MachineImplementationsActions<TContext extends MachineContext, TResolvedTypesMeta, TEventsCausingActions = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'eventsCausingActions'>, TIndexedEvents = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'indexedEvents'>, TIndexedActors = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'indexedActors'>, TIndexedActions = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'indexedActions'>, TIndexedGuards = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'indexedGuards'>, TIndexedDelays = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'indexedDelays'>> = {
+    [K in keyof TIndexedActions]?: ActionFunction<TContext, MaybeNarrowedEvent<TIndexedEvents, TEventsCausingActions, K>, Cast<Prop<TIndexedEvents, keyof TIndexedEvents>, EventObject>, GetParameterizedParams<Cast<TIndexedActions[K], ParameterizedObject>>, Cast<Prop<TIndexedActors, keyof TIndexedActors>, ProvidedActor>, Cast<Prop<TIndexedActions, keyof TIndexedActions>, ParameterizedObject>, Cast<Prop<TIndexedGuards, keyof TIndexedGuards>, ParameterizedObject>, Cast<Prop<TIndexedDelays, keyof TIndexedDelays>, ParameterizedObject>['type']>;
 };
-type MachineImplementationsDelays<TContext extends MachineContext, TResolvedTypesMeta, TEventsCausingDelays = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'eventsCausingDelays'>, TIndexedEvents = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'indexedEvents'>> = {
-    [K in keyof TEventsCausingDelays]?: DelayConfig<TContext, Cast<Prop<TIndexedEvents, TEventsCausingDelays[K]>, EventObject>>;
+type MachineImplementationsActors<_TContext extends MachineContext, TResolvedTypesMeta, TIndexedActors = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'indexedActors'>, _TInvokeSrcNameMap = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'invokeSrcNameMap'>> = {
+    [K in keyof TIndexedActors]?: Cast<Prop<TIndexedActors[K], 'logic'>, AnyActorLogic>;
 };
-type MachineImplementationsGuards<TContext extends MachineContext, TResolvedTypesMeta, TEventsCausingGuards = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'eventsCausingGuards'>, TIndexedEvents = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'indexedEvents'>> = {
-    [K in keyof TEventsCausingGuards]?: GuardPredicate<TContext, Cast<Prop<TIndexedEvents, TEventsCausingGuards[K]>, EventObject>>;
+type MachineImplementationsDelays<TContext extends MachineContext, TResolvedTypesMeta, TEventsCausingDelays = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'eventsCausingDelays'>, TIndexedEvents = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'indexedEvents'>, TIndexedActions = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'indexedActions'>, TIndexedDelays = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'indexedDelays'>> = {
+    [K in keyof TIndexedDelays]?: DelayConfig<TContext, MaybeNarrowedEvent<TIndexedEvents, TEventsCausingDelays, K>, Cast<Prop<Prop<TIndexedActions, keyof TIndexedActions>, 'params'>, ParameterizedObject['params'] | undefined> | undefined, Cast<Prop<TIndexedEvents, keyof TIndexedEvents>, EventObject>>;
 };
-type MachineImplementationsActors<TContext extends MachineContext, TResolvedTypesMeta, TEventsCausingActors = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'eventsCausingActors'>, TIndexedEvents = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'indexedEvents'>, _TInvokeSrcNameMap = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'invokeSrcNameMap'>> = {
-    [K in keyof TEventsCausingActors]?: AnyActorBehavior | {
-        src: AnyActorBehavior;
-        input: Mapper<TContext, Cast<Prop<TIndexedEvents, TEventsCausingActors[K]>, EventObject>, any> | any;
-    };
+type MachineImplementationsGuards<TContext extends MachineContext, TResolvedTypesMeta, TEventsCausingGuards = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'eventsCausingGuards'>, TIndexedEvents = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'indexedEvents'>, TIndexedGuards = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'indexedGuards'>> = {
+    [K in keyof TIndexedGuards]?: Guard<TContext, MaybeNarrowedEvent<TIndexedEvents, TEventsCausingGuards, K>, GetParameterizedParams<Cast<TIndexedGuards[K], ParameterizedObject | undefined>>, Cast<Prop<TIndexedGuards, keyof TIndexedGuards>, ParameterizedObject>>;
 };
 type MakeKeysRequired<T extends string> = {
     [K in T]: unknown;
@@ -458,55 +416,58 @@ type MakeKeysRequired<T extends string> = {
 type MaybeMakeMissingImplementationsRequired<TImplementationType, TMissingImplementationsForType, TRequireMissingImplementations> = TRequireMissingImplementations extends true ? IsNever<TMissingImplementationsForType> extends true ? {} : {
     [K in Cast<TImplementationType, string>]: MakeKeysRequired<Cast<TMissingImplementationsForType, string>>;
 } : {};
-type GenerateActionsImplementationsPart<TContext extends MachineContext, TResolvedTypesMeta, TRequireMissingImplementations, TMissingImplementations> = MaybeMakeMissingImplementationsRequired<'actions', Prop<TMissingImplementations, 'actions'>, TRequireMissingImplementations> & {
+type GenerateActionsImplementationsPart<TContext extends MachineContext, TResolvedTypesMeta, TRequireMissingImplementations, TMissingImplementations> = Compute<MaybeMakeMissingImplementationsRequired<'actions', Prop<TMissingImplementations, 'actions'>, TRequireMissingImplementations> & {
     actions?: MachineImplementationsActions<TContext, TResolvedTypesMeta>;
-};
-type GenerateDelaysImplementationsPart<TContext extends MachineContext, TResolvedTypesMeta, TRequireMissingImplementations, TMissingImplementations> = MaybeMakeMissingImplementationsRequired<'delays', Prop<TMissingImplementations, 'delays'>, TRequireMissingImplementations> & {
+}>;
+type GenerateActorsImplementationsPart<TContext extends MachineContext, TResolvedTypesMeta, TRequireMissingImplementations, TMissingImplementations> = Compute<MaybeMakeMissingImplementationsRequired<'actors', Prop<TMissingImplementations, 'actors'>, TRequireMissingImplementations> & {
+    actors?: MachineImplementationsActors<TContext, TResolvedTypesMeta>;
+}>;
+type GenerateDelaysImplementationsPart<TContext extends MachineContext, TResolvedTypesMeta, TRequireMissingImplementations, TMissingImplementations> = Compute<MaybeMakeMissingImplementationsRequired<'delays', Prop<TMissingImplementations, 'delays'>, TRequireMissingImplementations> & {
     delays?: MachineImplementationsDelays<TContext, TResolvedTypesMeta>;
-};
-type GenerateGuardsImplementationsPart<TContext extends MachineContext, TResolvedTypesMeta, TRequireMissingImplementations, TMissingImplementations> = MaybeMakeMissingImplementationsRequired<'guards', Prop<TMissingImplementations, 'guards'>, TRequireMissingImplementations> & {
+}>;
+type GenerateGuardsImplementationsPart<TContext extends MachineContext, TResolvedTypesMeta, TRequireMissingImplementations, TMissingImplementations> = Compute<MaybeMakeMissingImplementationsRequired<'guards', Prop<TMissingImplementations, 'guards'>, TRequireMissingImplementations> & {
     guards?: MachineImplementationsGuards<TContext, TResolvedTypesMeta>;
-};
-type GenerateActorsImplementationsPart<TContext extends MachineContext, TResolvedTypesMeta, TRequireMissingImplementations, TMissingImplementations> = MaybeMakeMissingImplementationsRequired<'actors', Prop<TMissingImplementations, 'actors'>, TRequireMissingImplementations> & {
-    actors?: MachineImplementationsActors<TContext, TResolvedTypesMeta>;
-};
-export type InternalMachineImplementations<TContext extends MachineContext, _TEvent extends EventObject, TResolvedTypesMeta, TRequireMissingImplementations extends boolean = false, TMissingImplementations = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'missingImplementations'>> = GenerateActionsImplementationsPart<TContext, TResolvedTypesMeta, TRequireMissingImplementations, TMissingImplementations> & GenerateDelaysImplementationsPart<TContext, TResolvedTypesMeta, TRequireMissingImplementations, TMissingImplementations> & GenerateGuardsImplementationsPart<TContext, TResolvedTypesMeta, TRequireMissingImplementations, TMissingImplementations> & GenerateActorsImplementationsPart<TContext, TResolvedTypesMeta, TRequireMissingImplementations, TMissingImplementations>;
-export type MachineImplementations<TContext extends MachineContext, TEvent extends EventObject, TAction extends ParameterizedObject = ParameterizedObject, TActorMap extends ActorMap = ActorMap, TTypesMeta extends TypegenConstraint = TypegenDisabled> = InternalMachineImplementations<TContext, TEvent, ResolveTypegenMeta<TTypesMeta, TEvent, TAction, TActorMap>>;
-type InitialContext<TContext extends MachineContext> = TContext | ContextFactory<TContext>;
-export type ContextFactory<TContext extends MachineContext> = ({ spawn, input }: {
-    spawn: Spawner;
-    input: any;
+}>;
+export type InternalMachineImplementations<TContext extends MachineContext, TResolvedTypesMeta, TRequireMissingImplementations extends boolean = false, TMissingImplementations = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'missingImplementations'>> = Compute<GenerateActionsImplementationsPart<TContext, TResolvedTypesMeta, TRequireMissingImplementations, TMissingImplementations> & GenerateActorsImplementationsPart<TContext, TResolvedTypesMeta, TRequireMissingImplementations, TMissingImplementations> & GenerateDelaysImplementationsPart<TContext, TResolvedTypesMeta, TRequireMissingImplementations, TMissingImplementations> & GenerateGuardsImplementationsPart<TContext, TResolvedTypesMeta, TRequireMissingImplementations, TMissingImplementations>>;
+export type MachineImplementations<TContext extends MachineContext, TEvent extends EventObject, TActor extends ProvidedActor = ProvidedActor, TAction extends ParameterizedObject = ParameterizedObject, TGuard extends ParameterizedObject = ParameterizedObject, TDelay extends string = string, TTag extends string = string, TTypesMeta extends TypegenConstraint = TypegenDisabled> = InternalMachineImplementations<TContext, ResolveTypegenMeta<TTypesMeta, TEvent, TActor, TAction, TGuard, TDelay, TTag>>;
+type InitialContext<TContext extends MachineContext, TActor extends ProvidedActor, TInput> = TContext | ContextFactory<TContext, TActor, TInput>;
+export type ContextFactory<TContext extends MachineContext, TActor extends ProvidedActor, TInput> = ({ spawn, input }: {
+    spawn: Spawner<TActor>;
+    input: TInput;
 }) => TContext;
-export interface MachineConfig<TContext extends MachineContext, TEvent extends EventObject, TAction extends ParameterizedObject = ParameterizedObject, TActorMap extends ActorMap = ActorMap, TTypesMeta = TypegenDisabled> extends StateNodeConfig<NoInfer<TContext>, NoInfer<TEvent>, TAction> {
+export type MachineConfig<TContext extends MachineContext, TEvent extends EventObject, TActor extends ProvidedActor = ProvidedActor, TAction extends ParameterizedObject = ParameterizedObject, TGuard extends ParameterizedObject = ParameterizedObject, TDelay extends string = string, TTag extends string = string, TInput = any, TOutput = unknown, TTypesMeta = TypegenDisabled> = (Omit<StateNodeConfig<NoInfer<TContext>, NoInfer<TEvent>, NoInfer<TActor>, NoInfer<TAction>, NoInfer<TGuard>, NoInfer<TDelay>, NoInfer<TTag>, NoInfer<TOutput>>, 'output'> & {
     /**
      * The initial context (extended state)
      */
-    context?: InitialContext<LowInfer<TContext>>;
     /**
      * The machine's own version.
      */
     version?: string;
-    /**
-     * If `true`, will use SCXML semantics, such as event token matching.
-     */
-    scxml?: boolean;
-    types?: MachineTypes<TContext, TEvent, TActorMap, TTypesMeta>;
+    types?: MachineTypes<TContext, TEvent, TActor, TAction, TGuard, TDelay, TTag, TInput, TOutput, TTypesMeta>;
+    output?: Mapper<TContext, DoneStateEvent, TOutput, TEvent> | TOutput;
+}) & (MachineContext extends TContext ? {
+    context?: InitialContext<LowInfer<TContext>, TActor, TInput>;
+} : {
+    context: InitialContext<LowInfer<TContext>, TActor, TInput>;
+});
+export interface ProvidedActor {
+    src: string;
+    logic: AnyActorLogic;
+    id?: string;
 }
-export type ActorMap = Record<string, {
-    output: any;
-}>;
-export interface MachineTypes<TContext extends MachineContext, TEvent extends EventObject, TActorMap extends ActorMap = ActorMap, TTypesMeta = TypegenDisabled> {
+export interface SetupTypes<TContext extends MachineContext, TEvent extends EventObject, TChildrenMap extends Record<string, string>, TTag extends string, TInput, TOutput> {
     context?: TContext;
-    actions?: {
-        type: string;
-        [key: string]: any;
-    };
-    actors?: TActorMap;
     events?: TEvent;
-    guards?: {
-        type: string;
-        [key: string]: any;
-    };
+    children?: TChildrenMap;
+    tags?: TTag;
+    input?: TInput;
+    output?: TOutput;
+}
+export interface MachineTypes<TContext extends MachineContext, TEvent extends EventObject, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string, TTag extends string, TInput, TOutput, TTypesMeta = TypegenDisabled> extends SetupTypes<TContext, TEvent, never, TTag, TInput, TOutput> {
+    actors?: TActor;
+    actions?: TAction;
+    guards?: TGuard;
+    delays?: TDelay;
     typegen?: TTypesMeta;
 }
 export interface HistoryStateNode<TContext extends MachineContext> extends StateNode<TContext> {
@@ -517,313 +478,115 @@ export type HistoryValue<TContext extends MachineContext, TEvent extends EventOb
 export type AnyHistoryValue = HistoryValue<any, any>;
 export type StateFrom<T extends AnyStateMachine | ((...args: any[]) => AnyStateMachine)> = T extends AnyStateMachine ? ReturnType<T['transition']> : T extends (...args: any[]) => AnyStateMachine ? ReturnType<ReturnType<T>['transition']> : never;
 export type Transitions<TContext extends MachineContext, TEvent extends EventObject> = Array<TransitionDefinition<TContext, TEvent>>;
-export declare enum ActionTypes {
-    Stop = "xstate.stop",
-    Raise = "xstate.raise",
-    Send = "xstate.send",
-    Cancel = "xstate.cancel",
-    Assign = "xstate.assign",
-    After = "xstate.after",
-    DoneState = "done.state",
-    DoneInvoke = "done.invoke",
-    Log = "xstate.log",
-    Init = "xstate.init",
-    Invoke = "xstate.invoke",
-    ErrorExecution = "error.execution",
-    ErrorCommunication = "error.communication",
-    ErrorPlatform = "error.platform",
-    ErrorCustom = "xstate.error",
-    Pure = "xstate.pure",
-    Choose = "xstate.choose"
+export interface DoneActorEvent<TOutput = unknown> {
+    type: `xstate.done.actor.${string}`;
+    output: TOutput;
 }
-export interface RaiseActionObject<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject = TExpressionEvent> extends BaseActionObject {
-    type: ActionTypes.Raise;
-    params: {
-        event: TEvent;
-        _event: SCXML.Event<TEvent>;
-        delay: RaiseActionOptions<TContext, TExpressionEvent>['delay'];
-        id: string | number;
-    };
-}
-export interface DoneInvokeEvent<TData> extends EventObject {
-    type: `done.invoke.${string}`;
-    output: TData;
+export interface ErrorActorEvent<TErrorData = unknown> extends EventObject {
+    type: `xstate.error.actor.${string}`;
+    error: TErrorData;
 }
-export interface ErrorEvent<TErrorData> {
-    type: `error.${string}`;
-    data: TErrorData;
-}
-export interface SnapshotEvent<TData> {
+export interface SnapshotEvent<TSnapshot extends Snapshot<unknown> = Snapshot<unknown>> extends EventObject {
     type: `xstate.snapshot.${string}`;
-    data: TData;
-}
-export interface ErrorExecutionEvent extends EventObject {
-    src: string;
-    type: ActionTypes.ErrorExecution;
-    data: any;
-}
-export interface ErrorPlatformEvent extends EventObject {
-    data: any;
-}
-export interface SCXMLErrorEvent extends SCXML.Event<any> {
-    name: ActionTypes.ErrorExecution | ActionTypes.ErrorPlatform | ActionTypes.ErrorCommunication;
-    data: any;
+    snapshot: TSnapshot;
 }
-export interface DoneEventObject extends EventObject {
-    output?: any;
-    toString(): string;
-}
-export type DoneEvent = DoneEventObject & string;
-export interface InvokeAction {
-    type: ActionTypes.Invoke;
-    src: string | ActorRef<any>;
-    id: string;
-    exec?: undefined;
-    meta: MetaObject | undefined;
-}
-export interface DynamicInvokeActionObject<TContext extends MachineContext, TEvent extends EventObject> {
-    type: ActionTypes.Invoke;
-    params: InvokeDefinition<TContext, TEvent>;
+export interface DoneStateEvent<TOutput = unknown> extends EventObject {
+    type: `xstate.done.state.${string}`;
+    output: TOutput;
 }
-export interface InvokeActionObject extends BaseActionObject {
-    type: ActionTypes.Invoke;
-    params: {
-        src: string | ActorRef<any>;
-        id: string;
-        exec?: undefined;
-        ref?: ActorRef<any>;
-        meta: MetaObject | undefined;
-    };
-}
-export interface DynamicStopActionObject<TContext extends MachineContext, TExpressionEvent extends EventObject> {
-    type: ActionTypes.Stop;
-    params: {
-        actor: string | ActorRef<any> | Expr<TContext, TExpressionEvent, ActorRef<any> | string>;
-    };
-}
-export interface StopActionObject {
-    type: ActionTypes.Stop;
-    params: {
-        actor: ActorRef<any>;
-    };
-}
-export type DelayExpr<TContext extends MachineContext, TEvent extends EventObject> = ExprWithMeta<TContext, TEvent, number>;
-export type LogExpr<TContext extends MachineContext, TEvent extends EventObject> = ExprWithMeta<TContext, TEvent, any>;
-export interface DynamicLogAction<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject> extends BaseDynamicActionObject<TContext, TExpressionEvent, TEvent, LogActionObject, {
-    label: string | undefined;
-    expr: string | LogExpr<TContext, TExpressionEvent>;
-}> {
-    type: ActionTypes.Log;
-}
-export interface LogActionObject extends BuiltInActionObject {
-    type: ActionTypes.Log;
-    params: {
-        label: string | undefined;
-        value: any;
-    };
-}
-export interface SendActionObject<TSentEvent extends EventObject = AnyEventObject> extends BaseActionObject {
-    type: 'xstate.send';
-    params: {
-        to: ActorRef<TSentEvent> | undefined;
-        _event: SCXML.Event<TSentEvent>;
-        event: TSentEvent;
-        delay?: number;
-        id: string | number;
-        internal: boolean;
-    };
-}
-export type Expr<TContext extends MachineContext, TEvent extends EventObject, T> = (arg: UnifiedArg<TContext, TEvent>) => T;
-export type ExprWithMeta<TContext extends MachineContext, TEvent extends EventObject, T> = (args: UnifiedArg<TContext, TEvent> & StateMeta<TEvent>) => T;
-export type SendExpr<TContext extends MachineContext, TEvent extends EventObject, TSentEvent extends EventObject = AnyEventObject> = ExprWithMeta<TContext, TEvent, TSentEvent>;
+export type DelayExpr<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject> = (args: ActionArgs<TContext, TExpressionEvent, TEvent>, params: TParams) => number;
+export type LogExpr<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject> = (args: ActionArgs<TContext, TExpressionEvent, TEvent>, params: TParams) => unknown;
+export type SendExpr<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TSentEvent extends EventObject, TEvent extends EventObject> = (args: ActionArgs<TContext, TExpressionEvent, TEvent>, params: TParams) => TSentEvent;
 export declare enum SpecialTargets {
     Parent = "#_parent",
     Internal = "#_internal"
 }
-export interface SendActionOptions<TContext extends MachineContext, TEvent extends EventObject> extends RaiseActionOptions<TContext, TEvent> {
-    to?: string | ActorRef<any, any> | ExprWithMeta<TContext, TEvent, string | ActorRef<any, any>>;
-}
-export interface RaiseActionOptions<TContext extends MachineContext, TEvent extends EventObject> {
-    id?: string | number;
-    delay?: number | string | DelayExpr<TContext, TEvent>;
-}
-export interface RaiseActionParams<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject> extends RaiseActionOptions<TContext, TExpressionEvent> {
-    event: TEvent | SendExpr<TContext, TExpressionEvent, TEvent>;
+export interface SendToActionOptions<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject, TDelay extends string> extends RaiseActionOptions<TContext, TExpressionEvent, TParams, TEvent, TDelay> {
 }
-export interface SendActionParams<TContext extends MachineContext, TEvent extends EventObject, TSentEvent extends EventObject = EventObject> extends SendActionOptions<TContext, TEvent> {
-    event: TSentEvent | SendExpr<TContext, TEvent, TSentEvent>;
+export interface RaiseActionOptions<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject, TDelay extends string> {
+    id?: string;
+    delay?: Delay<TDelay> | DelayExpr<TContext, TExpressionEvent, TParams, TEvent>;
 }
-export interface DynamicCancelActionObject<TContext extends MachineContext, TExpressionEvent extends EventObject> {
-    type: ActionTypes.Cancel;
-    params: {
-        sendId: string | ExprWithMeta<TContext, TExpressionEvent, string>;
-    };
+export interface RaiseActionParams<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject, TDelay extends string> extends RaiseActionOptions<TContext, TExpressionEvent, TParams, TEvent, TDelay> {
+    event: TEvent | SendExpr<TContext, TExpressionEvent, TParams, TEvent, TEvent>;
 }
-export interface CancelActionObject extends BaseActionObject {
-    type: ActionTypes.Cancel;
-    params: {
-        sendId: string;
-    };
+export interface SendToActionParams<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TSentEvent extends EventObject, TEvent extends EventObject, TDelay extends string> extends SendToActionOptions<TContext, TExpressionEvent, TParams, TEvent, TDelay> {
+    event: TSentEvent | SendExpr<TContext, TExpressionEvent, TParams, TSentEvent, TEvent>;
 }
-export type Assigner<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject = TExpressionEvent> = (args: {
-    context: TContext;
-    event: TExpressionEvent;
-} & AssignMeta<TExpressionEvent, TEvent>) => Partial<TContext>;
-export type PartialAssigner<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject, TKey extends keyof TContext> = (args: {
-    context: TContext;
-    event: TExpressionEvent;
-} & AssignMeta<TExpressionEvent, TEvent>) => TContext[TKey];
-export type PropertyAssigner<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject = TExpressionEvent> = {
-    [K in keyof TContext]?: PartialAssigner<TContext, TExpressionEvent, TEvent, K> | TContext[K];
+export type Assigner<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject, TActor extends ProvidedActor> = (args: AssignArgs<TContext, TExpressionEvent, TEvent, TActor>, params: TParams) => Partial<TContext>;
+export type PartialAssigner<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject, TActor extends ProvidedActor, TKey extends keyof TContext> = (args: AssignArgs<TContext, TExpressionEvent, TEvent, TActor>, params: TParams) => TContext[TKey];
+export type PropertyAssigner<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject, TActor extends ProvidedActor> = {
+    [K in keyof TContext]?: PartialAssigner<TContext, TExpressionEvent, TParams, TEvent, TActor, K> | TContext[K];
 };
-export type Mapper<TContext extends MachineContext, TEvent extends EventObject, TParams extends {}> = (args: {
+export type Mapper<TContext extends MachineContext, TExpressionEvent extends EventObject, TResult, TEvent extends EventObject> = (args: {
     context: TContext;
-    event: TEvent;
-}) => TParams;
-export type PropertyMapper<TContext extends MachineContext, TEvent extends EventObject, TParams extends {}> = {
-    [K in keyof TParams]?: ((args: {
-        context: TContext;
-        event: TEvent;
-    }) => TParams[K]) | TParams[K];
-};
-export interface AnyAssignAction extends BaseActionObject {
-    type: ActionTypes.Assign;
-    assignment: any;
-}
-export type DynamicAssignAction<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject = TExpressionEvent> = BaseDynamicActionObject<TContext, TExpressionEvent, TEvent, AssignActionObject<TContext> | RaiseActionObject<TContext, TExpressionEvent>, {
-    assignment: Assigner<TContext, TExpressionEvent, TEvent> | PropertyAssigner<TContext, TExpressionEvent, TEvent>;
-}>;
-export interface AssignActionObject<TContext extends MachineContext> extends BaseActionObject {
-    type: ActionTypes.Assign;
-    params: {
-        context: TContext;
-        actions: BaseActionObject[];
-    };
-}
-export interface DynamicPureActionObject<TContext extends MachineContext, TEvent extends EventObject> {
-    type: ActionTypes.Pure;
-    params: {
-        get: (args: {
-            context: TContext;
-            event: TEvent;
-        }) => SingleOrArray<BaseActionObject | BaseActionObject['type']> | undefined;
-    };
-}
-export interface PureActionObject extends BaseActionObject {
-    type: ActionTypes.Pure;
-    params: {
-        actions: BaseActionObject[];
-    };
-}
-export interface ChooseAction<TContext extends MachineContext, TEvent extends EventObject> extends BaseActionObject {
-    type: ActionTypes.Choose;
-    params: {
-        guards: Array<ChooseCondition<TContext, TEvent>>;
-    };
-}
-export interface ResolvedChooseAction extends BaseActionObject {
-    type: ActionTypes.Choose;
-    params: {
-        actions: BaseActionObject[];
-    };
-}
-export interface TransitionDefinition<TContext extends MachineContext, TEvent extends EventObject> extends Omit<TransitionConfig<TContext, TEvent>, 'target'> {
-    target: Array<StateNode<TContext, TEvent>> | undefined;
+    event: TExpressionEvent;
+    self: ActorRef<MachineSnapshot<TContext, TEvent, Record<string, AnyActorRef>, // TODO: this should be replaced with `TChildren`
+    StateValue, string, unknown>, TEvent>;
+}) => TResult;
+export interface TransitionDefinition<TContext extends MachineContext, TEvent extends EventObject> extends Omit<TransitionConfig<TContext, TEvent, TEvent, TODO, TODO, TODO, TODO>, 'target' | 'guard'> {
+    target: ReadonlyArray<StateNode<TContext, TEvent>> | undefined;
     source: StateNode<TContext, TEvent>;
-    actions: BaseActionObject[];
+    actions: readonly UnknownAction[];
     reenter: boolean;
-    guard?: GuardDefinition<TContext, TEvent>;
-    eventType: TEvent['type'] | '*';
+    guard?: UnknownGuard;
+    eventType: EventDescriptor<TEvent>;
     toJSON: () => {
         target: string[] | undefined;
         source: string;
-        actions: BaseActionObject[];
-        guard?: GuardDefinition<TContext, TEvent>;
-        eventType: TEvent['type'] | '*';
+        actions: readonly UnknownAction[];
+        guard?: UnknownGuard;
+        eventType: EventDescriptor<TEvent>;
         meta?: Record<string, any>;
     };
 }
 export type AnyTransitionDefinition = TransitionDefinition<any, any>;
 export interface InitialTransitionDefinition<TContext extends MachineContext, TEvent extends EventObject> extends TransitionDefinition<TContext, TEvent> {
-    target: Array<StateNode<TContext, TEvent>>;
+    target: ReadonlyArray<StateNode<TContext, TEvent>>;
     guard?: never;
 }
 export type TransitionDefinitionMap<TContext extends MachineContext, TEvent extends EventObject> = {
-    [K in TEvent['type'] | '*']: Array<TransitionDefinition<TContext, K extends TEvent['type'] ? Extract<TEvent, {
-        type: K;
-    }> : EventObject>>;
+    [K in EventDescriptor<TEvent>]: Array<TransitionDefinition<TContext, ExtractEvent<TEvent, K>>>;
 };
 export interface DelayedTransitionDefinition<TContext extends MachineContext, TEvent extends EventObject> extends TransitionDefinition<TContext, TEvent> {
-    delay: number | string | DelayExpr<TContext, TEvent>;
-}
-export interface Edge<TContext extends MachineContext, TEvent extends EventObject, TEventType extends TEvent['type'] = string> {
-    event: TEventType;
-    source: StateNode<TContext, TEvent>;
-    target: StateNode<TContext, TEvent>;
-    cond?: GuardConfig<TContext, TEvent & {
-        type: TEventType;
-    }>;
-    actions: Array<Action<TContext, TEvent>>;
-    meta?: MetaObject;
-    transition: TransitionDefinition<TContext, TEvent>;
-}
-export interface NodesAndEdges<TContext extends MachineContext, TEvent extends EventObject> {
-    nodes: StateNode[];
-    edges: Array<Edge<TContext, TEvent, TEvent['type']>>;
-}
-export interface Segment<TContext extends MachineContext, TEvent extends EventObject> {
-    /**
-     * From state.
-     */
-    state: State<TContext, TEvent>;
-    /**
-     * Event from state.
-     */
-    event: TEvent;
-}
-export interface StateMeta<TEvent extends EventObject> {
-    _event: SCXML.Event<TEvent>;
-    self: ActorRef<TEvent>;
-    system: ActorSystem<any>;
+    delay: number | string | DelayExpr<TContext, TEvent, undefined, TEvent>;
 }
 export interface StateLike<TContext extends MachineContext> {
     value: StateValue;
     context: TContext;
     event: EventObject;
-    _event: SCXML.Event<EventObject>;
 }
 export interface StateConfig<TContext extends MachineContext, TEvent extends EventObject> {
-    value: StateValue;
     context: TContext;
-    _event: SCXML.Event<TEvent>;
     historyValue?: HistoryValue<TContext, TEvent>;
-    actions?: BaseActionObject[];
-    meta?: any;
-    configuration?: Array<StateNode<TContext, TEvent>>;
-    transitions?: Array<TransitionDefinition<TContext, TEvent>>;
-    children: Record<string, ActorRef<any>>;
-    done?: boolean;
+    children: Record<string, ActorRef<any, any>>;
+    status: 'active' | 'done' | 'error' | 'stopped';
     output?: any;
-    tags?: Set<string>;
-    machine?: StateMachine<TContext, TEvent, any, any, any>;
-    _internalQueue?: Array<SCXML.Event<TEvent>>;
+    error?: unknown;
+    machine?: StateMachine<TContext, TEvent, any, any, any, any, any, any, any, any, any>;
 }
-export interface InterpreterOptions<_TActorBehavior extends AnyActorBehavior> {
+export interface ActorOptions<TLogic extends AnyActorLogic> {
     /**
-     * Whether state actions should be executed immediately upon transition. Defaults to `true`.
+     * The clock that is responsible for setting and clearing timeouts, such as delayed events and transitions.
+     *
+     * @remarks
+     * You can create your own “clock”. The clock interface is an object with two functions/methods:
+     *
+     * - `setTimeout` - same arguments as `window.setTimeout(fn, timeout)`
+     * - `clearTimeout` - same arguments as `window.clearTimeout(id)`
+     *
+     * By default, the native `setTimeout` and `clearTimeout` functions are used.
+     *
+     * For testing, XState provides `SimulatedClock`.
+     *
+     * @see {@link Clock}
+     * @see {@link SimulatedClock}
      */
-    execute?: boolean;
     clock?: Clock;
-    logger?: (...args: any[]) => void;
-    parent?: ActorRef<any>;
     /**
-     * If `true`, defers processing of sent events until the service
-     * is initialized (`.start()`). Otherwise, an error will be thrown
-     * for events sent to an uninitialized service.
-     *
-     * Default: `true`
+     * Specifies the logger to be used for log(...) actions. Defaults to the native console.log method.
      */
-    deferEvents?: boolean;
+    logger?: (...args: any[]) => void;
     /**
      * The custom `id` for referencing this service.
      */
@@ -834,7 +597,6 @@ export interface InterpreterOptions<_TActorBehavior extends AnyActorBehavior> {
      * Default: `false`
      */
     devTools?: boolean | DevToolsAdapter;
-    sync?: boolean;
     /**
      * The system ID to register this actor under
      */
@@ -842,79 +604,113 @@ export interface InterpreterOptions<_TActorBehavior extends AnyActorBehavior> {
     /**
      * The input data to pass to the actor.
      */
-    input?: any;
-    state?: any;
+    input?: InputFrom<TLogic>;
+    /**
+     * Initializes actor logic from a specific persisted internal state.
+     *
+     * @remarks
+     *
+     * If the state is compatible with the actor logic, when the actor is started it will be at that persisted state.
+     * Actions from machine actors will not be re-executed, because they are assumed to have been already executed.
+     * However, invocations will be restarted, and spawned actors will be restored recursively.
+     *
+     * Can be generated with {@link Actor.getPersistedSnapshot}.
+     *
+     * @see https://stately.ai/docs/persistence
+     */
+    snapshot?: Snapshot<unknown>;
+    /**
+     * @deprecated Use `snapshot` instead.
+     */
+    state?: Snapshot<unknown>;
     /**
      * The source definition.
      */
-    src?: string;
-}
-export type AnyInterpreter = Interpreter<any>;
-export declare namespace SCXML {
-    interface Event<TEvent extends EventObject> {
-        /**
-         * This is a character string giving the name of the event.
-         * The SCXML Processor must set the name field to the name of this event.
-         * It is what is matched against the 'event' attribute of <transition>.
-         * Note that transitions can do additional tests by using the value of this field
-         * inside boolean expressions in the 'cond' attribute.
-         */
-        name: string;
-        /**
-         * This field describes the event type.
-         * The SCXML Processor must set it to: "platform" (for events raised by the platform itself, such as error events),
-         * "internal" (for events raised by <raise> and <send> with target '_internal')
-         * or "external" (for all other events).
-         */
-        type: 'platform' | 'internal' | 'external';
-        /**
-         * If the sending entity has specified a value for this, the Processor must set this field to that value
-         * (see C Event I/O Processors for details).
-         * Otherwise, in the case of error events triggered by a failed attempt to send an event,
-         * the Processor must set this field to the send id of the triggering <send> element.
-         * Otherwise it must leave it blank.
-         */
-        sendid?: string;
-        /**
-         * This is a URI, equivalent to the 'target' attribute on the <send> element.
-         * For external events, the SCXML Processor should set this field to a value which,
-         * when used as the value of 'target', will allow the receiver of the event to <send>
-         * a response back to the originating entity via the Event I/O Processor specified in 'origintype'.
-         * For internal and platform events, the Processor must leave this field blank.
-         */
-        origin?: ActorRef<any>;
-        /**
-         * This is equivalent to the 'type' field on the <send> element.
-         * For external events, the SCXML Processor should set this field to a value which,
-         * when used as the value of 'type', will allow the receiver of the event to <send>
-         * a response back to the originating entity at the URI specified by 'origin'.
-         * For internal and platform events, the Processor must leave this field blank.
-         */
-        origintype?: string;
-        /**
-         * If this event is generated from an invoked child process, the SCXML Processor
-         * must set this field to the invoke id of the invocation that triggered the child process.
-         * Otherwise it must leave it blank.
-         */
-        invokeid?: string;
-        /**
-         * This field contains whatever data the sending entity chose to include in this event.
-         * The receiving SCXML Processor should reformat this data to match its data model,
-         * but must not otherwise modify it.
-         *
-         * If the conversion is not possible, the Processor must leave the field blank
-         * and must place an error 'error.execution' in the internal event queue.
-         */
-        data: TEvent;
-        /**
-         * @private
-         */
-        $$type: 'scxml';
-    }
-}
+    src?: string | AnyActorLogic;
+    /**
+     * A callback function or observer object which can be used to inspect actor system updates.
+     *
+     * @remarks
+     * If a callback function is provided, it can accept an inspection event argument. The types of inspection events that can be observed include:
+     *
+     * - `@xstate.actor` - An actor ref has been created in the system
+     * - `@xstate.event` - An event was sent from a source actor ref to a target actor ref in the system
+     * - `@xstate.snapshot` - An actor ref emitted a snapshot due to a received event
+     *
+     * @example
+     * ```ts
+     * import { createMachine } from 'xstate';
+     *
+     * const machine = createMachine({
+     *   // ...
+     * });
+     *
+     * const actor = createActor(machine, {
+     *   inspect: (inspectionEvent) => {
+     *     if (inspectionEvent.actorRef === actor) {
+     *       // This event is for the root actor
+     *     }
+     *
+     *     if (inspectionEvent.type === '@xstate.actor') {
+     *       console.log(inspectionEvent.actorRef);
+     *     }
+     *
+     *     if (inspectionEvent.type === '@xstate.event') {
+     *       console.log(inspectionEvent.sourceRef);
+     *       console.log(inspectionEvent.actorRef);
+     *       console.log(inspectionEvent.event);
+     *     }
+     *
+     *     if (inspectionEvent.type === '@xstate.snapshot') {
+     *       console.log(inspectionEvent.actorRef);
+     *       console.log(inspectionEvent.event);
+     *       console.log(inspectionEvent.snapshot);
+     *     }
+     *   }
+     * });
+     * ```
+     *
+     * Alternately, an observer object (`{ next?, error?, complete? }`) can be provided:
+     *
+     * @example
+     * ```ts
+     * const actor = createActor(machine, {
+     *   inspect: {
+     *     next: (inspectionEvent) => {
+     *       if (inspectionEvent.actorRef === actor) {
+     *         // This event is for the root actor
+     *       }
+     *
+     *       if (inspectionEvent.type === '@xstate.actor') {
+     *         console.log(inspectionEvent.actorRef);
+     *       }
+     *
+     *       if (inspectionEvent.type === '@xstate.event') {
+     *         console.log(inspectionEvent.sourceRef);
+     *         console.log(inspectionEvent.actorRef);
+     *         console.log(inspectionEvent.event);
+     *       }
+     *
+     *       if (inspectionEvent.type === '@xstate.snapshot') {
+     *         console.log(inspectionEvent.actorRef);
+     *         console.log(inspectionEvent.event);
+     *         console.log(inspectionEvent.snapshot);
+     *       }
+     *     }
+     *   }
+     * });
+     * ```
+     */
+    inspect?: Observer<InspectionEvent> | ((inspectionEvent: InspectionEvent) => void);
+}
+export type AnyActor = Actor<any>;
+/**
+ * @deprecated Use `AnyActor` instead.
+ */
+export type AnyInterpreter = AnyActor;
 export type Observer<T> = {
     next?: (value: T) => void;
-    error?: (err: any) => void;
+    error?: (err: unknown) => void;
     complete?: () => void;
 };
 export interface Subscription {
@@ -930,42 +726,51 @@ export interface Subscribable<T> extends InteropSubscribable<T> {
     subscribe(observer: Observer<T>): Subscription;
     subscribe(next: (value: T) => void, error?: (error: any) => void, complete?: () => void): Subscription;
 }
-export type Spawnable = AnyStateMachine | PromiseLike<any> | InvokeCallback | InteropObservable<any> | Subscribable<any> | ActorBehavior<any, any>;
-export type ExtractEvent<TEvent extends EventObject, TEventType extends TEvent['type']> = TEvent extends any ? TEventType extends TEvent['type'] ? TEvent : never : never;
+export type ExtractEvent<TEvent extends EventObject, TDescriptor extends EventDescriptor<TEvent>> = string extends TEvent['type'] ? TEvent : NormalizeDescriptor<TDescriptor> extends infer TNormalizedDescriptor ? TEvent extends any ? TEvent['type'] extends TNormalizedDescriptor ? TEvent : never : never : never;
 export interface BaseActorRef<TEvent extends EventObject> {
     send: (event: TEvent) => void;
 }
 export interface ActorLike<TCurrent, TEvent extends EventObject> extends Subscribable<TCurrent> {
     send: (event: TEvent) => void;
 }
-export interface ActorRef<TEvent extends EventObject, TSnapshot = any> extends Subscribable<TSnapshot>, InteropObservable<TSnapshot> {
+export interface ActorRef<TSnapshot extends Snapshot<unknown>, TEvent extends EventObject> extends Subscribable<TSnapshot>, InteropObservable<TSnapshot> {
     /**
      * The unique identifier for this actor relative to its parent.
      */
     id: string;
     sessionId: string;
     send: (event: TEvent) => void;
-    start?: () => void;
-    getSnapshot: () => TSnapshot | undefined;
-    getPersistedState?: () => any;
+    start: () => void;
+    getSnapshot: () => TSnapshot;
+    getPersistedSnapshot: () => Snapshot<unknown>;
     stop: () => void;
     toJSON?: () => any;
     _parent?: ActorRef<any, any>;
     system?: ActorSystem<any>;
-    status: ActorStatus;
-    src?: string;
+    src: string | AnyActorLogic;
 }
 export type AnyActorRef = ActorRef<any, any>;
-export type ActorRefFrom<T> = ReturnTypeOrValue<T> extends infer R ? R extends StateMachine<infer TContext, infer TEvent, any, any, infer TResolvedTypesMeta> ? ActorRef<TEvent, State<TContext, TEvent, AreAllImplementationsAssumedToBeProvided<TResolvedTypesMeta> extends false ? MarkAllImplementationsAsProvided<TResolvedTypesMeta> : TResolvedTypesMeta>> : R extends Promise<infer U> ? ActorRef<{
-    type: string;
-}, U | undefined> : R extends ActorBehavior<infer TEvent, infer TSnapshot> ? ActorRef<TEvent, TSnapshot> : never : never;
-export type DevToolsAdapter = (service: AnyInterpreter) => void;
-export type InterpreterFrom<T extends AnyStateMachine | ((...args: any[]) => AnyStateMachine)> = ReturnTypeOrValue<T> extends StateMachine<infer TContext, infer TEvent, any, any, infer TResolvedTypesMeta> ? Interpreter<ActorBehavior<TEvent, State<TContext, TEvent, TResolvedTypesMeta>, State<TContext, TEvent, TResolvedTypesMeta>, PersistedMachineState<State<TContext, TEvent, TResolvedTypesMeta>>>> : never;
-export type MachineImplementationsFrom<T extends AnyStateMachine | ((...args: any[]) => AnyStateMachine), TRequireMissingImplementations extends boolean = false> = ReturnTypeOrValue<T> extends StateMachine<infer TContext, infer TEvent, any, any, infer TResolvedTypesMeta> ? InternalMachineImplementations<TContext, TEvent, TResolvedTypesMeta, TRequireMissingImplementations> : never;
-export type __ResolvedTypesMetaFrom<T> = T extends StateMachine<any, any, any, infer TResolvedTypesMeta> ? TResolvedTypesMeta : never;
-export type EventOfMachine<TMachine extends AnyStateMachine> = TMachine extends StateMachine<any, infer E, any, any, any> ? E : never;
-export interface ActorContext<TEvent extends EventObject, TSnapshot, TSystem extends ActorSystem<any> = ActorSystem<any>> {
-    self: ActorRef<TEvent, TSnapshot>;
+export type ActorLogicFrom<T> = ReturnTypeOrValue<T> extends infer R ? R extends StateMachine<any, any, any, any, any, any, any, any, any, any, any> ? R : R extends Promise<infer U> ? PromiseActorLogic<U> : never : never;
+export type ActorRefFrom<T> = ReturnTypeOrValue<T> extends infer R ? R extends StateMachine<infer TContext, infer TEvent, infer TChildren, infer _TActor, infer _TAction, infer _TGuard, infer _TDelay, infer TStateValue, infer TTag, infer _TInput, infer TOutput, infer TResolvedTypesMeta> ? ActorRef<MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, AreAllImplementationsAssumedToBeProvided<TResolvedTypesMeta> extends false ? MarkAllImplementationsAsProvided<TResolvedTypesMeta> : TResolvedTypesMeta>, TEvent> : R extends Promise<infer U> ? ActorRefFrom<PromiseActorLogic<U>> : R extends ActorLogic<infer TSnapshot, infer TEvent, infer _TInput, infer _TSystem> ? ActorRef<TSnapshot, TEvent> : never : never;
+export type DevToolsAdapter = (service: AnyActor) => void;
+/**
+ * @deprecated Use `Actor<T>` instead.
+ */
+export type InterpreterFrom<T extends AnyStateMachine | ((...args: any[]) => AnyStateMachine)> = ReturnTypeOrValue<T> extends StateMachine<infer TContext, infer TEvent, infer TChildren, infer _TActor, infer _TAction, infer _TGuard, infer _TDelay, infer TStateValue, infer TTag, infer TInput, infer TOutput, infer TResolvedTypesMeta> ? Actor<ActorLogic<MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TResolvedTypesMeta>, TEvent, TInput, ActorSystem<any>>> : never;
+export type MachineImplementationsFrom<T extends AnyStateMachine | ((...args: any[]) => AnyStateMachine), TRequireMissingImplementations extends boolean = false> = ReturnTypeOrValue<T> extends StateMachine<infer TContext, infer _TEvent, infer _TChildren, infer _TActor, infer _TAction, infer _TGuard, infer _TDelay, infer _TStateValue, infer _TTag, infer _TInput, infer _TOutput, infer TResolvedTypesMeta> ? InternalMachineImplementations<TContext, TResolvedTypesMeta, TRequireMissingImplementations> : never;
+export type __ResolvedTypesMetaFrom<T> = T extends StateMachine<any, // context
+any, // event
+any, // children
+any, // actor
+any, // action
+any, // guard
+any, // delay
+any, // tag
+any, // input
+any, // output
+infer TResolvedTypesMeta> ? TResolvedTypesMeta : never;
+export interface ActorScope<TSnapshot extends Snapshot<unknown>, TEvent extends EventObject, TSystem extends ActorSystem<any> = ActorSystem<any>> {
+    self: ActorRef<TSnapshot, TEvent>;
     id: string;
     sessionId: string;
     logger: (...args: any[]) => void;
@@ -973,34 +778,84 @@ export interface ActorContext<TEvent extends EventObject, TSnapshot, TSystem ext
     system: TSystem;
     stopChild: (child: AnyActorRef) => void;
 }
-export type AnyActorContext = ActorContext<any, any, any>;
-export interface ActorBehavior<TEvent extends EventObject, TSnapshot = any, TInternalState = any, 
+export type AnyActorScope = ActorScope<any, any, AnyActorSystem>;
+export type Snapshot<TOutput> = {
+    status: 'active';
+    output: undefined;
+    error: undefined;
+} | {
+    status: 'done';
+    output: TOutput;
+    error: undefined;
+} | {
+    status: 'error';
+    output: undefined;
+    error: unknown;
+} | {
+    status: 'stopped';
+    output: undefined;
+    error: undefined;
+};
 /**
- * Serialized internal state used for persistence & restoration
+ * Represents logic which can be used by an actor.
+ *
+ * @template TSnapshot - The type of the snapshot.
+ * @template TEvent - The type of the event object.
+ * @template TInput - The type of the input.
+ * @template TSystem - The type of the actor system.
  */
-TPersisted = TInternalState, TSystem extends ActorSystem<any> = ActorSystem<any>> {
-    transition: (state: TInternalState, message: TEvent | LifecycleSignal, ctx: ActorContext<TEvent, TSnapshot, TSystem>) => TInternalState;
-    getInitialState: (actorCtx: ActorContext<TEvent, TSnapshot, any>, input: any) => TInternalState;
-    restoreState?: (persistedState: TPersisted, actorCtx: ActorContext<TEvent, TSnapshot>) => TInternalState;
-    getSnapshot?: (state: TInternalState) => TSnapshot;
-    getStatus?: (state: TInternalState) => {
-        status: string;
-        data?: any;
-    };
-    start?: (state: TInternalState, actorCtx: ActorContext<TEvent, TSnapshot>) => void;
-    /**
-     * @returns Persisted state
-     */
-    getPersistedState?: (state: TInternalState) => TPersisted;
-}
-export type AnyActorBehavior = ActorBehavior<any, any, any, any>;
-export type SnapshotFrom<T> = ReturnTypeOrValue<T> extends infer R ? R extends ActorRef<infer _, infer TSnapshot> ? TSnapshot : R extends Interpreter<infer TBehavior> ? SnapshotFrom<TBehavior> : R extends ActorBehavior<infer _, infer TSnapshot> ? TSnapshot : R extends ActorContext<infer _, infer TSnapshot, infer __> ? TSnapshot : never : never;
-export type EventFromBehavior<TBehavior extends ActorBehavior<any, any>> = TBehavior extends ActorBehavior<infer TEvent, infer _> ? TEvent : never;
-export type PersistedStateFrom<TBehavior extends ActorBehavior<any, any>> = TBehavior extends ActorBehavior<infer _TEvent, infer _TSnapshot, infer _TInternalState, infer TPersisted> ? TPersisted : never;
-export type InternalStateFrom<TBehavior extends ActorBehavior<any, any>> = TBehavior extends ActorBehavior<infer _TEvent, infer _TSnapshot, infer TInternalState, infer _TPersisted> ? TInternalState : never;
-type ResolveEventType<T> = ReturnTypeOrValue<T> extends infer R ? R extends StateMachine<infer _, infer TEvent, infer __, infer ___, infer ____> ? TEvent : R extends State<infer _, infer TEvent, infer __> ? TEvent : R extends Interpreter<infer _, infer TEvent> ? TEvent : R extends ActorRef<infer TEvent, infer _> ? TEvent : never : never;
+export interface ActorLogic<TSnapshot extends Snapshot<unknown>, TEvent extends EventObject, TInput = NonReducibleUnknown, TSystem extends ActorSystem<any> = ActorSystem<any>> {
+    /** The initial setup/configuration used to create the actor logic. */
+    config?: unknown;
+    /**
+     * Transition function that processes the current state and an incoming message
+     * to produce a new state.
+     * @param snapshot - The current state.
+     * @param message - The incoming message.
+     * @param ctx - The actor scope.
+     * @returns The new state.
+     */
+    transition: (snapshot: TSnapshot, message: TEvent, ctx: ActorScope<TSnapshot, TEvent, TSystem>) => TSnapshot;
+    /**
+     * Called to provide the initial state of the actor.
+     * @param actorScope - The actor scope.
+     * @param input - The input for the initial state.
+     * @returns The initial state.
+     */
+    getInitialSnapshot: (actorScope: ActorScope<TSnapshot, TEvent, TSystem>, input: TInput) => TSnapshot;
+    /**
+     * Called when Actor is created to restore the internal state of the actor given a persisted state.
+     * The persisted state can be created by `getPersistedSnapshot`.
+     * @param persistedState - The persisted state to restore from.
+     * @param actorScope - The actor scope.
+     * @returns The restored state.
+     */
+    restoreSnapshot?: (persistedState: Snapshot<unknown>, actorScope: ActorScope<TSnapshot, TEvent>) => TSnapshot;
+    /**
+     * Called when the actor is started.
+     * @param snapshot - The starting state.
+     * @param actorScope - The actor scope.
+     */
+    start?: (snapshot: TSnapshot, actorScope: ActorScope<TSnapshot, TEvent>) => void;
+    /**
+     * Obtains the internal state of the actor in a representation which can be be persisted.
+     * The persisted state can be restored by `restoreSnapshot`.
+     * @param snapshot - The current state.
+     * @returns The a representation of the internal state to be persisted.
+     */
+    getPersistedSnapshot: (snapshot: TSnapshot, options?: unknown) => Snapshot<unknown>;
+}
+export type AnyActorLogic = ActorLogic<any, // snapshot
+any, // event
+any, // input
+any>;
+export type UnknownActorLogic = ActorLogic<any, // this is invariant and it's hard to figure out a better default than `any`
+EventObject, NonReducibleUnknown, ActorSystem<any>>;
+export type SnapshotFrom<T> = ReturnTypeOrValue<T> extends infer R ? R extends ActorRef<infer TSnapshot, infer _> ? TSnapshot : R extends Actor<infer TLogic> ? SnapshotFrom<TLogic> : R extends ActorLogic<infer _, infer __, infer ___, infer ____> ? ReturnType<R['transition']> : R extends ActorScope<infer TSnapshot, infer _, infer __> ? TSnapshot : never : never;
+export type EventFromLogic<TLogic extends ActorLogic<any, any, any, any>> = TLogic extends ActorLogic<infer _, infer TEvent, infer __, infer _____> ? TEvent : never;
+type ResolveEventType<T> = ReturnTypeOrValue<T> extends infer R ? R extends StateMachine<infer _TContext, infer TEvent, infer _TChildren, infer _TActor, infer _TAction, infer _TGuard, infer _TDelay, infer _TStateValue, infer _TTag, infer _TInput, infer _TOutput, infer _TResolvedTypesMeta> ? TEvent : R extends MachineSnapshot<infer _TContext, infer TEvent, infer _TChildren, infer _TTag, infer _TOutput, infer _TResolvedTypesMeta> ? TEvent : R extends ActorRef<infer _, infer TEvent> ? TEvent : never : never;
 export type EventFrom<T, K extends Prop<TEvent, 'type'> = never, TEvent extends EventObject = ResolveEventType<T>> = IsNever<K> extends true ? TEvent : ExtractEvent<TEvent, K>;
-export type ContextFrom<T> = ReturnTypeOrValue<T> extends infer R ? R extends StateMachine<infer TContext, infer _, infer __, infer ___, infer ____> ? TContext : R extends State<infer TContext, infer _, infer __> ? TContext : R extends Interpreter<infer TBehavior> ? TBehavior extends StateMachine<infer TContext, infer _> ? TContext : never : never : never;
+export type ContextFrom<T> = ReturnTypeOrValue<T> extends infer R ? R extends StateMachine<infer TContext, infer _TEvent, infer _TChildren, infer _TActor, infer _TAction, infer _TGuard, infer _TDelay, infer _TStateValue, infer _TTag, infer _TInput, infer _TOutput, infer _TTypesMeta> ? TContext : R extends MachineSnapshot<infer TContext, infer _TEvent, infer _TChildren, infer _TTag, infer _TOutput, infer _TResolvedTypesMeta> ? TContext : R extends Actor<infer TActorLogic> ? TActorLogic extends StateMachine<infer TContext, infer _TEvent, infer _TChildren, infer _TActor, infer _TAction, infer _TGuard, infer _TDelay, infer _TTag, infer _TInput, infer _TOutput, infer _TTypesMeta> ? TContext : never : never : never;
 export type InferEvent<E extends EventObject> = {
     [T in E['type']]: {
         type: T;
@@ -1010,23 +865,27 @@ export type InferEvent<E extends EventObject> = {
 }[E['type']];
 export type TODO = any;
 export type StateValueFrom<TMachine extends AnyStateMachine> = Parameters<StateFrom<TMachine>['matches']>[0];
-export type StateFromMachine<TMachine extends AnyStateMachine> = TMachine['initialState'];
+export type TagsFrom<TMachine extends AnyStateMachine> = Parameters<StateFrom<TMachine>['hasTag']>[0];
 export interface ActorSystemInfo {
     actors: Record<string, AnyActorRef>;
 }
 export interface ActorSystem<T extends ActorSystemInfo> {
-    _bookId: () => string;
-    _register: (sessionId: string, actorRef: AnyActorRef) => string;
-    _unregister: (actorRef: AnyActorRef) => void;
-    _set: <K extends keyof T['actors']>(key: K, actorRef: T['actors'][K]) => void;
     get: <K extends keyof T['actors']>(key: K) => T['actors'][K] | undefined;
+    inspect: (observer: Observer<InspectionEvent>) => void;
 }
-export type PersistedMachineState<TState extends AnyState> = Pick<TState, 'value' | 'output' | 'context' | '_event' | 'done' | 'historyValue'> & {
-    children: {
-        [K in keyof TState['children']]: {
-            state: any;
-            src?: string;
-        };
+export type AnyActorSystem = ActorSystem<any>;
+export type RequiredActorOptions<TActor extends ProvidedActor> = (undefined extends TActor['id'] ? never : 'id') | (undefined extends InputFrom<TActor['logic']> ? never : 'input');
+type ExtractLiteralString<T extends string | undefined> = T extends string ? string extends T ? never : T : never;
+type ToConcreteChildren<TActor extends ProvidedActor> = {
+    [A in TActor as ExtractLiteralString<A['id']>]?: ActorRefFrom<A['logic']>;
+};
+export type ToChildren<TActor extends ProvidedActor> = string extends TActor['src'] ? Record<string, AnyActorRef> : Compute<ToConcreteChildren<TActor> & {
+    include: {
+        [id: string]: TActor extends any ? ActorRefFrom<TActor['logic']> | undefined : never;
     };
+    exclude: {};
+}[undefined extends TActor['id'] ? 'include' : string extends TActor['id'] ? 'include' : 'exclude']>;
+export type StateSchema = {
+    states?: Record<string, StateSchema>;
 };
 export {};