xstate 3.2.1 → 3.3.3

package/es/graph.d.ts

@@ -1,9 +1,12 @@
 import { StateNode } from './index';
 import { Machine, Edge, PathMap, PathItem, PathsItem, PathsMap, AdjacencyMap } from './types';
 export declare function getNodes(node: StateNode): StateNode[];
-export declare function getEdges(node: StateNode): Edge[];
-export declare function getAdjacencyMap(node: Machine): AdjacencyMap;
-export declare function getShortestPaths(machine: Machine): PathMap;
-export declare function getShortestPathsAsArray(machine: Machine): PathItem[];
-export declare function getSimplePaths(machine: Machine): PathsMap;
-export declare function getSimplePathsAsArray(machine: Machine): PathsItem[];
+export declare function getEventEdges(node: StateNode, event: string): Edge[];
+export declare function getEdges(node: StateNode, options?: {
+    deep: boolean;
+}): Edge[];
+export declare function getAdjacencyMap(node: Machine, extendedState?: any): AdjacencyMap;
+export declare function getShortestPaths(machine: Machine, extendedState?: any): PathMap;
+export declare function getShortestPathsAsArray(machine: Machine, extendedState?: any): PathItem[];
+export declare function getSimplePaths(machine: Machine, extendedState?: any): PathsMap;
+export declare function getSimplePathsAsArray(machine: Machine, extendedState?: any): PathsItem[];

package/es/graph.js

@@ -1,4 +1,4 @@
-import { toStateValue, getActionType } from './utils';
+import { toStateValue, getActionType, flatMap } from './utils';
 var EMPTY_MAP = {};
 export function getNodes(node) {
     var states = node.states;
@@ -10,21 +10,28 @@ export function getNodes(node) {
     }, []);
     return nodes;
 }
