xstate 4.20.0 → 4.23.0

package/es/interpreter.js

@@ -1,6 +1,6 @@
 import { __values, __assign, __spreadArray, __read } from './_virtual/_tslib.js';
 import { IS_PRODUCTION } from './environment.js';
-import { warn, mapContext, isFunction, keys, toSCXMLEvent, toInvokeSource, isPromiseLike, isObservable, isMachine, reportUnhandledExceptionOnInvocation, symbolObservable, isArray, toEventObject, isString, isActor, uniqueId, toObserver } from './utils.js';
+import { warn, mapContext, isFunction, keys, toSCXMLEvent, toInvokeSource, isMachine, isPromiseLike, isObservable, isBehavior, reportUnhandledExceptionOnInvocation, symbolObservable, isArray, toEventObject, isString, isActor, uniqueId, toObserver } from './utils.js';
 import { ActionTypes, SpecialTargets } from './types.js';
 import { isInFinalState } from './stateUtils.js';
 import { errorPlatform, log, stop, start, cancel, send, update, error as error$1 } from './actionTypes.js';
@@ -11,6 +11,8 @@ import { isSpawnedActor, createDeferredActor } from './Actor.js';
 import { Scheduler } from './scheduler.js';
 import { registry } from './registry.js';
 import { registerService, getGlobal } from './devTools.js';
+import { spawnBehavior } from './behaviors.js';
+
 var DEFAULT_SPAWN_OPTIONS = {
   sync: false,
   autoForward: false
@@ -830,24 +832,32 @@ function () {
             }
 
             var resolvedData = data ? mapContext(data, context, _event) : undefined;
+
+            if (typeof serviceCreator === 'string') {
+              // TODO: warn
+              return;
+            }
+
             var source = isFunction(serviceCreator) ? serviceCreator(context, _event.data, {
               data: resolvedData,
               src: invokeSource
             }) : serviceCreator;
 
-            if (isPromiseLike(source)) {
-              this.spawnPromise(Promise.resolve(source), id);
-            } else if (isFunction(source)) {
-              this.spawnCallback(source, id);
-            } else if (isObservable(source)) {
-              this.spawnObservable(source, id);
-            } else if (isMachine(source)) {
-              // TODO: try/catch here
-              this.spawnMachine(resolvedData ? source.withContext(resolvedData) : source, {
-                id: id,
+            if (!source) {
+              // TODO: warn?
+              return;
+            }
+
+            var options = void 0;
+
+            if (isMachine(source)) {
+              source = resolvedData ? source.withContext(resolvedData) : source;
+              options = {
                 autoForward: autoForward
-              });
-            } else ;
+              };
+            }
+
+            this.spawn(source, id, options);
           } else {
             this.spawnActivity(activity);
           }
@@ -910,13 +920,15 @@ function () {
     } else if (isFunction(entity)) {
       return this.spawnCallback(entity, name);
     } else if (isSpawnedActor(entity)) {
-      return this.spawnActor(entity);
+      return this.spawnActor(entity, name);
     } else if (isObservable(entity)) {
       return this.spawnObservable(entity, name);
     } else if (isMachine(entity)) {
       return this.spawnMachine(entity, __assign(__assign({}, options), {
         id: name
       }));
+    } else if (isBehavior(entity)) {
+      return this.spawnBehavior(entity, name);
     } else {
       throw new Error("Unable to spawn entity \"" + name + "\" of type \"" + typeof entity + "\".");
     }
@@ -962,11 +974,20 @@ function () {
     return actor;
   };
 
