xstate

Index

Classes

• Actor
• SimulatedClock
• StateMachine
• StateNode

Enumerations

• SpecialTargets

Functions

• __unsafe_getAllOwnEventDescriptors
• and
• assign
• cancel
• createActor
• createEmptyActor
• createMachine
• enqueueActions
• forwardTo
• fromCallback
• fromEventObservable
• fromObservable
• fromPromise
• fromTransition
• getStateNodes
• interpret
• isMachineSnapshot
• log
• matchesState
• not
• or
• pathToStateValue
• raise
• sendParent
• sendTo
• setup
• spawnChild
• stateIn
• stop
• stopChild
• toObserver
• waitFor

Interfaces

• ActionArgs
• ActorLike
• ActorLogic
• ActorOptions
• ActorRef
• ActorScope
• ActorSystem
• ActorSystemInfo
• AnyEventObject
• AssignAction
• AssignArgs
• AtomicStateNodeConfig
• BaseActorRef
• CancelAction
• ChooseBranch
• DelayedTransitionDefinition
• DoneActorEvent
• DoneStateEvent
• EnqueueActionsAction
• ErrorActorEvent
• HistoryStateNode
• HistoryStateNodeConfig
• InitialTransitionConfig
• InitialTransitionDefinition
• InspectedActorEvent
• InspectedEventEvent
• InspectedSnapshotEvent
• InteropObservable
• InteropSubscribable
• InvokeDefinition
• LogAction
• MachineImplementationsSimplified
• MachineTypes
• MarkAllImplementationsAsProvided
• ParameterizedObject
• ProvidedActor
• RaiseAction
• RaiseActionOptions
• RaiseActionParams
• ResolveTypegenMeta
• ResolvedTypegenMeta
• SendToAction
• SendToActionOptions
• SendToActionParams
• SetupTypes
• SnapshotEvent
• SpawnAction
• StateConfig
• StateLike
• StateMachineDefinition
• StateNodeConfig
• StateNodeDefinition
• StateValueMap
• StopAction
• Subscribable
• Subscription
• TransitionConfig
• TransitionDefinition
• TypegenDisabled
• TypegenEnabled
• TypegenMeta
• UnifiedArg

Type Aliases

• Action
• ActionFunction
• ActionFunctionMap
• Actions
• ActorLogicFrom
• ActorRefFrom
• AnyActor
• AnyActorLogic
• AnyActorRef
• AnyActorScope
• AnyFunction
• AnyHistoryValue
• AnyInterpreter
• AnyInvokeConfig
• AnyMachineSnapshot
• AnyState
• AnyStateConfig
• AnyStateMachine
• AnyStateNode
• AnyStateNodeConfig
• AnyStateNodeDefinition
• AnyTransitionConfig
• AnyTransitionDefinition
• AreAllImplementationsAssumedToBeProvided
• Assigner
• CallbackActorLogic
• CallbackSnapshot
• Cast
• Compute
• ConditionalRequired
• ContextFactory
• ContextFrom
• DelayConfig
• DelayExpr
• DelayFunctionMap
• DelayedTransitions
• DevToolsAdapter
• Elements
• Equals
• EventDescriptor
• EventFrom
• EventFromLogic
• EventObject
• ExtractEvent
• GetParameterizedParams
• HistoryValue
• HomomorphicOmit
• HomomorphicPick
• Identity
• IndexByProp
• IndexByType
• InferEvent
• InputFrom
• InspectionEvent
• InternalMachineImplementations
• Interpreter
• InterpreterFrom
• Invert
• InvokeConfig
• IsAny
• IsLiteralString
• IsNever
• IsNotNever
• Lazy
• LogExpr
• LowInfer
• MachineConfig
• MachineContext
• MachineImplementations
• MachineImplementationsFrom
• MachineSnapshot
• Mapper
• MaybeLazy
• Merge
• MetaObject
• MissingImplementationsError
• NoInfer
• NoRequiredParams
• NonReducibleUnknown
• ObservableActorLogic
• ObservableSnapshot
• Observer
• OutputFrom
• PartialAssigner
• PromiseActorLogic
• PromiseSnapshot
• Prop
• PropertyAssigner
• RequiredActorOptions
• SendExpr
• SimpleOrStateNodeConfig
• SingleOrArray
• Snapshot
• SnapshotFrom
• Spawner
• StateFrom
• StateKey
• StateNodesConfig
• StateSchema
• StateTypes
• StateValue
• StateValueFrom
• StatesConfig
• StatesDefinition
• TODO
• TagsFrom
• ToChildren
• TransitionActorLogic
• TransitionConfigOrTarget
• TransitionConfigTarget
• TransitionDefinitionMap
• TransitionSnapshot
• TransitionTarget
• Transitions
• TransitionsConfig
• TypegenConstraint
• UnknownAction
• UnknownActorLogic
• Values
• WithDynamicParams
• __ResolvedTypesMetaFrom

