xstate 5.0.0-beta.23 → 5.0.0-beta.24

package/dist/{actions-e83129c5.cjs.js → actions-6a8cda73.cjs.js}

@@ -1466,148 +1466,101 @@ 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.'.`);
-  }
-  return predicate({
+  const isInline = typeof guard === 'function';
+  const resolved = isInline ? guard :
+  // the existing type of `.guards` assumes non-nullable `TExpressionGuard`
+  // it's fine to cast this here to get a common type and lack of errors in the rest of the code
+  // our logic below makes sure that we call those 2 "variants" correctly
+  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);
+  }
+  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)) {
+    return resolved(guardArgs);
   }
+  const builtinGuard = resolved;
+  return builtinGuard.check(state, guardArgs, resolved // this holds all params
+  );
 }
 
 function getOutput(configuration, context, event, self) {
@@ -1797,14 +1750,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,
@@ -2409,7 +2359,7 @@ function resolveActionsAndContext(actions, event, currentState, actorCtx) {
     if (!resolved) {
       continue;
     }
-    const args = {
+    const actionArgs = {
       context: intermediateState.context,
       event,
       self: actorCtx?.self,
@@ -2420,14 +2370,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;
@@ -2975,8 +2925,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)];
 }
@@ -3141,7 +3090,6 @@ exports.stopSignal = stopSignal;
 exports.stopSignalType = stopSignalType;
 exports.toActorRef = toActorRef;
 exports.toArray = toArray;
-exports.toGuardDefinition = toGuardDefinition;
 exports.toInvokeConfig = toInvokeConfig;
 exports.toObserver = toObserver;
 exports.toTransitionConfigArray = toTransitionConfigArray;

package/dist/{actions-bf7f6679.esm.js → actions-7b182232.esm.js}

@@ -1464,148 +1464,101 @@ 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.'.`);
-  }
-  return predicate({
+  const isInline = typeof guard === 'function';
+  const resolved = isInline ? guard :
+  // the existing type of `.guards` assumes non-nullable `TExpressionGuard`
+  // it's fine to cast this here to get a common type and lack of errors in the rest of the code
+  // our logic below makes sure that we call those 2 "variants" correctly
+  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);
+  }
+  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)) {
+    return resolved(guardArgs);
   }