+  Interpreter.prototype.spawnBehavior = function (behavior, id) {
+    var actorRef = spawnBehavior(behavior, {
+      id: id,
+      parent: this
+    });
+    this.children.set(id, actorRef);
+    return actorRef;
+  };
+
   Interpreter.prototype.spawnPromise = function (promise, id) {
     var _this = this;
 
     var canceled = false;
-    var resolvedData = undefined;
+    var resolvedData;
     promise.then(function (response) {
       if (!canceled) {
         resolvedData = response;
@@ -1060,7 +1081,7 @@ function () {
     var canceled = false;
     var receivers = new Set();
     var listeners = new Set();
-    var emitted = undefined;
+    var emitted;
 
     var receive = function (e) {
       emitted = e;
@@ -1131,7 +1152,7 @@ function () {
   Interpreter.prototype.spawnObservable = function (source, id) {
     var _this = this;
 
-    var emitted = undefined;
+    var emitted;
     var subscription = source.subscribe(function (value) {
       emitted = value;
 
@@ -1175,8 +1196,8 @@ function () {
     return actor;
   };
 
-  Interpreter.prototype.spawnActor = function (actor) {
-    this.children.set(actor.id, actor);
+  Interpreter.prototype.spawnActor = function (actor, name) {
+    this.children.set(name, actor);
     return actor;
   };
 
@@ -1260,9 +1281,15 @@ function () {
 
   Interpreter.prototype[symbolObservable] = function () {
     return this;
-  };
+  }; // this gets stripped by Babel to avoid having "undefined" property in environments without this non-standard Symbol
+  // it has to be here to be included in the generated .d.ts
+
 
   Interpreter.prototype.getSnapshot = function () {
+    if (this.status === InterpreterStatus.NotStarted) {
+      return this.initialState;
+    }
+
     return this._state;
   };
   /**
@@ -1328,10 +1355,9 @@ function spawn(entity, nameOrOptions) {
  * @param options Interpreter options
  */
 
-
 function interpret(machine, options) {
   var interpreter = new Interpreter(machine, options);
   return interpreter;
 }
 
-export { Interpreter, InterpreterStatus, interpret, spawn };
+export { Interpreter, InterpreterStatus, interpret, spawn };

package/es/invokeUtils.js

@@ -1,6 +1,8 @@
 import { __assign, __rest } from './_virtual/_tslib.js';
+import './environment.js';
+import './utils.js';
+import './types.js';
 import { invoke } from './actionTypes.js';
-import './actions.js';
 
 function toInvokeSource(src) {
   if (typeof src === 'string') {
@@ -18,7 +20,6 @@ function toInvokeSource(src) {
 
   return src;
 }
-
 function toInvokeDefinition(invokeConfig) {
   return __assign(__assign({
     type: invoke
@@ -36,4 +37,4 @@ function toInvokeDefinition(invokeConfig) {
   });
 }
 
-export { toInvokeDefinition, toInvokeSource };
+export { toInvokeDefinition, toInvokeSource };

package/es/mapState.js

@@ -29,4 +29,4 @@ function mapState(stateMap, stateId) {
   return stateMap[foundStateId];
 }
 
-export { mapState };
+export { mapState };

package/es/match.js

@@ -31,4 +31,4 @@ function matchState(state, patterns, defaultValue) {
   return defaultValue(resolvedState);
 }
 
-export { matchState };
+export { matchState };

package/es/model.d.ts

@@ -1,39 +1,5 @@
-import type { AssignAction, Assigner, PropertyAssigner, ExtractEvent, EventObject } from './types';
-declare type AnyFunction = (...args: any[]) => any;
-declare type Cast<A1 extends any, A2 extends any> = A1 extends A2 ? A1 : A2;
-declare type Compute<A extends any> = {
-    [K in keyof A]: A[K];
-} & unknown;
-declare type Prop<T, K> = K extends keyof T ? T[K] : never;
-export interface Model<TContext, TEvent extends EventObject, TModelCreators = void> {
-    initialContext: TContext;
-    assign: <TEventType extends TEvent['type'] = TEvent['type']>(assigner: Assigner<TContext, ExtractEvent<TEvent, TEventType>> | PropertyAssigner<TContext, ExtractEvent<TEvent, TEventType>>, eventType?: TEventType) => AssignAction<TContext, ExtractEvent<TEvent, TEventType>>;
-    events: Prop<TModelCreators, 'events'>;
-    reset: () => AssignAction<TContext, any>;
-}
-export declare type ModelContextFrom<TModel extends Model<any, any, any>> = TModel extends Model<infer TContext, any, any> ? TContext : never;
-export declare type ModelEventsFrom<TModel extends Model<any, any, any>> = TModel extends Model<any, infer TEvent, any> ? TEvent : never;
-declare type EventCreator<Self extends AnyFunction, Return = ReturnType<Self>> = Return extends object ? Return extends {
-    type: any;
-} ? "An event creator can't return an object with a type property" : Self : 'An event creator must return an object';
-declare type EventCreators<Self> = {
-    [K in keyof Self]: Self[K] extends AnyFunction ? EventCreator<Self[K]> : 'An event creator must be a function';
-};
-declare type ModelCreators<Self> = {
-    events: EventCreators<Prop<Self, 'events'>>;
-};
-declare type FinalEventCreators<Self> = {
-    [K in keyof Self]: Self[K] extends AnyFunction ? (...args: Parameters<Self[K]>) => Compute<ReturnType<Self[K]> & {
-        type: K;
-    }> : never;
-};
-declare type FinalModelCreators<Self> = {
-    events: FinalEventCreators<Prop<Self, 'events'>>;
-};
-declare type EventFromEventCreators<EventCreators> = {
-    [K in keyof EventCreators]: EventCreators[K] extends AnyFunction ? ReturnType<EventCreators[K]> : never;
-}[keyof EventCreators];
+import type { EventObject } from './types';
+import { Cast, EventFromEventCreators, FinalModelCreators, Model, ModelCreators, Prop } from './model.types';
 export declare function createModel<TContext, TEvent extends EventObject>(initialContext: TContext): Model<TContext, TEvent, void>;
 export declare function createModel<TContext, TModelCreators extends ModelCreators<TModelCreators>, TFinalModelCreators = FinalModelCreators<TModelCreators>>(initialContext: TContext, creators: TModelCreators): Model<TContext, Cast<EventFromEventCreators<Prop<TFinalModelCreators, 'events'>>, EventObject>, TFinalModelCreators>;
-export {};
 //# sourceMappingURL=model.d.ts.map

package/es/model.types.d.ts

@@ -0,0 +1,37 @@
+import { EventObject, Assigner, ExtractEvent, PropertyAssigner, AssignAction, MachineConfig, MachineOptions, StateMachine } from './types';
+export declare type AnyFunction = (...args: any[]) => any;
+export declare type Cast<A1 extends any, A2 extends any> = A1 extends A2 ? A1 : A2;
+export declare type Compute<A extends any> = {
+    [K in keyof A]: A[K];
+} & unknown;
+export declare type Prop<T, K> = K extends keyof T ? T[K] : never;
+export interface Model<TContext, TEvent extends EventObject, TModelCreators = void> {
+    initialContext: TContext;
+    assign: <TEventType extends TEvent['type'] = TEvent['type']>(assigner: Assigner<TContext, ExtractEvent<TEvent, TEventType>> | PropertyAssigner<TContext, ExtractEvent<TEvent, TEventType>>, eventType?: TEventType) => AssignAction<TContext, ExtractEvent<TEvent, TEventType>>;
+    events: Prop<TModelCreators, 'events'>;
+    reset: () => AssignAction<TContext, any>;
+    createMachine: (config: MachineConfig<TContext, any, TEvent>, implementations?: Partial<MachineOptions<TContext, TEvent>>) => StateMachine<TContext, any, TEvent, any>;
+}
+export declare type ModelContextFrom<TModel extends Model<any, any, any>> = TModel extends Model<infer TContext, any, any> ? TContext : never;
+export declare type ModelEventsFrom<TModel extends Model<any, any, any>> = TModel extends Model<any, infer TEvent, any> ? TEvent : never;
+export declare type EventCreator<Self extends AnyFunction, Return = ReturnType<Self>> = Return extends object ? Return extends {
+    type: any;
+} ? "An event creator can't return an object with a type property" : Self : 'An event creator must return an object';
+export declare type EventCreators<Self> = {
+    [K in keyof Self]: Self[K] extends AnyFunction ? EventCreator<Self[K]> : 'An event creator must be a function';
+};
+export declare type ModelCreators<Self> = {
+    events: EventCreators<Prop<Self, 'events'>>;
+};
+export declare type FinalEventCreators<Self> = {
+    [K in keyof Self]: Self[K] extends AnyFunction ? (...args: Parameters<Self[K]>) => Compute<ReturnType<Self[K]> & {
+        type: K;
+    }> : never;
+};
+export declare type FinalModelCreators<Self> = {
+    events: FinalEventCreators<Prop<Self, 'events'>>;
+};
+export declare type EventFromEventCreators<EventCreators> = {
+    [K in keyof EventCreators]: EventCreators[K] extends AnyFunction ? ReturnType<EventCreators[K]> : never;
+}[keyof EventCreators];
+//# sourceMappingURL=model.types.d.ts.map

package/es/registry.js

@@ -15,4 +15,5 @@ var registry = {
     children.delete(id);
   }
 };
-export { registry };
+
+export { registry };

package/es/scheduler.js

@@ -1,4 +1,5 @@
 import { __assign } from './_virtual/_tslib.js';
+
 var defaultOptions = {
   deferEvents: false
 };
@@ -75,4 +76,4 @@ function () {
   return Scheduler;
 }();
 
-export { Scheduler };
+export { Scheduler };

package/es/schema.js

@@ -2,4 +2,4 @@ function createSchema(schema) {
   return schema;
 }
 
-export { createSchema };
+export { createSchema };

package/es/serviceScope.js

@@ -3,16 +3,14 @@
  * This is used to provide the correct service to spawn().
  */
 var serviceStack = [];
-
 var provide = function (service, fn) {
   serviceStack.push(service);
   var result = fn(service);
   serviceStack.pop();
   return result;
 };
-
 var consume = function (fn) {
   return fn(serviceStack[serviceStack.length - 1]);
 };
 
-export { consume, provide };
+export { consume, provide };

package/es/stateUtils.d.ts

@@ -10,5 +10,6 @@ export declare function getValue<TC, TE extends EventObject>(rootNode: StateNode
 export declare function has<T>(iterable: Iterable<T>, item: T): boolean;
 export declare function nextEvents<TC, TE extends EventObject>(configuration: Array<StateNode<TC, any, TE>>): Array<TE['type']>;
 export declare function isInFinalState<TC, TE extends EventObject>(configuration: Array<StateNode<TC, any, TE, any>>, stateNode: StateNode<TC, any, TE, any>): boolean;
+export declare function getMeta(configuration?: StateNode[]): Record<string, any>;
 export {};
 //# sourceMappingURL=stateUtils.d.ts.map

package/es/stateUtils.js

@@ -4,13 +4,11 @@ import { keys, flatten } from './utils.js';
 var isLeafNode = function (stateNode) {
   return stateNode.type === 'atomic' || stateNode.type === 'final';
 };
-
 function getChildren(stateNode) {
   return keys(stateNode.states).map(function (key) {
     return stateNode.states[key];
   });
 }
-
 function getAllStateNodes(stateNode) {
   var stateNodes = [stateNode];
 
@@ -20,7 +18,6 @@ function getAllStateNodes(stateNode) {
 
   return stateNodes.concat(flatten(getChildren(stateNode).map(getAllStateNodes)));
 }
-
 function getConfiguration(prevStateNodes, stateNodes) {
   var e_1, _a, e_2, _b, e_3, _c, e_4, _d;
 
@@ -205,12 +202,10 @@ function getAdjList(configuration) {
 
   return adjList;
 }
-
 function getValue(rootNode, configuration) {
   var config = getConfiguration([rootNode], configuration);
   return getValueFromAdj(rootNode, getAdjList(config));
 }
-
 function has(iterable, item) {
   if (Array.isArray(iterable)) {
     return iterable.some(function (member) {
@@ -224,13 +219,11 @@ function has(iterable, item) {
 
   return false; // TODO: fix
 }
-
 function nextEvents(configuration) {
   return __spreadArray([], __read(new Set(flatten(__spreadArray([], __read(configuration.map(function (sn) {
     return sn.ownEvents;
   })))))));
 }
-
 function isInFinalState(configuration, stateNode) {
   if (stateNode.type === 'compound') {
     return getChildren(stateNode).some(function (s) {
@@ -246,5 +239,18 @@ function isInFinalState(configuration, stateNode) {
 
   return false;
 }
+function getMeta(configuration) {
+  if (configuration === void 0) {
+    configuration = [];
+  }
+
+  return configuration.reduce(function (acc, stateNode) {
+    if (stateNode.meta !== undefined) {
+      acc[stateNode.id] = stateNode.meta;
+    }
+
+    return acc;
+  }, {});
+}
 
-export { getAdjList, getAllStateNodes, getChildren, getConfiguration, getValue, has, isInFinalState, isLeafNode, nextEvents };
+export { getAdjList, getAllStateNodes, getChildren, getConfiguration, getMeta, getValue, has, isInFinalState, isLeafNode, nextEvents };

package/es/types.d.ts

@@ -1,6 +1,7 @@
 import { StateNode } from './StateNode';
 import { State } from './State';
 import { Interpreter, Clock } from './interpreter';
+import { Model } from './model.types';
 export declare type EventType = string;
 export declare type ActionType = string;
 export declare type MetaObject = Record<string, any>;
@@ -134,7 +135,7 @@ export interface PayloadSender<TEvent extends EventObject> {
     <K extends TEvent['type']>(eventType: K, payload: NeverIfEmpty<ExtractExtraParameters<TEvent, K>>): void;
 }
 export declare type Receiver<TEvent extends EventObject> = (listener: (event: TEvent) => void) => void;
-export declare type InvokeCallback<TEvent extends EventObject = AnyEventObject> = (callback: Sender<TEvent>, onReceive: Receiver<TEvent>) => any;
+export declare type InvokeCallback<TEvent extends EventObject = AnyEventObject, TSentEvent extends EventObject = AnyEventObject> = (callback: Sender<TSentEvent>, onReceive: Receiver<TEvent>) => (() => void) | Promise<any> | void;
 export interface InvokeMeta {
     data: any;
     src: InvokeSourceDefinition;
@@ -152,7 +153,7 @@ export interface InvokeMeta {
  * @param context The current machine `context`
  * @param event The event that invoked the service
  */
-export declare type InvokeCreator<TContext, TEvent extends EventObject = AnyEventObject, TFinalContext = any> = (context: TContext, event: TEvent, meta: InvokeMeta) => PromiseLike<TFinalContext> | StateMachine<TFinalContext, any, any> | Subscribable<EventObject> | InvokeCallback<TEvent>;
+export declare type InvokeCreator<TContext, TEvent extends EventObject, TFinalContext = any> = (context: TContext, event: TEvent, meta: InvokeMeta) => PromiseLike<TFinalContext> | StateMachine<TFinalContext, any, any> | Subscribable<EventObject> | InvokeCallback<any, TEvent> | Behavior<any>;
 export interface InvokeDefinition<TContext, TEvent extends EventObject> extends ActivityDefinition<TContext, TEvent> {
     /**
      * The source of the machine to be invoked, or the machine itself.
@@ -384,6 +385,13 @@ export interface StateNodeConfig<TContext, TStateSchema extends StateSchema, TEv
      * The tags for this state node, which are accumulated into the `state.tags` property.
      */
     tags?: SingleOrArray<string>;
+    /**
+     * Whether actions should be called in order.
+     * When `false` (default), `assign(...)` actions are prioritized before other actions.
+     *
+     * @default false
+     */
+    preserveActionOrder?: boolean;
 }
 export interface StateNodeDefinition<TContext, TStateSchema extends StateSchema, TEvent extends EventObject> {
     id: string;
@@ -875,29 +883,47 @@ export interface Subscription {
     unsubscribe(): void;
 }
 export interface Subscribable<T> {
-    subscribe(observer: Observer<T>): Subscription;
     subscribe(next: (value: T) => void, error?: (error: any) => void, complete?: () => void): Subscription;
+    subscribe(observer: Observer<T>): Subscription;
 }
-export declare type Spawnable = StateMachine<any, any, any> | Promise<any> | InvokeCallback | Subscribable<any>;
+export declare type Spawnable = StateMachine<any, any, any> | PromiseLike<any> | InvokeCallback | Subscribable<any> | Behavior<any>;
 export declare type ExtractEvent<TEvent extends EventObject, TEventType extends TEvent['type']> = TEvent extends {
     type: TEventType;
 } ? TEvent : never;
+export interface BaseActorRef<TEvent extends EventObject> {
+    send: (event: TEvent) => void;
+}
 export interface ActorRef<TEvent extends EventObject, TEmitted = any> extends Subscribable<TEmitted> {
     send: Sender<TEvent>;
-}
-export interface SpawnedActorRef<TEvent extends EventObject, TEmitted = any> extends ActorRef<TEvent, TEmitted> {
     id: string;
     getSnapshot: () => TEmitted | undefined;
     stop?: () => void;
     toJSON?: () => any;
 }
-export declare type ActorRefFrom<T extends StateMachine<any, any, any> | Promise<any>> = T extends StateMachine<infer TContext, any, infer TEvent, infer TTypestate> ? SpawnedActorRef<TEvent, State<TContext, TEvent, any, TTypestate>> & {
+/**
+ * @deprecated Use `ActorRef` instead.
+ */
+export declare type SpawnedActorRef<TEvent extends EventObject, TEmitted = any> = ActorRef<TEvent, TEmitted>;
+export declare type ActorRefFrom<T extends StateMachine<any, any, any> | Promise<any> | Behavior<any>> = T extends StateMachine<infer TContext, any, infer TEvent, infer TTypestate> ? ActorRef<TEvent, State<TContext, TEvent, any, TTypestate>> & {
     /**
-     * @deprecated
+     * @deprecated Use `.getSnapshot()` instead.
      */
     state: State<TContext, TEvent, any, TTypestate>;
-} : T extends Promise<infer U> ? SpawnedActorRef<never, U> : never;
+} : T extends Promise<infer U> ? ActorRef<never, U> : T extends Behavior<infer TEvent1, infer TEmitted> ? ActorRef<TEvent1, TEmitted> : never;
 export declare type AnyInterpreter = Interpreter<any, any, any, any>;
 export declare type InterpreterFrom<T extends StateMachine<any, any, any, any>> = T extends StateMachine<infer TContext, infer TStateSchema, infer TEvent, infer TTypestate> ? Interpreter<TContext, TStateSchema, TEvent, TTypestate> : never;
+export interface ActorContext<TEvent extends EventObject, TEmitted> {
+    parent?: ActorRef<any, any>;
+    self: ActorRef<TEvent, TEmitted>;
+    id: string;
+    observers: Set<Observer<TEmitted>>;
+}
+export interface Behavior<TEvent extends EventObject, TEmitted = any> {
+    transition: (state: TEmitted, event: TEvent, actorCtx: ActorContext<TEvent, TEmitted>) => TEmitted;
+    initialState: TEmitted;
+    start?: (actorCtx: ActorContext<TEvent, TEmitted>) => TEmitted;
+}
+export declare type EventFrom<T> = T extends StateMachine<any, any, infer TEvent, any> ? TEvent : T extends Model<any, infer TEvent, any> ? TEvent : T extends State<any, infer TEvent, any, any> ? TEvent : T extends Interpreter<any, any, infer TEvent, any> ? TEvent : never;
+export declare type ContextFrom<T> = T extends StateMachine<infer TContext, any, any, any> ? TContext : T extends Model<infer TContext, any, any> ? TContext : T extends State<infer TContext, any, any, any> ? TContext : T extends Interpreter<infer TContext, any, any, any> ? TContext : never;
 export {};
 //# sourceMappingURL=types.d.ts.map

package/es/types.js

@@ -30,4 +30,4 @@ var SpecialTargets;
   SpecialTargets["Internal"] = "#_internal";
 })(SpecialTargets || (SpecialTargets = {}));
 
-export { ActionTypes, SpecialTargets };
+export { ActionTypes, SpecialTargets };

package/es/utils.d.ts

@@ -1,6 +1,6 @@
-import { Event, StateValue, ActionType, Action, EventObject, PropertyMapper, Mapper, EventType, HistoryValue, AssignAction, Condition, Subscribable, StateMachine, ConditionPredicate, SCXML, StateLike, EventData, TransitionConfig, TransitionConfigTarget, NullEvent, SingleOrArray, Guard, InvokeSourceDefinition } from './types';
+import { Event, StateValue, ActionType, Action, EventObject, PropertyMapper, Mapper, EventType, HistoryValue, AssignAction, Condition, Subscribable, StateMachine, ConditionPredicate, SCXML, StateLike, EventData, TransitionConfig, TransitionConfigTarget, NullEvent, SingleOrArray, Guard, InvokeSourceDefinition, Observer, Behavior } from './types';
 import { StateNode } from './StateNode';
-import { Observer, State } from '.';
+import { State } from './State';
 import { Actor } from './Actor';
 export declare function keys<T extends object>(value: T): Array<keyof T & string>;
 export declare function matchesState(parentStateId: StateValue, childStateId: StateValue, delimiter?: string): boolean;
@@ -40,6 +40,7 @@ export declare function toArray<T>(value: T[] | T | undefined): T[];
 export declare function mapContext<TContext, TEvent extends EventObject>(mapper: Mapper<TContext, TEvent, any> | PropertyMapper<TContext, TEvent, any>, context: TContext, _event: SCXML.Event<TEvent>): any;
 export declare function isBuiltInEvent(eventType: EventType): boolean;
 export declare function isPromiseLike(value: any): value is PromiseLike<any>;
+export declare function isBehavior(value: any): value is Behavior<any, any>;
 export declare function partition<T, A extends T, B extends T>(items: T[], predicate: (item: T) => item is A): [A[], B[]];
 export declare function updateHistoryStates(hist: HistoryValue, stateValue: StateValue): Record<string, HistoryValue | undefined>;
 export declare function updateHistoryValue(hist: HistoryValue, stateValue: StateValue): HistoryValue;