Type Aliases

Action

Action<TContext, TExpressionEvent, TEvent, TParams, TActor, TAction, TGuard, TDelay>: NoRequiredParams<TAction> | WithDynamicParams<TContext, TExpressionEvent, TAction> | ActionFunction<TContext, TExpressionEvent, TEvent, TParams, TActor, TAction, TGuard, TDelay>

Type parameters

• TContext: MachineContext
• TExpressionEvent: EventObject
• TEvent: EventObject
• TParams: ParameterizedObject[params] | undefined
• TActor: ProvidedActor
• TAction: ParameterizedObject
• TGuard: ParameterizedObject
• TDelay: string

ActionFunction

ActionFunction<TContext, TExpressionEvent, TEvent, TParams, TActor, TAction, TGuard, TDelay>: { _out_TAction?: TAction; _out_TActor?: TActor; _out_TDelay?: TDelay; _out_TEvent?: TEvent; _out_TGuard?: TGuard }

Type parameters

• TContext: MachineContext
• TExpressionEvent: EventObject
• TEvent: EventObject
• TParams: ParameterizedObject[params] | undefined
• TActor: ProvidedActor
• TAction: ParameterizedObject
• TGuard: ParameterizedObject
• TDelay: string

Type declaration

• • (args: ActionArgs<TContext, TExpressionEvent, TEvent>, params: TParams): void

  • Parameters

    • args: ActionArgs<TContext, TExpressionEvent, TEvent>

    • params: TParams

    Returns void

• optional_out_TAction?: TAction

• optional_out_TActor?: TActor

• optional_out_TDelay?: TDelay

• optional_out_TEvent?: TEvent

• optional_out_TGuard?: TGuard

ActionFunctionMap

ActionFunctionMap<TContext, TEvent, TActor, TAction, TGuard, TDelay>: { [ K in TAction[type] ]?: ActionFunction<TContext, TEvent, TEvent, GetParameterizedParams<TAction extends { type: K } ? TAction : never>, TActor, TAction, TGuard, TDelay> }

Type parameters

• TContext: MachineContext
• TEvent: EventObject
• TActor: ProvidedActor
• TAction: ParameterizedObject = ParameterizedObject
• TGuard: ParameterizedObject = ParameterizedObject
• TDelay: string = string

Actions

Actions<TContext, TExpressionEvent, TEvent, TParams, TActor, TAction, TGuard, TDelay>: SingleOrArray<Action<TContext, TExpressionEvent, TEvent, TParams, TActor, TAction, TGuard, TDelay>>

Type parameters

• TContext: MachineContext
• TExpressionEvent: EventObject
• TEvent: EventObject
• TParams: ParameterizedObject[params] | undefined
• TActor: ProvidedActor
• TAction: ParameterizedObject
• TGuard: ParameterizedObject
• TDelay: string

ActorLogicFrom

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

Type parameters

• T

ActorRefFrom

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

Type parameters

• T

AnyActor

AnyActor: Actor<any>

AnyActorLogic

AnyActorLogic: ActorLogic<any, any, any, any>

AnyActorRef

AnyActorRef: ActorRef<any, any>

AnyActorScope

AnyActorScope: ActorScope<any, any, AnyActorSystem>

AnyFunction

AnyFunction: (...args: any[]) => any

Type declaration

• • (...args: any[]): any

  • Parameters

    • rest...args: any[]

    Returns any

AnyHistoryValue

AnyHistoryValue: HistoryValue<any, any>

AnyInterpreter

AnyInterpreter: AnyActor

@deprecated

Use AnyActor instead.

AnyInvokeConfig

AnyInvokeConfig: InvokeConfig<any, any, any, any, any, any>

AnyMachineSnapshot

AnyMachineSnapshot: MachineSnapshot<any, any, any, any, any, any, any>

AnyState

AnyState: AnyMachineSnapshot

@deprecated

use AnyMachineSnapshot instead

AnyStateConfig

AnyStateConfig: StateConfig<any, AnyEventObject>

AnyStateMachine

