xstate 5.0.0-beta.23 → 5.0.0-beta.25

package/dist/{actions-bf7f6679.esm.js → actions-5943a9db.esm.js}

@@ -1464,148 +1464,100 @@ function invoke({
   return invoke;
 }
 
+function checkStateIn(state, _, {
+  stateValue
+}) {
+  if (typeof stateValue === 'string' && isStateId(stateValue)) {
+    return state.configuration.some(sn => sn.id === stateValue.slice(1));
+  }
+  return state.matches(stateValue);
+}
 function stateIn(stateValue) {
-  return {
-    type: 'xstate.guard:in',
-    params: {
-      stateValue
-    },
-    predicate: ({
-      state
-    }) => {
-      if (typeof stateValue === 'string' && isStateId(stateValue)) {
-        return state.configuration.some(sn => sn.id === stateValue.slice(1));
-      }
-      return state.matches(stateValue);
-    }
-  };
+  function stateIn(_) {
+    return false;
+  }
+  stateIn.check = checkStateIn;
+  stateIn.stateValue = stateValue;
+  return stateIn;
+}
+function checkNot(state, {
+  context,
+  event
+}, {
+  guards
+}) {
+  return !evaluateGuard(guards[0], context, event, state);
 }
 function not(guard) {
-  return {
-    type: 'xstate.boolean',
-    params: {
-      op: 'not'
-    },
-    children: [toGuardDefinition(guard)],
-    predicate: ({
-      evaluate,
-      guard,
-      context,
-      event,
-      state
-    }) => {
-      return !evaluate(guard.children[0], context, event, state);
-    }
-  };
+  function not(_) {
+    return false;
+  }
+  not.check = checkNot;
+  not.guards = [guard];
+  return not;
+}
+function checkAnd(state, {
+  context,
+  event
+}, {
+  guards
+}) {
+  return guards.every(guard => evaluateGuard(guard, context, event, state));
 }
 function and(guards) {
-  return {
-    type: 'xstate.boolean',
-    params: {
-      op: 'and'
-    },
-    children: guards.map(guard => toGuardDefinition(guard)),
-    predicate: ({
-      evaluate,
-      guard,
-      context,
-      event,
-      state
-    }) => {
-      return guard.children.every(childGuard => {
-        return evaluate(childGuard, context, event, state);
-      });
-    }
-  };
+  function and(_) {
+    return false;
+  }
+  and.check = checkAnd;
+  and.guards = guards;
+  return and;
+}
+function checkOr(state, {
+  context,
+  event
+}, {
+  guards
+}) {
+  return guards.some(guard => evaluateGuard(guard, context, event, state));
 }
 function or(guards) {
-  return {
-    type: 'xstate.boolean',
-    params: {
-      op: 'or'
-    },
-    children: guards.map(guard => toGuardDefinition(guard)),
-    predicate: ({
-      evaluate,
-      guard,
-      context,
-      event,
-      state
-    }) => {
-      return guard.children.some(childGuard => {
-        return evaluate(childGuard, context, event, state);
-      });
-    }
-  };
+  function or(_) {
+    return false;
+  }
+  or.check = checkOr;
+  or.guards = guards;
+  return or;
 }
+
+// TODO: throw on cycles (depth check should be enough)
 function evaluateGuard(guard, context, event, state) {
   const {
     machine
   } = state;
-  const predicate = machine?.implementations?.guards?.[guard.type] ?? guard.predicate;
-  if (!predicate) {
-    throw new Error(`Guard '${guard.type}' is not implemented.'.`);
+  const isInline = typeof guard === 'function';
+  const resolved = isInline ? guard : machine.implementations.guards[typeof guard === 'string' ? guard : guard.type];
+  if (!isInline && !resolved) {
+    throw new Error(`Guard '${typeof guard === 'string' ? guard : guard.type}' is not implemented.'.`);
+  }
+  if (typeof resolved !== 'function') {
+    return evaluateGuard(resolved, context, event, state);
   }
-  return predicate({
+  const guardArgs = {
     context,
     event,
-    state,
-    guard,
-    evaluate: evaluateGuard
-  });
-}
-function toGuardDefinition(guardConfig, getPredicate) {
-  // TODO: check for cycles and consider a refactor to more lazily evaluated guards
-  // TODO: resolve this more recursively: https://github.com/statelyai/xstate/pull/4064#discussion_r1229915724
-  if (typeof guardConfig === 'string') {
-    const predicateOrDef = getPredicate?.(guardConfig);
-    if (typeof predicateOrDef === 'function') {
-      return {
-        type: guardConfig,
-        predicate: predicateOrDef,
-        params: {
-          type: guardConfig
-        }
-      };
-    } else if (predicateOrDef) {
-      return predicateOrDef;
-    } else {
-      return {
-        type: guardConfig,
-        params: {
-          type: guardConfig
-        }
-      };
-    }
-  }
-  if (typeof guardConfig === 'function') {
-    return {
-      type: guardConfig.name,
-      predicate: guardConfig,
-      params: {
-        type: guardConfig.name,
-        name: guardConfig.name
-      }
-    };
-  }
-  const predicateOrDef = getPredicate?.(guardConfig.type);
-  if (typeof predicateOrDef === 'function') {
-    return {
-      type: guardConfig.type,
-      params: guardConfig.params || guardConfig,
-      children: guardConfig.children?.map(childGuard => toGuardDefinition(childGuard, getPredicate)),
-      predicate: getPredicate?.(guardConfig.type) || guardConfig.predicate
-    };
-  } else if (predicateOrDef) {
-    return predicateOrDef;
-  } else {
-    return {
-      type: guardConfig.type,
-      params: guardConfig.params || guardConfig,
-      children: guardConfig.children?.map(childGuard => toGuardDefinition(childGuard, getPredicate)),
-      predicate: guardConfig.predicate
-    };
+    guard: isInline ? undefined : typeof guard === 'string' ? {
+      type: guard
+    } : guard
+  };
+  if (!('check' in resolved)) {
+    // the existing type of `.guards` assumes non-nullable `TExpressionGuard`
+    // inline guards expect `TExpressionGuard` to be set to `undefined`
+    // it's fine to cast this here, our logic makes sure that we call those 2 "variants" correctly
+    return resolved(guardArgs);
   }
+  const builtinGuard = resolved;
+  return builtinGuard.check(state, guardArgs, resolved // this holds all params
+  );
 }
 
 function getOutput(configuration, context, event, self) {
@@ -1795,14 +1747,11 @@ function getDelayedTransitions(stateNode) {
 function formatTransition(stateNode, descriptor, transitionConfig) {
   const normalizedTarget = normalizeTarget(transitionConfig.target);
   const reenter = transitionConfig.reenter ?? false;
-  const {
-    guards
-  } = stateNode.machine.implementations;
   const target = resolveTarget(stateNode, normalizedTarget);
   const transition = {
     ...transitionConfig,
     actions: toArray(transitionConfig.actions),
-    guard: transitionConfig.guard ? toGuardDefinition(transitionConfig.guard, guardType => guards[guardType]) : undefined,
+    guard: transitionConfig.guard,
     target,
     source: stateNode,
     reenter,
@@ -2407,7 +2356,7 @@ function resolveActionsAndContext(actions, event, currentState, actorCtx) {
     if (!resolved) {
       continue;
     }
-    const args = {
+    const actionArgs = {
       context: intermediateState.context,
       event,
       self: actorCtx?.self,
@@ -2418,14 +2367,14 @@ function resolveActionsAndContext(actions, event, currentState, actorCtx) {
     };
     if (!('resolve' in resolved)) {
       if (actorCtx?.self.status === ActorStatus.Running) {
-        resolved(args);
+        resolved(actionArgs);
       } else {
-        actorCtx?.defer(() => resolved(args));
+        actorCtx?.defer(() => resolved(actionArgs));
       }
       continue;
     }
     const builtinAction = resolved;
-    const [nextState, params, actions] = builtinAction.resolve(actorCtx, intermediateState, args, resolved // this holds all params
+    const [nextState, params, actions] = builtinAction.resolve(actorCtx, intermediateState, actionArgs, resolved // this holds all params
     );
 
     intermediateState = nextState;
@@ -2973,8 +2922,7 @@ function resolve$1(_, state, actionArgs, {
   branches
 }) {
   const matchedActions = branches.find(condition => {
-    const guard = condition.guard && toGuardDefinition(condition.guard, guardType => state.machine.implementations.guards[guardType]);
-    return !guard || evaluateGuard(guard, state.context, actionArgs.event, state);
+    return !condition.guard || evaluateGuard(condition.guard, state.context, actionArgs.event, state);
   })?.actions;
   return [state, undefined, toArray(matchedActions)];
 }
@@ -3067,4 +3015,4 @@ function createInitEvent(input) {
   };
 }
 
-export { fromObservable as $, microstep as A, isAtomicStateNode as B, isStateId as C, getStateNodeByPath as D, getPersistedState as E, resolveReferencedActor as F, createActor as G, matchesState as H, sendTo as I, sendParent as J, forwardTo as K, interpret as L, Actor as M, NULL_EVENT as N, ActorStatus as O, InterpreterStatus as P, doneInvoke as Q, cancel as R, STATE_DELIMITER as S, choose as T, log as U, pure as V, raise as W, stop as X, pathToStateValue as Y, toObserver as Z, fromPromise as _, toTransitionConfigArray as a, fromCallback as a0, fromEventObservable as a1, fromTransition as a2, stateIn as a3, not as a4, and as a5, or as a6, ConstantPrefix as a7, SpecialTargets as a8, startSignalType as a9, stopSignalType as aa, startSignal as ab, stopSignal as ac, isSignal as ad, isActorRef as ae, toActorRef as af, createEmptyActor as ag, toGuardDefinition as ah, constantPrefixes as ai, after as aj, done as ak, error as al, escalate as am, formatTransition as b, memo as c, flatten as d, evaluateGuard as e, formatTransitions as f, createInvokeId as g, getDelayedTransitions as h, formatInitialTransition as i, getCandidates as j, toInvokeConfig as k, getConfiguration as l, mapValues as m, getStateNodes as n, isInFinalState as o, State as p, isErrorEvent as q, resolveStateValue as r, cloneState as s, toArray as t, macrostep as u, transitionNode as v, getInitialConfiguration as w, resolveActionsAndContext as x, assign as y, createInitEvent as z };
+export { fromObservable as $, microstep as A, isAtomicStateNode as B, isStateId as C, getStateNodeByPath as D, getPersistedState as E, resolveReferencedActor as F, createActor as G, matchesState as H, sendTo as I, sendParent as J, forwardTo as K, interpret as L, Actor as M, NULL_EVENT as N, ActorStatus as O, InterpreterStatus as P, doneInvoke as Q, cancel as R, STATE_DELIMITER as S, choose as T, log as U, pure as V, raise as W, stop as X, pathToStateValue as Y, toObserver as Z, fromPromise as _, toTransitionConfigArray as a, fromCallback as a0, fromEventObservable as a1, fromTransition as a2, stateIn as a3, not as a4, and as a5, or as a6, ConstantPrefix as a7, SpecialTargets as a8, startSignalType as a9, stopSignalType as aa, startSignal as ab, stopSignal as ac, isSignal as ad, isActorRef as ae, toActorRef as af, createEmptyActor as ag, constantPrefixes as ah, after as ai, done as aj, error as ak, escalate as al, formatTransition as b, memo as c, flatten as d, evaluateGuard as e, formatTransitions as f, createInvokeId as g, getDelayedTransitions as h, formatInitialTransition as i, getCandidates as j, toInvokeConfig as k, getConfiguration as l, mapValues as m, getStateNodes as n, isInFinalState as o, State as p, isErrorEvent as q, resolveStateValue as r, cloneState as s, toArray as t, macrostep as u, transitionNode as v, getInitialConfiguration as w, resolveActionsAndContext as x, assign as y, createInitEvent as z };

package/dist/{actions-f6b5002d.development.esm.js → actions-cf69419d.development.esm.js}

@@ -1494,148 +1494,108 @@ function invoke({
   return invoke;
 }
 
+function checkStateIn(state, _, {
+  stateValue
+}) {
+  if (typeof stateValue === 'string' && isStateId(stateValue)) {
+    return state.configuration.some(sn => sn.id === stateValue.slice(1));
+  }
+  return state.matches(stateValue);
+}
 function stateIn(stateValue) {
-  return {
-    type: 'xstate.guard:in',
-    params: {
-      stateValue
-    },
-    predicate: ({
-      state
-    }) => {
-      if (typeof stateValue === 'string' && isStateId(stateValue)) {
-        return state.configuration.some(sn => sn.id === stateValue.slice(1));
-      }
-      return state.matches(stateValue);
+  function stateIn(_) {
+    {
+      throw new Error(`This isn't supposed to be called`);
     }
-  };
+  }
+  stateIn.check = checkStateIn;
+  stateIn.stateValue = stateValue;
+  return stateIn;
+}
+function checkNot(state, {
+  context,
+  event
+}, {
+  guards
+}) {
+  return !evaluateGuard(guards[0], context, event, state);
 }
 function not(guard) {
-  return {
-    type: 'xstate.boolean',
-    params: {
-      op: 'not'
-    },
-    children: [toGuardDefinition(guard)],
-    predicate: ({
-      evaluate,
-      guard,
-      context,
-      event,
-      state
-    }) => {
-      return !evaluate(guard.children[0], context, event, state);
+  function not(_) {
+    {
+      throw new Error(`This isn't supposed to be called`);
     }
-  };
+  }
+  not.check = checkNot;
+  not.guards = [guard];
+  return not;
+}
+function checkAnd(state, {
+  context,
+  event
+}, {
+  guards
+}) {
+  return guards.every(guard => evaluateGuard(guard, context, event, state));
 }
 function and(guards) {
-  return {
-    type: 'xstate.boolean',
-    params: {
-      op: 'and'
-    },
-    children: guards.map(guard => toGuardDefinition(guard)),
-    predicate: ({
-      evaluate,
-      guard,
-      context,
-      event,
-      state
-    }) => {
-      return guard.children.every(childGuard => {
-        return evaluate(childGuard, context, event, state);
-      });
+  function and(_) {
+    {
+      throw new Error(`This isn't supposed to be called`);
     }
-  };
+  }
+  and.check = checkAnd;
+  and.guards = guards;
+  return and;
+}
+function checkOr(state, {
+  context,
+  event
+}, {
+  guards
+}) {
+  return guards.some(guard => evaluateGuard(guard, context, event, state));
 }
 function or(guards) {
-  return {
-    type: 'xstate.boolean',
-    params: {
-      op: 'or'
-    },
-    children: guards.map(guard => toGuardDefinition(guard)),
-    predicate: ({
-      evaluate,
-      guard,
-      context,
-      event,
-      state
-    }) => {
-      return guard.children.some(childGuard => {
-        return evaluate(childGuard, context, event, state);
-      });
+  function or(_) {
+    {
+      throw new Error(`This isn't supposed to be called`);
     }
-  };
+  }
+  or.check = checkOr;
+  or.guards = guards;
+  return or;
 }
+
+// TODO: throw on cycles (depth check should be enough)
 function evaluateGuard(guard, context, event, state) {
   const {
     machine
   } = state;
-  const predicate = machine?.implementations?.guards?.[guard.type] ?? guard.predicate;
-  if (!predicate) {
-    throw new Error(`Guard '${guard.type}' is not implemented.'.`);
+  const isInline = typeof guard === 'function';
+  const resolved = isInline ? guard : machine.implementations.guards[typeof guard === 'string' ? guard : guard.type];
+  if (!isInline && !resolved) {
+    throw new Error(`Guard '${typeof guard === 'string' ? guard : guard.type}' is not implemented.'.`);
+  }
+  if (typeof resolved !== 'function') {
+    return evaluateGuard(resolved, context, event, state);
   }
-  return predicate({
+  const guardArgs = {
     context,
     event,
-    state,
-    guard,
-    evaluate: evaluateGuard
-  });
-}
-function toGuardDefinition(guardConfig, getPredicate) {
-  // TODO: check for cycles and consider a refactor to more lazily evaluated guards
-  // TODO: resolve this more recursively: https://github.com/statelyai/xstate/pull/4064#discussion_r1229915724
-  if (typeof guardConfig === 'string') {
-    const predicateOrDef = getPredicate?.(guardConfig);
-    if (typeof predicateOrDef === 'function') {
-      return {
-        type: guardConfig,
-        predicate: predicateOrDef,
-        params: {
-          type: guardConfig
-        }
-      };
-    } else if (predicateOrDef) {
-      return predicateOrDef;
-    } else {
-      return {
-        type: guardConfig,
-        params: {
-          type: guardConfig
-        }
-      };
-    }
-  }
-  if (typeof guardConfig === 'function') {
-    return {
-      type: guardConfig.name,
-      predicate: guardConfig,
-      params: {
-        type: guardConfig.name,
-        name: guardConfig.name
-      }
-    };
-  }
-  const predicateOrDef = getPredicate?.(guardConfig.type);
-  if (typeof predicateOrDef === 'function') {
-    return {
-      type: guardConfig.type,
-      params: guardConfig.params || guardConfig,
-      children: guardConfig.children?.map(childGuard => toGuardDefinition(childGuard, getPredicate)),
-      predicate: getPredicate?.(guardConfig.type) || guardConfig.predicate
-    };
-  } else if (predicateOrDef) {
-    return predicateOrDef;
-  } else {
-    return {
-      type: guardConfig.type,
-      params: guardConfig.params || guardConfig,
-      children: guardConfig.children?.map(childGuard => toGuardDefinition(childGuard, getPredicate)),
-      predicate: guardConfig.predicate
-    };
+    guard: isInline ? undefined : typeof guard === 'string' ? {
+      type: guard
+    } : guard
+  };
+  if (!('check' in resolved)) {
+    // the existing type of `.guards` assumes non-nullable `TExpressionGuard`
+    // inline guards expect `TExpressionGuard` to be set to `undefined`
+    // it's fine to cast this here, our logic makes sure that we call those 2 "variants" correctly
+    return resolved(guardArgs);
   }
+  const builtinGuard = resolved;
+  return builtinGuard.check(state, guardArgs, resolved // this holds all params
+  );
 }
 
 function getOutput(configuration, context, event, self) {
@@ -1831,9 +1791,6 @@ function getDelayedTransitions(stateNode) {
 function formatTransition(stateNode, descriptor, transitionConfig) {
   const normalizedTarget = normalizeTarget(transitionConfig.target);
   const reenter = transitionConfig.reenter ?? false;
-  const {
-    guards
-  } = stateNode.machine.implementations;
   const target = resolveTarget(stateNode, normalizedTarget);
 
   // TODO: should this be part of a lint rule instead?
@@ -1843,7 +1800,7 @@ function formatTransition(stateNode, descriptor, transitionConfig) {
   const transition = {
     ...transitionConfig,
     actions: toArray(transitionConfig.actions),
-    guard: transitionConfig.guard ? toGuardDefinition(transitionConfig.guard, guardType => guards[guardType]) : undefined,
+    guard: transitionConfig.guard,
     target,
     source: stateNode,
     reenter,
@@ -2448,7 +2405,7 @@ function resolveActionsAndContext(actions, event, currentState, actorCtx) {
     if (!resolved) {
       continue;
     }
-    const args = {
+    const actionArgs = {
       context: intermediateState.context,
       event,
       self: actorCtx?.self,
@@ -2459,14 +2416,14 @@ function resolveActionsAndContext(actions, event, currentState, actorCtx) {
     };
     if (!('resolve' in resolved)) {
       if (actorCtx?.self.status === ActorStatus.Running) {
-        resolved(args);
+        resolved(actionArgs);
       } else {
-        actorCtx?.defer(() => resolved(args));
+        actorCtx?.defer(() => resolved(actionArgs));
       }
       continue;
     }
     const builtinAction = resolved;
-    const [nextState, params, actions] = builtinAction.resolve(actorCtx, intermediateState, args, resolved // this holds all params
+    const [nextState, params, actions] = builtinAction.resolve(actorCtx, intermediateState, actionArgs, resolved // this holds all params
     );
 
     intermediateState = nextState;
@@ -3032,8 +2989,7 @@ function resolve$1(_, state, actionArgs, {
   branches
 }) {
   const matchedActions = branches.find(condition => {
-    const guard = condition.guard && toGuardDefinition(condition.guard, guardType => state.machine.implementations.guards[guardType]);
-    return !guard || evaluateGuard(guard, state.context, actionArgs.event, state);
+    return !condition.guard || evaluateGuard(condition.guard, state.context, actionArgs.event, state);
   })?.actions;
   return [state, undefined, toArray(matchedActions)];
 }
@@ -3132,4 +3088,4 @@ function createInitEvent(input) {
   };
 }
 
-export { fromObservable as $, microstep as A, isAtomicStateNode as B, isStateId as C, getStateNodeByPath as D, getPersistedState as E, resolveReferencedActor as F, createActor as G, matchesState as H, sendTo as I, sendParent as J, forwardTo as K, interpret as L, Actor as M, NULL_EVENT as N, ActorStatus as O, InterpreterStatus as P, doneInvoke as Q, cancel as R, STATE_DELIMITER as S, choose as T, log as U, pure as V, raise as W, stop as X, pathToStateValue as Y, toObserver as Z, fromPromise as _, toTransitionConfigArray as a, fromCallback as a0, fromEventObservable as a1, fromTransition as a2, stateIn as a3, not as a4, and as a5, or as a6, ConstantPrefix as a7, SpecialTargets as a8, startSignalType as a9, stopSignalType as aa, startSignal as ab, stopSignal as ac, isSignal as ad, isActorRef as ae, toActorRef as af, createEmptyActor as ag, toGuardDefinition as ah, constantPrefixes as ai, after as aj, done as ak, error as al, escalate as am, formatTransition as b, memo as c, flatten as d, evaluateGuard as e, formatTransitions as f, createInvokeId as g, getDelayedTransitions as h, formatInitialTransition as i, getCandidates as j, toInvokeConfig as k, getConfiguration as l, mapValues as m, getStateNodes as n, isInFinalState as o, State as p, isErrorEvent as q, resolveStateValue as r, cloneState as s, toArray as t, macrostep as u, transitionNode as v, getInitialConfiguration as w, resolveActionsAndContext as x, assign as y, createInitEvent as z };
+export { fromObservable as $, microstep as A, isAtomicStateNode as B, isStateId as C, getStateNodeByPath as D, getPersistedState as E, resolveReferencedActor as F, createActor as G, matchesState as H, sendTo as I, sendParent as J, forwardTo as K, interpret as L, Actor as M, NULL_EVENT as N, ActorStatus as O, InterpreterStatus as P, doneInvoke as Q, cancel as R, STATE_DELIMITER as S, choose as T, log as U, pure as V, raise as W, stop as X, pathToStateValue as Y, toObserver as Z, fromPromise as _, toTransitionConfigArray as a, fromCallback as a0, fromEventObservable as a1, fromTransition as a2, stateIn as a3, not as a4, and as a5, or as a6, ConstantPrefix as a7, SpecialTargets as a8, startSignalType as a9, stopSignalType as aa, startSignal as ab, stopSignal as ac, isSignal as ad, isActorRef as ae, toActorRef as af, createEmptyActor as ag, constantPrefixes as ah, after as ai, done as aj, error as ak, escalate as al, formatTransition as b, memo as c, flatten as d, evaluateGuard as e, formatTransitions as f, createInvokeId as g, getDelayedTransitions as h, formatInitialTransition as i, getCandidates as j, toInvokeConfig as k, getConfiguration as l, mapValues as m, getStateNodes as n, isInFinalState as o, State as p, isErrorEvent as q, resolveStateValue as r, cloneState as s, toArray as t, macrostep as u, transitionNode as v, getInitialConfiguration as w, resolveActionsAndContext as x, assign as y, createInitEvent as z };

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

@@ -1,4 +1,4 @@
-import { MachineConfig, EventObject, MachineContext, InternalMachineImplementations, ParameterizedObject, ProvidedActor, AnyEventObject, NonReducibleUnknown } from "./types.js";
+import { MachineConfig, EventObject, MachineContext, InternalMachineImplementations, ParameterizedObject, ProvidedActor, AnyEventObject, NonReducibleUnknown, Prop } from "./types.js";
 import { TypegenConstraint, TypegenDisabled, ResolveTypegenMeta } from "./typegenTypes.js";
 import { StateMachine } from "./StateMachine.js";
-export declare function createMachine<TContext extends MachineContext, TEvent extends EventObject = AnyEventObject, TActor extends ProvidedActor = ProvidedActor, TInput = any, TOutput = NonReducibleUnknown, TAction extends ParameterizedObject = ParameterizedObject, TTypesMeta extends TypegenConstraint = TypegenDisabled>(config: MachineConfig<TContext, TEvent, TAction, TActor, TInput, TOutput, TTypesMeta>, implementations?: InternalMachineImplementations<TContext, TEvent, TAction, TActor, ResolveTypegenMeta<TTypesMeta, TEvent, TAction, TActor>>): StateMachine<TContext, TEvent, TAction, TActor, TInput, TOutput, ResolveTypegenMeta<TTypesMeta, TEvent, TAction, TActor>>;
+export declare function createMachine<TContext extends MachineContext, TEvent extends EventObject = AnyEventObject, TActor extends ProvidedActor = ProvidedActor, TAction extends ParameterizedObject = ParameterizedObject, TGuard extends ParameterizedObject = ParameterizedObject, TDelay extends string = string, TTag extends string = string, TInput = any, TOutput = NonReducibleUnknown, TTypesMeta extends TypegenConstraint = TypegenDisabled>(config: MachineConfig<TContext, TEvent, TActor, TAction, TGuard, TDelay, TTag, TInput, TOutput, TTypesMeta>, implementations?: InternalMachineImplementations<TContext, TEvent, TActor, TAction, TDelay, ResolveTypegenMeta<TTypesMeta, TEvent, TActor, TAction, TGuard, TDelay, TTag>>): StateMachine<TContext, TEvent, TActor, TAction, TGuard, TDelay, Prop<ResolveTypegenMeta<TTypesMeta, TEvent, TActor, TAction, TGuard, TDelay, TTag>['resolved'], 'tags'> & string, TInput, TOutput, ResolveTypegenMeta<TTypesMeta, TEvent, TActor, TAction, TGuard, TDelay, TTag>>;

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

@@ -12,7 +12,7 @@ export declare function isStateConfig<TContext extends MachineContext, TEvent ex
  * @deprecated Use `isStateConfig(object)` or `state instanceof State` instead.
  */
 export declare const isState: typeof isStateConfig;
-export declare class State<TContext extends MachineContext, TEvent extends EventObject, TActor extends ProvidedActor, TOutput, TResolvedTypesMeta = TypegenDisabled> {
+export declare class State<TContext extends MachineContext, TEvent extends EventObject, TActor extends ProvidedActor, TTag extends string, TOutput, TResolvedTypesMeta = TypegenDisabled> {
     machine: AnyStateMachine;
     tags: Set<string>;
     value: StateValue;
@@ -41,7 +41,11 @@ export declare class State<TContext extends MachineContext, TEvent extends Event
      * @param stateValue
      * @param context
      */
-    static from<TContext extends MachineContext, TEvent extends EventObject = EventObject>(stateValue: State<TContext, TEvent, TODO, any, any> | StateValue, context: TContext | undefined, machine: AnyStateMachine): State<TContext, TEvent, TODO, any, any>;
+    static from<TContext extends MachineContext, TEvent extends EventObject = EventObject>(stateValue: State<TContext, TEvent, TODO, any, // tags
+    any, // output
+    any> | StateValue, context: TContext | undefined, machine: AnyStateMachine): State<TContext, TEvent, TODO, any, // tags
+    any, // output
+    any>;
     /**
      * Creates a new `State` instance that represents the current state of a running machine.
      *
@@ -67,7 +71,7 @@ export declare class State<TContext extends MachineContext, TEvent extends Event
      * Whether the current state configuration has a state node with the specified `tag`.
      * @param tag
      */
-    hasTag(tag: TResolvedTypesMeta extends TypegenEnabled ? Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'tags'> : string): boolean;
+    hasTag(tag: TTag): boolean;
     /**
      * Determines whether sending the `event` will cause a non-forbidden transition
      * to be selected, even if the transitions have no actions nor