-function getEventEdges(node, event) {
+export function getEventEdges(node, event) {
     var transitions = node.on[event];
-    return transitions.map(function (transition) {
-        return {
-            source: node,
-            target: node.parent.getState(transition.target),
-            event: event,
-            actions: transition.actions ? transition.actions.map(getActionType) : [],
-            cond: transition.cond
-        };
-    });
+    return flatMap(transitions.map(function (transition) {
+        var targets = [].concat(transition.target);
+        return targets.map(function (target) {
+            var targetNode = node.getRelativeStateNodes(target, undefined, false)[0];
+            return {
+                source: node,
+                target: targetNode,
+                event: event,
+                actions: transition.actions
+                    ? transition.actions.map(getActionType)
+                    : [],
+                cond: transition.cond
+            };
+        });
+    }));
 }
-export function getEdges(node) {
+export function getEdges(node, options) {
+    var _a = (options || {}).deep, deep = _a === void 0 ? true : _a;
     var edges = [];
-    if (node.states) {
+    if (node.states && deep) {
         Object.keys(node.states).forEach(function (stateKey) {
             edges.push.apply(edges, getEdges(node.states[stateKey]));
         });
@@ -34,7 +41,7 @@ export function getEdges(node) {
     });
     return edges;
 }
-export function getAdjacencyMap(node) {
+export function getAdjacencyMap(node, extendedState) {
     var adjacency = {};
     var events = node.events;
     function findAdjacencies(stateValue) {
@@ -45,7 +52,7 @@ export function getAdjacencyMap(node) {
         adjacency[stateKey] = {};
         for (var _i = 0, events_1 = events; _i < events_1.length; _i++) {
             var event_1 = events_1[_i];
-            var nextState = node.transition(stateValue, event_1);
+            var nextState = node.transition(stateValue, event_1, extendedState);
             adjacency[stateKey][event_1] = { state: nextState.value };
             findAdjacencies(nextState.value);
         }
@@ -53,11 +60,12 @@ export function getAdjacencyMap(node) {
     findAdjacencies(node.initialState.value);
     return adjacency;
 }
-export function getShortestPaths(machine) {
+export function getShortestPaths(machine, extendedState) {
+    var _a;
     if (!machine.states) {
         return EMPTY_MAP;
     }
-    var adjacency = getAdjacencyMap(machine);
+    var adjacency = getAdjacencyMap(machine, extendedState);
     var initialStateId = JSON.stringify(machine.initialState.value);
     var pathMap = (_a = {},
         _a[initialStateId] = [],
@@ -97,20 +105,19 @@ export function getShortestPaths(machine) {
     }
     util(machine.initialState.value);
     return pathMap;
-    var _a;
 }
-export function getShortestPathsAsArray(machine) {
-    var result = getShortestPaths(machine);
+export function getShortestPathsAsArray(machine, extendedState) {
+    var result = getShortestPaths(machine, extendedState);
     return Object.keys(result).map(function (key) { return ({
         state: JSON.parse(key),
         path: result[key]
     }); });
 }
-export function getSimplePaths(machine) {
+export function getSimplePaths(machine, extendedState) {
     if (!machine.states) {
         return EMPTY_MAP;
     }
-    var adjacency = getAdjacencyMap(machine);
+    var adjacency = getAdjacencyMap(machine, extendedState);
     var visited = new Set();
     var path = [];
     var paths = {};
@@ -143,8 +150,8 @@ export function getSimplePaths(machine) {
     });
     return paths;
 }
-export function getSimplePathsAsArray(machine) {
-    var result = getSimplePaths(machine);
+export function getSimplePathsAsArray(machine, extendedState) {
+    var result = getSimplePaths(machine, extendedState);
     return Object.keys(result).map(function (key) { return ({
         state: JSON.parse(key),
         paths: result[key]

package/es/patterns.js

@@ -1,4 +1,5 @@
 export function toggle(onState, offState, eventType) {
+    var _a, _b, _c;
     return _a = {},
         _a[onState] = {
             on: (_b = {}, _b[eventType] = offState, _b)
@@ -7,5 +8,4 @@ export function toggle(onState, offState, eventType) {
             on: (_c = {}, _c[eventType] = onState, _c)
         },
         _a;
-    var _a, _b, _c;
 }

package/es/scxml.d.ts

@@ -1,7 +1,8 @@
 import { Machine, EventObject } from './types';
 export declare function fromMachine(machine: Machine): string;
 export interface ScxmlToMachineOptions {
-    evalCond: (expr: string) => ((extState: any, event: EventObject) => boolean) | Function;
+    evalCond: (expr: string) => // tslint:disable-next-line:ban-types
+    ((extState: any, event: EventObject) => boolean) | Function;
     delimiter?: string;
 }
 export declare function toMachine(xml: string, options: ScxmlToMachineOptions): any;

package/es/scxml.js

@@ -73,10 +73,9 @@ function stateNodeToSCXML(stateNode) {
                     return {
                         type: 'element',
                         name: 'transition',
-                        attributes: __assign({}, event ? { event: event } : undefined, { target: stateNode.parent.getState(targetTransition.target)
-                                .id }, targetTransition.cond
+                        attributes: __assign({}, (event ? { event: event } : undefined), { target: stateNode.parent.getRelativeStateNodes(targetTransition.target)[0].id }, (targetTransition.cond
                             ? { cond: targetTransition.cond.toString() }
-                            : undefined),
+                            : undefined)),
                         elements: targetTransition.actions
                             ? targetTransition.actions.map(function (action) { return ({
                                 type: 'element',
@@ -94,9 +93,10 @@ function stateNodeToSCXML(stateNode) {
                 return {
                     type: 'element',
                     name: 'transition',
-                    attributes: __assign({}, event ? { event: event } : undefined, { target: stateNode.parent.getState(target).id }, targetTransition.cond
+                    attributes: __assign({}, (event ? { event: event } : undefined), { target: stateNode.parent.getRelativeStateNodes(target)[0]
+                            .id }, (targetTransition.cond
                         ? { cond: targetTransition.cond.toString() }
-                        : undefined),
+                        : undefined)),
                     elements: targetTransition.actions
                         ? targetTransition.actions.map(function (action) { return ({
                             type: 'element',
@@ -169,8 +169,31 @@ function toConfig(nodeJson, id, options) {
     var initial = parallel ? undefined : nodeJson.attributes.initial;
     var states;
     var on;
+    var elements = nodeJson.elements;
+    switch (nodeJson.name) {
+        case 'history': {
+            if (!elements) {
+                return {
+                    id: id,
+                    history: nodeJson.attributes.type || 'shallow'
+                };
+            }
+            var transitionElement = elements.filter(function (element) { return element.name === 'transition'; })[0];
+            return {
+                id: id,
+                history: nodeJson.attributes.type || 'shallow',
+                target: "#" + transitionElement.attributes.target
+            };
+        }
+        default:
+            break;
+    }
     if (nodeJson.elements) {
-        var stateElements = nodeJson.elements.filter(function (element) { return element.name === 'state' || element.name === 'parallel'; });
+        var stateElements = nodeJson.elements.filter(function (element) {
+            return element.name === 'state' ||
+                element.name === 'parallel' ||
+                element.name === 'history';
+        });
         var transitionElements = nodeJson.elements.filter(function (element) { return element.name === 'transition'; });
         var onEntryElement = nodeJson.elements.find(function (element) { return element.name === 'onentry'; });
         var onExitElement = nodeJson.elements.find(function (element) { return element.name === 'onexit'; });
@@ -182,11 +205,11 @@ function toConfig(nodeJson, id, options) {
         }
         states = indexedRecord(stateElements, function (item) { return "" + item.attributes.id; });
         on = mapValues(indexedAggregateRecord(transitionElements, function (item) { return item.attributes.event || ''; }), function (values) {
-            return values.map(function (value) { return (__assign({ target: "#" + value.attributes.target }, value.elements ? executableContent(value.elements) : undefined, value.attributes.cond
+            return values.map(function (value) { return (__assign({ target: "#" + value.attributes.target }, (value.elements ? executableContent(value.elements) : undefined), (value.attributes.cond
                 ? {
                     cond: evalCond(value.attributes.cond)
                 }
-                : undefined)); });
+                : undefined))); });
         });
         var onEntry = onEntryElement
             ? onEntryElement.elements.map(function (element) {
@@ -208,13 +231,13 @@ function toConfig(nodeJson, id, options) {
                 }
             })
             : undefined;
-        return __assign({ id: id, delimiter: options.delimiter }, initial ? { initial: initial } : undefined, parallel ? { parallel: parallel } : undefined, stateElements.length
+        return __assign({ id: id, delimiter: options.delimiter }, (initial ? { initial: initial } : undefined), (parallel ? { parallel: parallel } : undefined), (stateElements.length
             ? {
                 states: mapValues(states, function (state, key) {
                     return toConfig(state, key, options);
                 })
             }
-            : undefined, transitionElements.length ? { on: on } : undefined, onEntry ? { onEntry: onEntry } : undefined, onExit ? { onExit: onExit } : undefined);
+            : undefined), (transitionElements.length ? { on: on } : undefined), (onEntry ? { onEntry: onEntry } : undefined), (onExit ? { onExit: onExit } : undefined));
     }
     return { id: id };
 }

package/es/types.d.ts

@@ -19,11 +19,17 @@ export interface StateValueMap {
     [key: string]: StateValue;
 }
 export declare type StateValue = string | StateValueMap;
-export declare type Condition = (extendedState: any, event?: EventObject) => boolean;
+export interface HistoryValue {
+    states: Record<string, HistoryValue | undefined>;
+    current: StateValue | undefined;
+}
+export declare type ConditionPredicate = (extendedState: any, event: EventObject, microstepState: StateValue) => boolean;
+export declare type Condition = string | ConditionPredicate;
 export interface TransitionConfig {
-    cond?: (extendedState: any, event: EventObject) => boolean;
+    cond?: Condition;
     actions?: Action[];
     in?: StateValue;
+    internal?: boolean;
 }
 export interface TargetTransitionConfig extends TransitionConfig {
     target: string | string[];
@@ -35,6 +41,12 @@ export interface StateNodeConfig {
     key?: string;
     initial?: string | undefined;
     parallel?: boolean | undefined;
+    /**
+     * Indicates whether the state node is a history state node, and what
+     * type of history:
+     * shallow, deep, true (shallow), false (none), undefined (none)
+     */
+    history?: 'shallow' | 'deep' | boolean | undefined;
     states?: Record<string, SimpleOrCompoundStateNodeConfig> | undefined;
     on?: Record<string, Transition | undefined>;
     onEntry?: Action | Action[];
@@ -51,15 +63,24 @@ export interface SimpleStateNodeConfig extends StateNodeConfig {
     parallel?: false | undefined;
     states?: undefined;
 }
+export interface HistoryStateNodeConfig extends SimpleStateNodeConfig {
+    history: 'shallow' | 'deep' | true;
+    target: StateValue | undefined;
+}
 export interface CompoundStateNodeConfig extends StateNodeConfig {
     initial?: string;
     parallel?: boolean;
     states: Record<string, SimpleOrCompoundStateNodeConfig>;
+    history?: false | undefined;
 }
 export declare type SimpleOrCompoundStateNodeConfig = CompoundStateNodeConfig | SimpleStateNodeConfig;
+export interface MachineOptions {
+    guards: Record<string, ConditionPredicate>;
+}
 export interface MachineConfig extends CompoundStateNodeConfig {
     key?: string;
     strict?: boolean;
+    history?: false | undefined;
 }
 export interface StandardMachineConfig extends MachineConfig {
     initial: string;
@@ -68,7 +89,6 @@ export interface StandardMachineConfig extends MachineConfig {
 export interface ParallelMachineConfig extends MachineConfig {
     initial?: undefined;
     parallel: true;
-    states: Record<string, CompoundStateNodeConfig>;
 }
 export interface EntryExitEffectMap {
     entry: Action[];
@@ -79,6 +99,8 @@ export interface StateNode {
     id: string;
     initial: string | undefined;
     parallel: boolean;
+    transient: boolean;
+    history: false | 'shallow' | 'deep';
     states: Record<string, StateNode>;
     on?: Record<string, Transition>;
     onEntry?: Action | Action[];
@@ -88,6 +110,7 @@ export interface StateNode {
 }
 export interface ComplexStateNode extends StateNode {
     initial: string;
+    history: false;
 }
 export interface LeafStateNode extends StateNode {
     initial: never;
@@ -95,6 +118,10 @@ export interface LeafStateNode extends StateNode {
     states: never;
     parent: StateNode;
 }
+export interface HistoryStateNode extends StateNode {
+    history: 'shallow' | 'deep';
+    target: StateValue | undefined;
+}
 export interface Machine extends StateNode {
     id: string;
     initial: string | undefined;
@@ -116,15 +143,19 @@ export interface ActionMap {
     actions: Action[];
     onExit: Action[];
 }
+export interface EntryExitStates {
+    entry: Set<StateNode>;
+    exit: Set<StateNode>;
+}
 export interface ActivityMap {
     [activityKey: string]: boolean;
 }
 export declare type MaybeStateValueActionsTuple = [StateValue | undefined, ActionMap, ActivityMap | undefined];
 export interface StateTransition {
-    statePaths: string[][];
-    actions: ActionMap;
-    activities: ActivityMap | undefined;
-    events: EventObject[];
+    value: StateValue | undefined;
+    entryExitStates: EntryExitStates | undefined;
+    actions: Action[];
+    paths: string[][];
 }
 export interface TransitionData {
     value: StateValue | undefined;

package/es/utils.d.ts

@@ -12,10 +12,23 @@ export declare function mapValues<T, P>(collection: {
 }) => P): {
     [key: string]: P;
 };
+export declare function mapFilterValues<T, P>(collection: {
+    [key: string]: T;
+}, iteratee: (item: T, key: string, collection: {
+    [key: string]: T;
+}) => P, predicate: (item: T) => boolean): {
+    [key: string]: P;
+};
 /**
  * Retrieves a value at the given path.
  * @param props The deep path to the prop of the desired value
  */
-export declare const path: (props: string[]) => any;
+export declare const path: <T extends Record<string, any>>(props: string[]) => any;
+/**
+ * Retrieves a value at the given path via the nested accessor prop.
+ * @param props The deep path to the prop of the desired value
+ */
+export declare function nestedPath<T extends Record<string, any>>(props: string[], accessorProp: keyof T): (object: T) => T;
 export declare const toStatePaths: (stateValue: StateValue) => string[][];
 export declare const pathsToStateValue: (paths: string[][]) => StateValue;
+export declare const flatMap: <T>(array: T[][]) => T[];

package/es/utils.js

@@ -13,7 +13,9 @@ export function getActionType(action) {
     try {
         return typeof action === 'string' || typeof action === 'number'
             ? "" + action
-            : typeof action === 'function' ? action.name : action.type;
+            : typeof action === 'function'
+                ? action.name
+                : action.type;
     }
     catch (e) {
         throw new Error('Events must be strings or objects with a string event.type property.');
@@ -64,6 +66,17 @@ export function mapValues(collection, iteratee) {
     });
     return result;
 }
+export function mapFilterValues(collection, iteratee, predicate) {
+    var result = {};
+    Object.keys(collection).forEach(function (key) {
+        var item = collection[key];
+        if (!predicate(item)) {
+            return;
+        }
+        result[key] = iteratee(item, key, collection);
+    });
+    return result;
+}
 /**
  * Retrieves a value at the given path.
  * @param props The deep path to the prop of the desired value
@@ -76,17 +89,29 @@ export var path = function (props) { return function (object) {
     }
     return result;
 }; };
+/**
+ * Retrieves a value at the given path via the nested accessor prop.
+ * @param props The deep path to the prop of the desired value
+ */
+export function nestedPath(props, accessorProp) {
+    return function (object) {
+        var result = object;
+        for (var _i = 0, props_2 = props; _i < props_2.length; _i++) {
+            var prop = props_2[_i];
+            result = result[accessorProp][prop];
+        }
+        return result;
+    };
+}
 export var toStatePaths = function (stateValue) {
     if (typeof stateValue === 'string') {
         return [[stateValue]];
     }
-    var result = Object.keys(stateValue)
-        .map(function (key) {
+    var result = flatMap(Object.keys(stateValue).map(function (key) {
         return toStatePaths(stateValue[key]).map(function (subPath) {
             return [key].concat(subPath);
         });
-    })
-        .reduce(function (a, b) { return a.concat(b); }, []);
+    }));
     return result;
 };
 export var pathsToStateValue = function (paths) {
@@ -110,3 +135,6 @@ export var pathsToStateValue = function (paths) {
     }
     return result;
 };
+export var flatMap = function (array) {
+    return array.reduce(function (a, b) { return a.concat(b); }, []);
+};

package/lib/Machine.d.ts

@@ -1,2 +1,2 @@
-import { StandardMachine, ParallelMachine, MachineConfig, ParallelMachineConfig } from './types';
-export declare function Machine(config: MachineConfig | ParallelMachineConfig): StandardMachine | ParallelMachine;
+import { StandardMachine, ParallelMachine, MachineConfig, ParallelMachineConfig, MachineOptions } from './types';
+export declare function Machine(config: MachineConfig | ParallelMachineConfig, options?: MachineOptions): StandardMachine | ParallelMachine;

package/lib/Machine.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 var StateNode_1 = require("./StateNode");
-function Machine(config) {
-    return new StateNode_1.StateNode(config);
+function Machine(config, options) {
+    return new StateNode_1.StateNode(config, options);
 }
 exports.Machine = Machine;

package/lib/State.d.ts

@@ -1,7 +1,8 @@
-import { StateValue, ActivityMap, EventObject, Action, StateInterface } from './types';
+import { StateValue, ActivityMap, EventObject, Action, StateInterface, HistoryValue } from './types';
 export declare class State implements StateInterface {
     value: StateValue;
-    history: State | undefined;
+    historyValue?: HistoryValue | undefined;
+    history?: State | undefined;
     actions: Action[];
     activities: ActivityMap;
     data: Record<string, any>;
@@ -11,10 +12,10 @@ export declare class State implements StateInterface {
     events: EventObject[];
     static from(stateValue: State | StateValue): State;
     static inert(stateValue: State | StateValue): State;
-    constructor(value: StateValue, history?: State | undefined, actions?: Action[], activities?: ActivityMap, data?: Record<string, any>, 
-        /**
-         * Internal event queue
-         */
-        events?: EventObject[]);
+    constructor(value: StateValue, historyValue?: HistoryValue | undefined, history?: State | undefined, actions?: Action[], activities?: ActivityMap, data?: Record<string, any>, 
+    /**
+     * Internal event queue
+     */
+    events?: EventObject[]);
     toString(): string | undefined;
 }

package/lib/State.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 var constants_1 = require("./constants");
 var State = /** @class */ (function () {
-    function State(value, history, actions, activities, data, 
+    function State(value, historyValue, history, actions, activities, data, 
     /**
      * Internal event queue
      */
@@ -12,6 +12,7 @@ var State = /** @class */ (function () {
         if (data === void 0) { data = {}; }
         if (events === void 0) { events = []; }
         this.value = value;
+        this.historyValue = historyValue;
         this.history = history;
         this.actions = actions;
         this.activities = activities;
@@ -29,7 +30,7 @@ var State = /** @class */ (function () {
             if (!stateValue.actions.length) {
                 return stateValue;
             }
-            return new State(stateValue.value, stateValue.history, []);
+            return new State(stateValue.value, stateValue.historyValue, stateValue.history, [], stateValue.activities);
         }
         return State.from(stateValue);
     };

package/lib/StateNode.d.ts

@@ -1,16 +1,19 @@
-import { Event, StateValue, Action, StandardMachine, ParallelMachine, SimpleOrCompoundStateNodeConfig, MachineConfig, ParallelMachineConfig, EventType, StandardMachineConfig, StateNodeConfig, Activity, ConditionalTransitionConfig } from './types';
+import { Event, StateValue, Action, StandardMachine, ParallelMachine, SimpleOrCompoundStateNodeConfig, ParallelMachineConfig, EventType, StandardMachineConfig, Activity, ConditionalTransitionConfig, StateTransition, MachineOptions, HistoryValue } from './types';
 import { State } from './State';
-declare class StateNode implements StateNodeConfig {
+declare class StateNode {
     config: SimpleOrCompoundStateNodeConfig | StandardMachineConfig | ParallelMachineConfig;
+    options: MachineOptions;
     key: string;
     id: string;
     path: string[];
     initial?: string;
     parallel?: boolean;
+    transient: boolean;
     states: Record<string, StateNode>;
+    history: false | 'shallow' | 'deep';
     on: Record<string, ConditionalTransitionConfig>;
-    onEntry?: Action[];
-    onExit?: Action[];
+    onEntry: Action[];
+    onExit: Action[];
     activities?: Activity[];
     strict: boolean;
     parent?: StateNode;
@@ -19,24 +22,58 @@ declare class StateNode implements StateNodeConfig {
     delimiter: string;
     private __cache;
     private idMap;
-    constructor(config: SimpleOrCompoundStateNodeConfig | StandardMachineConfig | ParallelMachineConfig);
+    constructor(config: SimpleOrCompoundStateNodeConfig | StandardMachineConfig | ParallelMachineConfig, options?: MachineOptions);
     getStateNodes(state: StateValue | State): StateNode[];
     handles(event: Event): boolean;
+    private _transitionLeafNode;
+    private _transitionHierarchicalNode;
+    private _transitionOrthogonalNode;
+    _transition(stateValue: StateValue, state: State, event: Event, extendedState?: any): StateTransition;
+    private _next;
+    private _getEntryExitStates;
+    private _evaluateCond;
+    private _getActions;
+    private _getActivities;
     transition(state: StateValue | State, event: Event, extendedState?: any): State;
-    private stateTransitionToState(stateTransition, prevState);
+    private ensureValidPaths;
     getStateNode(stateKey: string): StateNode;
     getStateNodeById(stateId: string): StateNode;
-    private resolve(stateValue);
-    private transitionStateValue(state, event, fullState, extendedState?);
-    private next(event, fullState, history?, extendedState?);
+    getStateNodeByPath(statePath: string | string[]): StateNode;
+    private resolve;
     private readonly resolvedStateValue;
-    private getResolvedPath(stateIdentifier);
+    private getResolvedPath;
     private readonly initialStateValue;
     readonly initialState: State;
+    readonly target: StateValue | undefined;
     getStates(stateValue: StateValue): StateNode[];
-    getState(relativeStateId: string | string[]): StateNode | undefined;
+    /**
+     * Returns the leaf nodes from a state path relative to this state node.
+     *
+     * @param relativeStateId The relative state path to retrieve the state nodes
+     * @param history The previous state to retrieve history
+     * @param resolve Whether state nodes should resolve to initial child state nodes
+     */
+    getRelativeStateNodes(relativeStateId: string | string[], historyValue?: HistoryValue, resolve?: boolean): StateNode[];
+    readonly initialStateNodes: StateNode[];
+    /**
+     * Retrieves state nodes from a relative path to this state node.
+     *
+     * @param relativePath The relative path from this state node
+     * @param historyValue
+     */
+    getFromRelativePath(relativePath: string[], historyValue?: HistoryValue): StateNode[];
+    static updateHistoryValue(hist: HistoryValue, stateValue: StateValue): HistoryValue;
+    historyValue(relativeStateValue?: StateValue | undefined): HistoryValue | undefined;
+    /**
+     * Resolves to the historical value(s) of the parent state node,
+     * represented by state nodes.
+     *
+     * @param historyValue
+     */
+    private resolveHistory;
     readonly events: EventType[];
-    private formatTransitions(onConfig);
+    private formatTransition;
+    private formatTransitions;
 }
-export declare function Machine(config: MachineConfig | ParallelMachineConfig): StandardMachine | ParallelMachine;
+export declare function Machine<T extends StandardMachineConfig | ParallelMachineConfig>(config: T, options?: MachineOptions): T extends ParallelMachineConfig ? ParallelMachine : T extends StandardMachineConfig ? StandardMachine : never;
 export { StateNode };