AnyStateMachine: StateMachine<any, any, any, any, any, any, any, any, any, any, any, any>

AnyStateNode

AnyStateNode: StateNode<any, any>

AnyStateNodeConfig

AnyStateNodeConfig: StateNodeConfig<any, any, any, any, any, any, any, any>

AnyStateNodeDefinition

AnyStateNodeDefinition: StateNodeDefinition<any, any>

AnyTransitionConfig

AnyTransitionConfig: TransitionConfig<any, any, any, any, any, any, any>

AnyTransitionDefinition

AnyTransitionDefinition: TransitionDefinition<any, any>

AreAllImplementationsAssumedToBeProvided

AreAllImplementationsAssumedToBeProvided<TResolvedTypesMeta, TMissingImplementations>: IsAny<TResolvedTypesMeta> extends true ? true : TResolvedTypesMeta extends TypegenEnabled ? IsNever<Values<{ [ K in keyof TMissingImplementations ]: TMissingImplementations[K] }>> extends true ? true : false : true

Type parameters

• TResolvedTypesMeta
• TMissingImplementations = Prop<Prop<TResolvedTypesMeta, resolved>, missingImplementations>

Assigner

Assigner<TContext, TExpressionEvent, TParams, TEvent, TActor>: (args: AssignArgs<TContext, TExpressionEvent, TEvent, TActor>, params: TParams) => Partial<TContext>

Type parameters

• TContext: MachineContext
• TExpressionEvent: EventObject
• TParams: ParameterizedObject[params] | undefined
• TEvent: EventObject
• TActor: ProvidedActor

Type declaration

• • (args: AssignArgs<TContext, TExpressionEvent, TEvent, TActor>, params: TParams): Partial<TContext>

  • Parameters

    • args: AssignArgs<TContext, TExpressionEvent, TEvent, TActor>

    • params: TParams

    Returns Partial<TContext>

CallbackActorLogic

CallbackActorLogic<TEvent, TInput>: ActorLogic<CallbackSnapshot<TInput>, TEvent, TInput, AnyActorSystem>

Type parameters

• TEvent: EventObject
• TInput = NonReducibleUnknown

CallbackSnapshot

CallbackSnapshot<TInput>: Snapshot<undefined> & { input: TInput }

Type parameters

• TInput

Cast

Cast<A, B>: A extends B ? A : B

Type parameters

• A
• B

Compute

Compute<A>: { [ K in keyof A ]: A[K] } & unknown

Type parameters

• A: any

ConditionalRequired

ConditionalRequired<T, Condition>: Condition extends true ? Required<T> : T

Type parameters

• T
• Condition: boolean

ContextFactory

ContextFactory<TContext, TActor, TInput>: ({ spawn, input }: { input: TInput; spawn: Spawner<TActor> }) => TContext

Type parameters

• TContext: MachineContext
• TActor: ProvidedActor
• TInput

Type declaration

• • ({ spawn, input }: { input: TInput; spawn: Spawner<TActor> }): TContext

  • Parameters

    • { spawn, input }: { input: TInput; spawn: Spawner<TActor> }

    Returns TContext

ContextFrom

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

Type parameters

• T

DelayConfig

DelayConfig<TContext, TExpressionEvent, TParams, TEvent>: number | DelayExpr<TContext, TExpressionEvent, TParams, TEvent>

Type parameters

• TContext: MachineContext
• TExpressionEvent: EventObject
• TParams: ParameterizedObject[params] | undefined
• TEvent: EventObject

DelayExpr

DelayExpr<TContext, TExpressionEvent, TParams, TEvent>: (args: ActionArgs<TContext, TExpressionEvent, TEvent>, params: TParams) => number

Type parameters

• TContext: MachineContext
• TExpressionEvent: EventObject
• TParams: ParameterizedObject[params] | undefined
• TEvent: EventObject

Type declaration

• • (args: ActionArgs<TContext, TExpressionEvent, TEvent>, params: TParams): number

  • Parameters

    • args: ActionArgs<TContext, TExpressionEvent, TEvent>

    • params: TParams

    Returns number

DelayFunctionMap

DelayFunctionMap<TContext, TEvent, TAction>: Record<string, DelayConfig<TContext, TEvent, TAction[params], TEvent>>

Type parameters

• TContext: MachineContext
• TEvent: EventObject
• TAction: ParameterizedObject

DelayedTransitions