+  const builtinGuard = resolved;
+  return builtinGuard.check(state, guardArgs, resolved // this holds all params
+  );
 }
 
 function getOutput(configuration, context, event, self) {
@@ -1795,14 +1748,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 +2357,7 @@ function resolveActionsAndContext(actions, event, currentState, actorCtx) {
     if (!resolved) {
       continue;
     }
-    const args = {
+    const actionArgs = {
       context: intermediateState.context,
       event,
       self: actorCtx?.self,
@@ -2418,14 +2368,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 +2923,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 +3016,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 { 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, TInput = any, TOutput = NonReducibleUnknown, TTypesMeta extends TypegenConstraint = TypegenDisabled>(config: MachineConfig<TContext, TEvent, TAction, TGuard, TActor, TInput, TOutput, TTypesMeta>, implementations?: InternalMachineImplementations<TContext, TEvent, TActor, TAction, ResolveTypegenMeta<TTypesMeta, TEvent, TActor, TAction, TGuard>>): StateMachine<TContext, TEvent, TActor, TAction, TGuard, TInput, TOutput, ResolveTypegenMeta<TTypesMeta, TEvent, TActor, TAction, TGuard>>;

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

@@ -4,17 +4,17 @@ import type { AreAllImplementationsAssumedToBeProvided, MarkAllImplementationsAs
 import type { ActorContext, ActorLogic, EventObject, InternalMachineImplementations, MachineConfig, MachineContext, MachineImplementationsSimplified, MachineTypes, NoInfer, StateConfig, StateMachineDefinition, StateValue, TransitionDefinition, PersistedMachineState, ParameterizedObject, AnyActorContext, ProvidedActor, Equals, TODO } from "./types.js";
 export declare const STATE_IDENTIFIER = "#";
 export declare const WILDCARD = "*";
-export declare class StateMachine<TContext extends MachineContext, TEvent extends EventObject, TAction extends ParameterizedObject, TActor extends ProvidedActor, TInput, TOutput, TResolvedTypesMeta = ResolveTypegenMeta<TypegenDisabled, NoInfer<TEvent>, TAction, TActor>> implements ActorLogic<TEvent, State<TContext, TEvent, TActor, TOutput, TResolvedTypesMeta>, State<TContext, TEvent, TActor, TOutput, TResolvedTypesMeta>, PersistedMachineState<State<TContext, TEvent, TActor, TOutput, TResolvedTypesMeta>>, TODO, TInput, TOutput> {
+export declare class StateMachine<TContext extends MachineContext, TEvent extends EventObject, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TInput, TOutput, TResolvedTypesMeta = ResolveTypegenMeta<TypegenDisabled, NoInfer<TEvent>, TActor, TAction, TGuard>> implements ActorLogic<TEvent, State<TContext, TEvent, TActor, TOutput, TResolvedTypesMeta>, State<TContext, TEvent, TActor, TOutput, TResolvedTypesMeta>, PersistedMachineState<State<TContext, TEvent, TActor, TOutput, TResolvedTypesMeta>>, TODO, TInput, TOutput> {
     /**
      * The raw config used to create the machine.
      */
-    config: MachineConfig<TContext, TEvent, any, any, any, TOutput, any>;
+    config: MachineConfig<TContext, TEvent, any, any, any, any, TOutput, any>;
     /**
      * The machine's own version.
      */
     version?: string;
     implementations: MachineImplementationsSimplified<TContext, TEvent>;
-    types: MachineTypes<TContext, TEvent, TAction, TActor, TInput, TOutput>;
+    types: MachineTypes<TContext, TEvent, TAction, TGuard, TActor, TInput, TOutput, TResolvedTypesMeta>;
     __xstatenode: true;
     idMap: Map<string, StateNode<TContext, TEvent>>;
     root: StateNode<TContext, TEvent>;
@@ -25,7 +25,7 @@ export declare class StateMachine<TContext extends MachineContext, TEvent extend
     /**
      * The raw config used to create the machine.
      */
-    config: MachineConfig<TContext, TEvent, any, any, any, TOutput, any>, implementations?: MachineImplementationsSimplified<TContext, TEvent>);
+    config: MachineConfig<TContext, TEvent, any, any, any, any, TOutput, any>, implementations?: MachineImplementationsSimplified<TContext, TEvent>);
     /**
      * Clones this state machine with the provided implementations
      * and merges the `context` (if provided).
@@ -35,7 +35,7 @@ export declare class StateMachine<TContext extends MachineContext, TEvent extend
      *
      * @returns A new `StateMachine` instance with the provided implementations.
      */
-    provide(implementations: InternalMachineImplementations<TContext, TEvent, TAction, TActor, TResolvedTypesMeta, true>): StateMachine<TContext, TEvent, TAction, TActor, TInput, TOutput, AreAllImplementationsAssumedToBeProvided<TResolvedTypesMeta> extends false ? MarkAllImplementationsAsProvided<TResolvedTypesMeta> : TResolvedTypesMeta>;
+    provide(implementations: InternalMachineImplementations<TContext, TEvent, TActor, TAction, TResolvedTypesMeta, true>): StateMachine<TContext, TEvent, TActor, TAction, TGuard, TInput, TOutput, AreAllImplementationsAssumedToBeProvided<TResolvedTypesMeta> extends false ? MarkAllImplementationsAsProvided<TResolvedTypesMeta> : TResolvedTypesMeta>;
     /**
      * Resolves the given `state` to a new `State` instance relative to this machine.
      *
@@ -93,9 +93,11 @@ export declare class StateMachine<TContext extends MachineContext, TEvent extend
     /** @deprecated an internal property acting as a "phantom" type, not meant to be used at runtime */
     __TEvent: TEvent;
     /** @deprecated an internal property acting as a "phantom" type, not meant to be used at runtime */
+    __TActor: TActor;
+    /** @deprecated an internal property acting as a "phantom" type, not meant to be used at runtime */
     __TAction: TAction;
     /** @deprecated an internal property acting as a "phantom" type, not meant to be used at runtime */
-    __TActor: TActor;
+    __TGuard: TGuard;
     /** @deprecated an internal property acting as a "phantom" type, not meant to be used at runtime */
     __TInput: TInput;
     /** @deprecated an internal property acting as a "phantom" type, not meant to be used at runtime */