DelayedTransitions<TContext, TEvent, TActor, TAction, TGuard, TDelay>: { [ K in Delay<TDelay> ]?: string | SingleOrArray<TransitionConfig<TContext, TEvent, TEvent, TActor, TAction, TGuard, TDelay>> }

Type parameters

• TContext: MachineContext
• TEvent: EventObject
• TActor: ProvidedActor
• TAction: ParameterizedObject
• TGuard: ParameterizedObject
• TDelay: string

DevToolsAdapter

DevToolsAdapter: (service: AnyActor) => void

Type declaration

• • (service: AnyActor): void

  • Parameters

    • service: AnyActor

    Returns void

Elements

Elements<T>: T[keyof T & `${number}`]

Type parameters

• T

Equals

Equals<A1, A2>: <A>() => A extends A2 ? true : false extends <A>() => A extends A1 ? true : false ? true : false

Type parameters

• A1: any
• A2: any

EventDescriptor

EventDescriptor<TEvent>: TEvent[type] | PartialEventDescriptor<TEvent[type]> | *

Type parameters

• TEvent: EventObject

EventFrom

EventFrom<T, K, TEvent>: IsNever<K> extends true ? TEvent : ExtractEvent<TEvent, K>

Type parameters

• T
• K: Prop<TEvent, type> = never
• TEvent: EventObject = ResolveEventType<T>

EventFromLogic

EventFromLogic<TLogic>: TLogic extends ActorLogic<infer _, infer TEvent, infer __, infer _____> ? TEvent : never

Type parameters

• TLogic: ActorLogic<any, any, any, any>

EventObject

EventObject: { type: string }

The full definition of an event, with a string type.

---

Type declaration

• type: string

  The type of event that is sent.

ExtractEvent

ExtractEvent<TEvent, TDescriptor>: string extends TEvent[type] ? TEvent : NormalizeDescriptor<TDescriptor> extends infer TNormalizedDescriptor ? TEvent extends any ? TEvent[type] extends TNormalizedDescriptor ? TEvent : never : never : never

Type parameters

• TEvent: EventObject
• TDescriptor: EventDescriptor<TEvent>

GetParameterizedParams

GetParameterizedParams<T>: T extends any ? params extends keyof T ? T[params] : undefined : never

Type parameters

• T: ParameterizedObject | undefined

HistoryValue

HistoryValue<TContext, TEvent>: Record<string, StateNode<TContext, TEvent>[]>

Type parameters

• TContext: MachineContext
• TEvent: EventObject

HomomorphicOmit

HomomorphicOmit<T, K>: { [ P in keyof T as Exclude<P, K> ]: T[P] }

Type parameters

• T
• K: keyof any

HomomorphicPick

HomomorphicPick<T, K>: { [ P in keyof T as P & K ]: T[P] }

Type parameters

• T
• K: keyof any

Identity

Identity<T>: { [ K in keyof T ]: T[K] }

Type parameters

• T

IndexByProp

IndexByProp<T, P>: { [ E in T as E[P] ]: E }

Type parameters

• T: Record<P, string>
• P: keyof T

IndexByType

IndexByType<T>: IndexByProp<T, type>

Type parameters

• T: { type: string }

InferEvent

InferEvent<E>: { [ T in E[type] ]: { type: T } & Extract<E, { type: T }> }[E[type]]

Type parameters

• E: EventObject

InputFrom

InputFrom<T>: 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

Type parameters

• T

InspectionEvent

InspectionEvent: InspectedSnapshotEvent | InspectedEventEvent | InspectedActorEvent

InternalMachineImplementations

InternalMachineImplementations<TContext, TResolvedTypesMeta, TRequireMissingImplementations, TMissingImplementations>: Compute<GenerateActionsImplementationsPart<TContext, TResolvedTypesMeta, TRequireMissingImplementations, TMissingImplementations> & GenerateActorsImplementationsPart<TContext, TResolvedTypesMeta, TRequireMissingImplementations, TMissingImplementations> & GenerateDelaysImplementationsPart<TContext, TResolvedTypesMeta, TRequireMissingImplementations, TMissingImplementations> & GenerateGuardsImplementationsPart<TContext, TResolvedTypesMeta, TRequireMissingImplementations, TMissingImplementations>>

Type parameters

• TContext: MachineContext
• TResolvedTypesMeta
• TRequireMissingImplementations: boolean = false
• TMissingImplementations = Prop<Prop<TResolvedTypesMeta, resolved>, missingImplementations>

Interpreter

Interpreter: typeof Actor

@deprecated

Use Actor instead.

InterpreterFrom

InterpreterFrom<T>: 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, AnyActorSystem>> : never

@deprecated

Use Actor<T> instead.

---

Type parameters

• T: AnyStateMachine | (...args: any[]) => AnyStateMachine

Invert

Invert<T>: { [ K in keyof T as T[K] ]: K }

Type parameters

• T: Record<PropertyKey, PropertyKey>

InvokeConfig

InvokeConfig<TContext, TEvent, TActor, TAction, TGuard, TDelay>: IsLiteralString<TActor[src]> extends true ? DistributeActors<TContext, TEvent, TActor, TAction, TGuard, TDelay, TActor> : { id?: string; input?: Mapper<TContext, TEvent, NonReducibleUnknown, TEvent> | NonReducibleUnknown; onDone?: string | SingleOrArray<TransitionConfigOrTarget<TContext, DoneActorEvent<any>, TEvent, TActor, TAction, TGuard, TDelay>>; onError?: string | SingleOrArray<TransitionConfigOrTarget<TContext, ErrorActorEvent, TEvent, TActor, TAction, TGuard, TDelay>>; onSnapshot?: string | SingleOrArray<TransitionConfigOrTarget<TContext, SnapshotEvent, TEvent, TActor, TAction, TGuard, TDelay>>; src: AnyActorLogic | string; systemId?: string }

Type parameters

• TContext: MachineContext
• TEvent: EventObject
• TActor: ProvidedActor
• TAction: ParameterizedObject
• TGuard: ParameterizedObject
• TDelay: string

IsAny

IsAny<T>: Equals<T, any>

Type parameters

• T

IsLiteralString

IsLiteralString<T>: string extends T ? false : true

Type parameters

• T: string

IsNever

IsNever<T>: [T] extends [never] ? true : false

Type parameters

• T

IsNotNever

IsNotNever<T>: [T] extends [never] ? false : true

Type parameters

• T

Lazy

Lazy<T>: () => T

Type parameters

• T

Type declaration

• • (): T

  • Returns T

LogExpr

LogExpr<TContext, TExpressionEvent, TParams, TEvent>: (args: ActionArgs<TContext, TExpressionEvent, TEvent>, params: TParams) => unknown

Type parameters

• TContext: MachineContext
• TExpressionEvent: EventObject
• TParams: ParameterizedObject[params] | undefined
• TEvent: EventObject

Type declaration

• • (args: ActionArgs<TContext, TExpressionEvent, TEvent>, params: TParams): unknown

  • Parameters

    • args: ActionArgs<TContext, TExpressionEvent, TEvent>

    • params: TParams

    Returns unknown

LowInfer

LowInfer<T>: T & {}

Type parameters

• T

MachineConfig

MachineConfig<TContext, TEvent, TActor, TAction, TGuard, TDelay, TTag, TInput, TOutput, TTypesMeta>: (Omit<StateNodeConfig<NoInfer<TContext>, NoInfer<TEvent>, NoInfer<TActor>, NoInfer<TAction>, NoInfer<TGuard>, NoInfer<TDelay>, NoInfer<TTag>, NoInfer<TOutput>>, output> & { output?: Mapper<TContext, DoneStateEvent, TOutput, TEvent> | TOutput; types?: MachineTypes<TContext, TEvent, TActor, TAction, TGuard, TDelay, TTag, TInput, TOutput, TTypesMeta>; version?: string }) & (MachineContext extends TContext ? { context?: InitialContext<LowInfer<TContext>, TActor, TInput> } : { context: InitialContext<LowInfer<TContext>, TActor, TInput> })

Type parameters

• TContext: MachineContext
• TEvent: EventObject
• TActor: ProvidedActor = ProvidedActor
• TAction: ParameterizedObject = ParameterizedObject
• TGuard: ParameterizedObject = ParameterizedObject
• TDelay: string = string
• TTag: string = string
• TInput = any
• TOutput = unknown
• TTypesMeta = TypegenDisabled

MachineContext

MachineContext: Record<string, any>

MachineImplementations

MachineImplementations<TContext, TEvent, TActor, TAction, TGuard, TDelay, TTag, TTypesMeta>: InternalMachineImplementations<TContext, ResolveTypegenMeta<TTypesMeta, TEvent, TActor, TAction, TGuard, TDelay, TTag>>

Type parameters

• TContext: MachineContext
• TEvent: EventObject
• TActor: ProvidedActor = ProvidedActor
• TAction: ParameterizedObject = ParameterizedObject
• TGuard: ParameterizedObject = ParameterizedObject
• TDelay: string = string
• TTag: string = string
• TTypesMeta: TypegenConstraint = TypegenDisabled

MachineImplementationsFrom

MachineImplementationsFrom<T, TRequireMissingImplementations>: 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

Type parameters

• T: AnyStateMachine | (...args: any[]) => AnyStateMachine
• TRequireMissingImplementations: boolean = false

MachineSnapshot

MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TResolvedTypesMeta>: ActiveMachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TResolvedTypesMeta> | DoneMachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TResolvedTypesMeta> | ErrorMachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TResolvedTypesMeta> | StoppedMachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TResolvedTypesMeta>

Type parameters

• TContext: MachineContext
• TEvent: EventObject
• TChildren: Record<string, AnyActorRef | undefined>
• TStateValue: StateValue
• TTag: string
• TOutput
• TResolvedTypesMeta = TypegenDisabled

Mapper

Mapper<TContext, TExpressionEvent, TResult, TEvent>: (args: { context: TContext; event: TExpressionEvent; self: ActorRef<MachineSnapshot<TContext, TEvent, Record<string, AnyActorRef>, StateValue, string, unknown>, TEvent> }) => TResult

Type parameters

• TContext: MachineContext
• TExpressionEvent: EventObject
• TResult
• TEvent: EventObject

Type declaration

• • (args: { context: TContext; event: TExpressionEvent; self: ActorRef<MachineSnapshot<TContext, TEvent, Record<string, AnyActorRef>, StateValue, string, unknown>, TEvent> }): TResult

  • Parameters

    • args: { context: TContext; event: TExpressionEvent; self: ActorRef<MachineSnapshot<TContext, TEvent, Record<string, AnyActorRef>, StateValue, string, unknown>, TEvent> }

    Returns TResult

MaybeLazy

MaybeLazy<T>: T | Lazy<T>

Type parameters

• T

Merge

Merge<M, N>: Omit<M, keyof N> & N

Type parameters

• M
• N

MetaObject

MetaObject: Record<string, any>

MissingImplementationsError

MissingImplementationsError<TResolvedTypesMeta, TMissingImplementations>: Compute<[Some implementations missing, Values<{ [ K in keyof TMissingImplementations ]: TMissingImplementations[K] }>]>

Type parameters

• TResolvedTypesMeta
• TMissingImplementations = Prop<Prop<TResolvedTypesMeta, resolved>, missingImplementations>

NoInfer

NoInfer<T>: [T][T extends any ? 0 : any]

Type parameters

• T

NoRequiredParams

NoRequiredParams<T>: T extends any ? undefined extends T[params] ? T[type] : never : never

Type parameters

• T: ParameterizedObject

NonReducibleUnknown

NonReducibleUnknown: {} | null | undefined

@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:

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.

ObservableActorLogic

ObservableActorLogic<TContext, TInput>: ActorLogic<ObservableSnapshot<TContext, TInput>, { type: string }, TInput, AnyActorSystem>

Type parameters

• TContext
• TInput: NonReducibleUnknown

ObservableSnapshot

ObservableSnapshot<TContext, TInput>: Snapshot<undefined> & { _subscription: Subscription | undefined; context: TContext | undefined; input: TInput | undefined }

Type parameters

• TContext
• TInput: NonReducibleUnknown

Observer

Observer<T>: { complete?: () => void; error?: (err: unknown) => void; next?: (value: T) => void }

Type parameters

• T

Type declaration

• optionalcomplete?: () => void

  • • (): void

    • Returns void

• optionalerror?: (err: unknown) => void

  • • (err: unknown): void

    • Parameters

      • err: unknown

      Returns void

• optionalnext?: (value: T) => void

  • • (value: T): void

    • Parameters

      • value: T

      Returns void

OutputFrom

OutputFrom<T>: T extends ActorLogic<infer TSnapshot, infer _TEvent, infer _TInput, infer _TSystem> ? TSnapshot & { status: done }[output] : never

Type parameters

• T

PartialAssigner

PartialAssigner<TContext, TExpressionEvent, TParams, TEvent, TActor, TKey>: (args: AssignArgs<TContext, TExpressionEvent, TEvent, TActor>, params: TParams) => TContext[TKey]

Type parameters

• TContext: MachineContext
• TExpressionEvent: EventObject
• TParams: ParameterizedObject[params] | undefined
• TEvent: EventObject
• TActor: ProvidedActor
• TKey: keyof TContext

Type declaration

• • (args: AssignArgs<TContext, TExpressionEvent, TEvent, TActor>, params: TParams): TContext[TKey]

  • Parameters

    • args: AssignArgs<TContext, TExpressionEvent, TEvent, TActor>

    • params: TParams

    Returns TContext[TKey]

PromiseActorLogic

PromiseActorLogic<TOutput, TInput>: ActorLogic<PromiseSnapshot<TOutput, TInput>, { type: string }, TInput, AnyActorSystem>

Type parameters

• TOutput
• TInput = unknown

PromiseSnapshot

PromiseSnapshot<TOutput, TInput>: Snapshot<TOutput> & { input: TInput | undefined }

Type parameters

• TOutput
• TInput

Prop

Prop<T, K>: K extends keyof T ? T[K] : never

Type parameters

• T
• K

PropertyAssigner

PropertyAssigner<TContext, TExpressionEvent, TParams, TEvent, TActor>: { [ K in keyof TContext ]?: PartialAssigner<TContext, TExpressionEvent, TParams, TEvent, TActor, K> | TContext[K] }

Type parameters

• TContext: MachineContext
• TExpressionEvent: EventObject
• TParams: ParameterizedObject[params] | undefined
• TEvent: EventObject
• TActor: ProvidedActor

RequiredActorOptions

RequiredActorOptions<TActor>: (undefined extends TActor[id] ? never : id) | (undefined extends InputFrom<TActor[logic]> ? never : input)

Type parameters

• TActor: ProvidedActor

SendExpr

SendExpr<TContext, TExpressionEvent, TParams, TSentEvent, TEvent>: (args: ActionArgs<TContext, TExpressionEvent, TEvent>, params: TParams) => TSentEvent

Type parameters

• TContext: MachineContext
• TExpressionEvent: EventObject
• TParams: ParameterizedObject[params] | undefined
• TSentEvent: EventObject
• TEvent: EventObject

Type declaration

• • (args: ActionArgs<TContext, TExpressionEvent, TEvent>, params: TParams): TSentEvent

  • Parameters

    • args: ActionArgs<TContext, TExpressionEvent, TEvent>

    • params: TParams

    Returns TSentEvent

SimpleOrStateNodeConfig

SimpleOrStateNodeConfig<TContext, TEvent>: AtomicStateNodeConfig<TContext, TEvent> | StateNodeConfig<TContext, TEvent, TODO, TODO, TODO, TODO, TODO, TODO>

Type parameters

• TContext: MachineContext
• TEvent: EventObject

SingleOrArray

SingleOrArray<T>: readonly T[] | T

Type parameters

• T

Snapshot

Snapshot<TOutput>: { error: undefined; output: undefined; status: active } | { error: undefined; output: TOutput; status: done } | { error: unknown; output: undefined; status: error } | { error: undefined; output: undefined; status: stopped }

Type parameters

• TOutput

SnapshotFrom

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

Type parameters

• T

Spawner

Spawner<TActor>: IsLiteralString<TActor[src]> extends true ? <TSrc>(logic: TSrc, ...[options = {} as any]: SpawnOptions<TActor, TSrc>) => ActorRefFrom<TActor & { src: TSrc }[logic]> : <TLogic>(src: TLogic, options?: { id?: string; input?: unknown; syncSnapshot?: boolean; systemId?: string }) => TLogic extends string ? AnyActorRef : ActorRefFrom<TLogic>

Type parameters

• TActor: ProvidedActor

StateFrom

StateFrom<T>: T extends AnyStateMachine ? ReturnType<T[transition]> : T extends (...args: any[]) => AnyStateMachine ? ReturnType<ReturnType<T>[transition]> : never

Type parameters

• T: AnyStateMachine | (...args: any[]) => AnyStateMachine

StateKey

StateKey: string | AnyMachineSnapshot

StateNodesConfig

StateNodesConfig<TContext, TEvent>: { [ K in string ]: StateNode<TContext, TEvent> }

Type parameters

• TContext: MachineContext
• TEvent: EventObject

StateSchema

StateSchema: { states?: Record<string, StateSchema> }

Type declaration

• optionalstates?: Record<string, StateSchema>

StateTypes

StateTypes: atomic | compound | parallel | final | history | string

StateValue

StateValue: string | StateValueMap

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" }.

StateValueFrom

StateValueFrom<TMachine>: Parameters<StateFrom<TMachine>[matches]>[0]

Type parameters

• TMachine: AnyStateMachine

StatesConfig

StatesConfig<TContext, TEvent, TActor, TAction, TGuard, TDelay, TTag, TOutput>: { [ K in string ]: StateNodeConfig<TContext, TEvent, TActor, TAction, TGuard, TDelay, TTag, TOutput> }

Type parameters

• TContext: MachineContext
• TEvent: EventObject
• TActor: ProvidedActor
• TAction: ParameterizedObject
• TGuard: ParameterizedObject
• TDelay: string
• TTag: string
• TOutput

StatesDefinition

StatesDefinition<TContext, TEvent>: { [ K in string ]: StateNodeDefinition<TContext, TEvent> }

Type parameters

• TContext: MachineContext
• TEvent: EventObject

TODO

TODO: any

TagsFrom

TagsFrom<TMachine>: Parameters<StateFrom<TMachine>[hasTag]>[0]

Type parameters

• TMachine: AnyStateMachine

ToChildren

ToChildren<TActor>: string extends TActor[src] ? Record<string, AnyActorRef> : Compute<ToConcreteChildren<TActor> & { exclude: {}; include: {} }[undefined extends TActor[id] ? include : string extends TActor[id] ? include : exclude]>

Type parameters

• TActor: ProvidedActor

TransitionActorLogic

TransitionActorLogic<TContext, TEvent, TInput>: ActorLogic<TransitionSnapshot<TContext>, TEvent, TInput, AnyActorSystem>

Type parameters

• TContext
• TEvent: EventObject
• TInput: NonReducibleUnknown

TransitionConfigOrTarget

TransitionConfigOrTarget<TContext, TExpressionEvent, TEvent, TActor, TAction, TGuard, TDelay>: SingleOrArray<TransitionConfigTarget | TransitionConfig<TContext, TExpressionEvent, TEvent, TActor, TAction, TGuard, TDelay>>

Type parameters

• TContext: MachineContext
• TExpressionEvent: EventObject
• TEvent: EventObject
• TActor: ProvidedActor
• TAction: ParameterizedObject
• TGuard: ParameterizedObject
• TDelay: string

TransitionConfigTarget

TransitionConfigTarget: string | undefined

TransitionDefinitionMap

TransitionDefinitionMap<TContext, TEvent>: { [ K in EventDescriptor<TEvent> ]: TransitionDefinition<TContext, ExtractEvent<TEvent, K>>[] }

Type parameters

• TContext: MachineContext
• TEvent: EventObject

TransitionSnapshot

TransitionSnapshot<TContext>: Snapshot<undefined> & { context: TContext }

Type parameters

• TContext

TransitionTarget

TransitionTarget: SingleOrArray<string>

Transitions

Transitions<TContext, TEvent>: TransitionDefinition<TContext, TEvent>[]

Type parameters

• TContext: MachineContext
• TEvent: EventObject

TransitionsConfig

TransitionsConfig<TContext, TEvent, TActor, TAction, TGuard, TDelay>: { [ K in EventDescriptor<TEvent> ]?: TransitionConfigOrTarget<TContext, ExtractEvent<TEvent, K>, TEvent, TActor, TAction, TGuard, TDelay> }

Type parameters

• TContext: MachineContext
• TEvent: EventObject
• TActor: ProvidedActor
• TAction: ParameterizedObject
• TGuard: ParameterizedObject
• TDelay: string

TypegenConstraint

TypegenConstraint: TypegenEnabled | TypegenDisabled

UnknownAction

UnknownAction: Action<MachineContext, EventObject, EventObject, ParameterizedObject[params] | undefined, ProvidedActor, ParameterizedObject, ParameterizedObject, string>

UnknownActorLogic

UnknownActorLogic: ActorLogic<any, any, never, AnyActorSystem>

Values

Values<T>: T[keyof T]

Type parameters

• T

WithDynamicParams

WithDynamicParams<TContext, TExpressionEvent, T>: T extends any ? ConditionalRequired<{ params?: T[params] | ({ context, event }: { context: TContext; event: TExpressionEvent }) => T[params]; type: T[type] }, undefined extends T[params] ? false : true> : never

Type parameters

• TContext: MachineContext
• TExpressionEvent: EventObject
• T: ParameterizedObject

__ResolvedTypesMetaFrom

__ResolvedTypesMetaFrom<T>: T extends StateMachine<any, any, any, any, any, any, any, any, any, any, infer TResolvedTypesMeta> ? TResolvedTypesMeta : never

Type parameters

• T