@xstate/react 4.0.0-alpha.1 → 4.0.0-beta.10

package/dist/xstate-react.development.esm.js

@@ -0,0 +1,168 @@
+import * as React from 'react';
+import { useEffect, useState, useCallback } from 'react';
+import { useSyncExternalStore } from 'use-sync-external-store/shim';
+import { toObserver, ActorStatus, createActor } from 'xstate';
+import useIsomorphicLayoutEffect from 'use-isomorphic-layout-effect';
+import { useSyncExternalStoreWithSelector } from 'use-sync-external-store/shim/with-selector';
+
+function useConstant(fn) {
+  const ref = React.useRef();
+  if (!ref.current) {
+    ref.current = {
+      v: fn()
+    };
+  }
+  return ref.current.v;
+}
+
+function useIdleInterpreter(machine, options) {
+  {
+    const [initialMachine] = useState(machine);
+    if (machine.config !== initialMachine.config) {
+      console.warn(`Actor logic has changed between renders. This is not supported and may lead to invalid snapshots.`);
+    }
+  }
+  const actorRef = useConstant(() => {
+    return createActor(machine, options);
+  });
+
+  // TODO: consider using `useAsapEffect` that would do this in `useInsertionEffect` is that's available
+  useIsomorphicLayoutEffect(() => {
+    actorRef.logic.implementations = machine.implementations;
+  });
+  return actorRef;
+}
+function useActorRef(machine, ...[options = {}, observerOrListener]) {
+  const actorRef = useIdleInterpreter(machine, options);
+  useEffect(() => {
+    if (!observerOrListener) {
+      return;
+    }
+    let sub = actorRef.subscribe(toObserver(observerOrListener));
+    return () => {
+      sub.unsubscribe();
+    };
+  }, [observerOrListener]);
+  useEffect(() => {
+    actorRef.start();
+    return () => {
+      actorRef.stop();
+      actorRef.status = ActorStatus.NotStarted;
+      actorRef._initState();
+    };
+  }, []);
+  return actorRef;
+}
+
+function useActor(logic, options = {}) {
+  if (!!logic && 'send' in logic && typeof logic.send === 'function') {
+    throw new Error(`useActor() expects actor logic (e.g. a machine), but received an ActorRef. Use the useSelector(actorRef, ...) hook instead to read the ActorRef's snapshot.`);
+  }
+  const actorRef = useIdleInterpreter(logic, options);
+  const getSnapshot = useCallback(() => {
+    return actorRef.getSnapshot();
+  }, [actorRef]);
+  const subscribe = useCallback(handleStoreChange => {
+    const {
+      unsubscribe
+    } = actorRef.subscribe(handleStoreChange);
+    return unsubscribe;
+  }, [actorRef]);
+  const actorSnapshot = useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+  useEffect(() => {
+    actorRef.start();
+    return () => {
+      actorRef.stop();
+      actorRef.status = ActorStatus.NotStarted;
+      actorRef._initState();
+    };
+  }, [actorRef]);
+  return [actorSnapshot, actorRef.send, actorRef];
+}
+
+function defaultCompare(a, b) {
+  return a === b;
+}
+function useSelector(actor, selector, compare = defaultCompare) {
+  const subscribe = useCallback(handleStoreChange => {
+    const {
+      unsubscribe
+    } = actor.subscribe(handleStoreChange);
+    return unsubscribe;
+  }, [actor]);
+  const boundGetSnapshot = useCallback(() => actor.getSnapshot(), [actor]);
+  const selectedSnapshot = useSyncExternalStoreWithSelector(subscribe, boundGetSnapshot, boundGetSnapshot, selector, compare);
+  return selectedSnapshot;
+}
+
+// From https://github.com/reduxjs/react-redux/blob/720f0ba79236cdc3e1115f4ef9a7760a21784b48/src/utils/shallowEqual.ts
+function is(x, y) {
+  if (x === y) {
+    return x !== 0 || y !== 0 || 1 / x === 1 / y;
+  } else {
+    return x !== x && y !== y;
+  }
+}
+function shallowEqual(objA, objB) {
+  if (is(objA, objB)) return true;
+  if (typeof objA !== 'object' || objA === null || typeof objB !== 'object' || objB === null) {
+    return false;
+  }
+  const keysA = Object.keys(objA);
+  const keysB = Object.keys(objB);
+  if (keysA.length !== keysB.length) return false;
+  for (let i = 0; i < keysA.length; i++) {
+    if (!Object.prototype.hasOwnProperty.call(objB, keysA[i]) || !is(objA[keysA[i]], objB[keysA[i]])) {
+      return false;
+    }
+  }
+  return true;
+}
+
+function createActorContext(actorLogic, interpreterOptions) {
+  const ReactContext = /*#__PURE__*/React.createContext(null);
+  const OriginalProvider = ReactContext.Provider;
+  function Provider({
+    children,
+    logic: providedLogic = actorLogic,
+    machine,
+    options: providedOptions = interpreterOptions
+  }) {
+    if (machine) {
+      throw new Error(`The "machine" prop has been deprecated. Please use "logic" instead.`);
+    }
+    const actor = useActorRef(providedLogic, providedOptions);
+    return /*#__PURE__*/React.createElement(OriginalProvider, {
+      value: actor,
+      children
+    });
+  }
+
+  // TODO: add properties to actor ref to make more descriptive
+  Provider.displayName = `ActorProvider`;
+  function useContext() {
+    const actor = React.useContext(ReactContext);
+    if (!actor) {
+      throw new Error(`You used a hook from "${Provider.displayName}" but it's not inside a <${Provider.displayName}> component.`);
+    }
+    return actor;
+  }
+  function useSelector$1(selector, compare) {
+    const actor = useContext();
+    return useSelector(actor, selector, compare);
+  }
+  return {
+    Provider: Provider,
+    useActorRef: useContext,
+    useSelector: useSelector$1
+  };
+}
+
+/**
+ * @alias useActor
+ */
+function useMachine(machine, options = {}) {
+  return useActor(machine, options);
+}
+
+export { createActorContext, shallowEqual, useActor, useActorRef, useMachine, useSelector };

package/dist/xstate-react.esm.js

@@ -1,251 +1,91 @@
-import { u as useConstant, _ as _slicedToArray } from './useConstant-94bfdbb5.esm.js';
-import { useEffect, useState, useCallback } from 'react';
+import * as React from 'react';
+import { useEffect, useCallback } from 'react';
+import { useSyncExternalStore } from 'use-sync-external-store/shim';
+import { toObserver, ActorStatus, createActor } from 'xstate';
 import useIsomorphicLayoutEffect from 'use-isomorphic-layout-effect';
 import { useSyncExternalStoreWithSelector } from 'use-sync-external-store/shim/with-selector';
-import { toObserver, InterpreterStatus, interpret } from 'xstate';
-import { useSyncExternalStore } from 'use-sync-external-store/shim';
-
-function _objectWithoutPropertiesLoose(source, excluded) {
-  if (source == null) return {};
-  var target = {};
-  var sourceKeys = Object.keys(source);
-  var key, i;
 
-  for (i = 0; i < sourceKeys.length; i++) {
-    key = sourceKeys[i];
-    if (excluded.indexOf(key) >= 0) continue;
-    target[key] = source[key];
-  }
-
-  return target;
-}
-
-function _objectWithoutProperties(source, excluded) {
-  if (source == null) return {};
-  var target = _objectWithoutPropertiesLoose(source, excluded);
-  var key, i;
-
-  if (Object.getOwnPropertySymbols) {
-    var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
-
-    for (i = 0; i < sourceSymbolKeys.length; i++) {
-      key = sourceSymbolKeys[i];
-      if (excluded.indexOf(key) >= 0) continue;
-      if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
-      target[key] = source[key];
-    }
+function useConstant(fn) {
+  const ref = React.useRef();
+  if (!ref.current) {
+    ref.current = {
+      v: fn()
+    };
   }
-
-  return target;
+  return ref.current.v;
 }
 
-var _excluded = ["context", "actors", "guards", "actions", "delays", "state"];
-function useIdleInterpreter(getMachine, options) {
-  var machine = useConstant(function () {
-    return typeof getMachine === 'function' ? getMachine() : getMachine;
+function useIdleInterpreter(machine, options) {
+  const actorRef = useConstant(() => {
+    return createActor(machine, options);
   });
 
-  if (process.env.NODE_ENV !== 'production' && typeof getMachine !== 'function') {
-    var _useState = useState(machine),
-        _useState2 = _slicedToArray(_useState, 1),
-        initialMachine = _useState2[0];
-
-    if (getMachine !== initialMachine) {
-      console.warn('Machine given to `useMachine` has changed between renders. This is not supported and might lead to unexpected results.\n' + 'Please make sure that you pass the same Machine as argument each time.');
-    }
-  }
-
-  var context = options.context,
-      actors = options.actors,
-      guards = options.guards,
-      actions = options.actions,
-      delays = options.delays,
-      rehydratedState = options.state,
-      interpreterOptions = _objectWithoutProperties(options, _excluded);
-
-  var service = useConstant(function () {
-    var machineConfig = {
-      context: context,
-      guards: guards,
-      actions: actions,
-      actors: actors,
-      delays: delays
-    };
-    var machineWithConfig = machine.provide(machineConfig);
-    return interpret(machineWithConfig, interpreterOptions);
-  }); // Make sure options are kept updated when they change.
-  // This mutation assignment is safe because the service instance is only used
-  // in one place -- this hook's caller.
-
-  useIsomorphicLayoutEffect(function () {
-    Object.assign(service.behavior.options.actions, actions);
-    Object.assign(service.behavior.options.guards, guards);
-    Object.assign(service.behavior.options.actors, actors);
-    Object.assign(service.behavior.options.delays, delays);
-  }, [actions, guards, actors, delays]);
-  return service;
+  // TODO: consider using `useAsapEffect` that would do this in `useInsertionEffect` is that's available
+  useIsomorphicLayoutEffect(() => {
+    actorRef.logic.implementations = machine.implementations;
+  });
+  return actorRef;
 }
-function useInterpret(getMachine) {
-  for (var _len = arguments.length, _ref = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
-    _ref[_key - 1] = arguments[_key];
-  }
-
-  var _ref$ = _ref[0],
-      options = _ref$ === void 0 ? {} : _ref$,
-      observerOrListener = _ref[1];
-  var service = useIdleInterpreter(getMachine, options);
-  useEffect(function () {
+function useActorRef(machine, ...[options = {}, observerOrListener]) {
+  const actorRef = useIdleInterpreter(machine, options);
+  useEffect(() => {
     if (!observerOrListener) {
       return;
     }
-
-    var sub = service.subscribe(toObserver(observerOrListener));
-    return function () {
+    let sub = actorRef.subscribe(toObserver(observerOrListener));
+    return () => {
       sub.unsubscribe();
     };
   }, [observerOrListener]);
-  useEffect(function () {
-    var rehydratedState = options.state;
-    service.start(rehydratedState ? service.behavior.createState(rehydratedState) : undefined);
-    return function () {
-      service.stop();
-      service.status = InterpreterStatus.NotStarted;
+  useEffect(() => {
+    actorRef.start();
+    return () => {
+      actorRef.stop();
+      actorRef.status = ActorStatus.NotStarted;
+      actorRef._initState();
     };
   }, []);
-  return service;
-}
-
-function identity(a) {
-  return a;
-}
-
-var isEqual = function isEqual(prevState, nextState) {
-  return prevState === nextState || nextState.changed === false;
-};
-
-// TODO: rethink how we can do this better
-var cachedRehydratedStates = new WeakMap();
-function useMachine(getMachine) {
-  for (var _len = arguments.length, _ref = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
-    _ref[_key - 1] = arguments[_key];
-  }
-
-  var _ref$ = _ref[0],
-      options = _ref$ === void 0 ? {} : _ref$;
-  // using `useIdleInterpreter` allows us to subscribe to the service *before* we start it
-  // so we don't miss any notifications
-  var service = useIdleInterpreter(getMachine, options);
-  var getSnapshot = useCallback(function () {
-    if (service.status === InterpreterStatus.NotStarted && options.state) {
-      var cached = cachedRehydratedStates.get(options.state);
-
-      if (cached) {
-        return cached;
-      }
-
-      var created = service.behavior.createState(options.state);
-      cachedRehydratedStates.set(options.state, created);
-      return created;
-    }
-
-    return service.getSnapshot();
-  }, [service]);
-  var subscribe = useCallback(function (handleStoreChange) {
-    var _service$subscribe = service.subscribe(handleStoreChange),
-        unsubscribe = _service$subscribe.unsubscribe;
-
-    return unsubscribe;
-  }, [service]);
-  var storeSnapshot = useSyncExternalStoreWithSelector(subscribe, getSnapshot, getSnapshot, identity, isEqual);
-  useEffect(function () {
-    var rehydratedState = options.state;
-    service.start(rehydratedState ? service.behavior.createState(rehydratedState) : undefined);
-    return function () {
-      service.stop();
-      service.status = InterpreterStatus.NotStarted;
-    };
-  }, []);
-  return [storeSnapshot, service.send, service];
+  return actorRef;
 }
 
-function useActor(actorRef) {
-  var subscribe = useCallback(function (handleStoreChange) {
-    var _actorRef$subscribe = actorRef.subscribe(handleStoreChange),
-        unsubscribe = _actorRef$subscribe.unsubscribe;
-
-    return unsubscribe;
-  }, [actorRef]);
-  var boundGetSnapshot = useCallback(function () {
+function useActor(logic, options = {}) {
+  const actorRef = useIdleInterpreter(logic, options);
+  const getSnapshot = useCallback(() => {
     return actorRef.getSnapshot();
   }, [actorRef]);
-  var storeSnapshot = useSyncExternalStore(subscribe, boundGetSnapshot, boundGetSnapshot);
-  var boundSend = useCallback(function (event) {
-    return actorRef.send(event);
+  const subscribe = useCallback(handleStoreChange => {
+    const {
+      unsubscribe
+    } = actorRef.subscribe(handleStoreChange);
+    return unsubscribe;
+  }, [actorRef]);
+  const actorSnapshot = useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+  useEffect(() => {
+    actorRef.start();
+    return () => {
+      actorRef.stop();
+      actorRef.status = ActorStatus.NotStarted;
+      actorRef._initState();
+    };
   }, [actorRef]);
-  return [storeSnapshot, boundSend];
+  return [actorSnapshot, actorRef.send, actorRef];
 }
 
 function defaultCompare(a, b) {
   return a === b;
 }
-
-function useSelector(actor, selector) {
-  var compare = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : defaultCompare;
-  var subscribe = useCallback(function (handleStoreChange) {
-    var _actor$subscribe = actor.subscribe(handleStoreChange),
-        unsubscribe = _actor$subscribe.unsubscribe;
-
+function useSelector(actor, selector, compare = defaultCompare) {
+  const subscribe = useCallback(handleStoreChange => {
+    const {
+      unsubscribe
+    } = actor.subscribe(handleStoreChange);
     return unsubscribe;
   }, [actor]);
-  var boundGetSnapshot = useCallback(function () {
-    return actor.getSnapshot();
-  }, [actor]);
-  var selectedSnapshot = useSyncExternalStoreWithSelector(subscribe, boundGetSnapshot, boundGetSnapshot, selector, compare);
+  const boundGetSnapshot = useCallback(() => actor.getSnapshot(), [actor]);
+  const selectedSnapshot = useSyncExternalStoreWithSelector(subscribe, boundGetSnapshot, boundGetSnapshot, selector, compare);
   return selectedSnapshot;
 }
 
-/**
- * React hook that spawns an `ActorRef` with the specified `behavior`.
- * The returned `ActorRef` can be used with the `useActor(actorRef)` hook.
- *
- * @param behavior The actor behavior to spawn
- * @returns An ActorRef with the specified `behavior`
- */
-
-function useSpawn(behavior) {
-  var actorRef = useConstant(function () {
-    // TODO: figure out what to do about the name argument
-    return interpret(behavior);
-  });
-  useEffect(function () {
-    var _actorRef$start;
-
-    (_actorRef$start = actorRef.start) === null || _actorRef$start === void 0 ? void 0 : _actorRef$start.call(actorRef);
-    return function () {
-      var _stop, _ref;
-
-      (_stop = (_ref = actorRef).stop) === null || _stop === void 0 ? void 0 : _stop.call(_ref);
-    };
-  }, []);
-  return actorRef;
-}
-
-function _typeof(obj) {
-  "@babel/helpers - typeof";
-
-  if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
-    _typeof = function (obj) {
-      return typeof obj;
-    };
-  } else {
-    _typeof = function (obj) {
-      return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
-    };
-  }
-
-  return _typeof(obj);
-}
-
 // From https://github.com/reduxjs/react-redux/blob/720f0ba79236cdc3e1115f4ef9a7760a21784b48/src/utils/shallowEqual.ts
 function is(x, y) {
   if (x === y) {
@@ -254,25 +94,66 @@ function is(x, y) {
     return x !== x && y !== y;
   }
 }
-
 function shallowEqual(objA, objB) {
   if (is(objA, objB)) return true;
-
-  if (_typeof(objA) !== 'object' || objA === null || _typeof(objB) !== 'object' || objB === null) {
+  if (typeof objA !== 'object' || objA === null || typeof objB !== 'object' || objB === null) {
     return false;
   }
-
-  var keysA = Object.keys(objA);
-  var keysB = Object.keys(objB);
+  const keysA = Object.keys(objA);
+  const keysB = Object.keys(objB);
   if (keysA.length !== keysB.length) return false;
-
-  for (var i = 0; i < keysA.length; i++) {
+  for (let i = 0; i < keysA.length; i++) {
     if (!Object.prototype.hasOwnProperty.call(objB, keysA[i]) || !is(objA[keysA[i]], objB[keysA[i]])) {
       return false;
     }
   }
-
   return true;
 }
 
-export { shallowEqual, useActor, useInterpret, useMachine, useSelector, useSpawn };
+function createActorContext(actorLogic, interpreterOptions) {
+  const ReactContext = /*#__PURE__*/React.createContext(null);
+  const OriginalProvider = ReactContext.Provider;
+  function Provider({
+    children,
+    logic: providedLogic = actorLogic,
+    machine,
+    options: providedOptions = interpreterOptions
+  }) {
+    if (machine) {
+      throw new Error(`The "machine" prop has been deprecated. Please use "logic" instead.`);
+    }
+    const actor = useActorRef(providedLogic, providedOptions);
+    return /*#__PURE__*/React.createElement(OriginalProvider, {
+      value: actor,
+      children
+    });
+  }
+
+  // TODO: add properties to actor ref to make more descriptive
+  Provider.displayName = `ActorProvider`;
+  function useContext() {
+    const actor = React.useContext(ReactContext);
+    if (!actor) {
+      throw new Error(`You used a hook from "${Provider.displayName}" but it's not inside a <${Provider.displayName}> component.`);
+    }
+    return actor;
+  }
+  function useSelector$1(selector, compare) {
+    const actor = useContext();
+    return useSelector(actor, selector, compare);
+  }
+  return {
+    Provider: Provider,
+    useActorRef: useContext,
+    useSelector: useSelector$1
+  };
+}
+
+/**
+ * @alias useActor
+ */
+function useMachine(machine, options = {}) {
+  return useActor(machine, options);
+}
+
+export { createActorContext, shallowEqual, useActor, useActorRef, useMachine, useSelector };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xstate/react",
-  "version": "4.0.0-alpha.1",
+  "version": "4.0.0-beta.10",
   "description": "XState tools for React",
   "keywords": [
     "state",
@@ -18,21 +18,32 @@
   "main": "dist/xstate-react.cjs.js",
   "module": "dist/xstate-react.esm.js",
   "exports": {
-    "./fsm": {
-      "module": "./fsm/dist/xstate-react-fsm.esm.js",
-      "default": "./fsm/dist/xstate-react-fsm.cjs.js"
-    },
     ".": {
+      "types": {
+        "import": "./dist/xstate-react.cjs.mjs",
+        "default": "./dist/xstate-react.cjs.js"
+      },
+      "development": {
+        "module": "./dist/xstate-react.development.esm.js",
+        "import": "./dist/xstate-react.development.cjs.mjs",
+        "default": "./dist/xstate-react.development.cjs.js"
+      },
       "module": "./dist/xstate-react.esm.js",
+      "import": "./dist/xstate-react.cjs.mjs",
       "default": "./dist/xstate-react.cjs.js"
     },
     "./package.json": "./package.json"
   },
+  "imports": {
+    "#is-development": {
+      "development": "./src/true.ts",
+      "default": "./src/false.ts"
+    }
+  },
   "types": "dist/xstate-react.cjs.d.ts",
   "sideEffects": false,
   "files": [
-    "dist",
-    "fsm"
+    "dist"
   ],
   "repository": {
     "type": "git",
@@ -43,39 +54,28 @@
     "url": "https://github.com/statelyai/xstate/issues"
   },
   "peerDependencies": {
-    "@xstate/fsm": "^3.0.0-alpha.0",
     "react": "^16.8.0 || ^17.0.0 || ^18.0.0",
-    "xstate": "^5.0.0-alpha.1"
+    "xstate": "^5.0.0-beta.29"
   },
   "peerDependenciesMeta": {
-    "@xstate/fsm": {
-      "optional": true
-    },
     "xstate": {
       "optional": true
     }
   },
   "dependencies": {
-    "use-isomorphic-layout-effect": "^1.0.0",
+    "use-isomorphic-layout-effect": "^1.1.2",
     "use-sync-external-store": "^1.0.0"
   },
   "devDependencies": {
-    "@testing-library/react": "^13.0.0",
+    "@testing-library/react": "^13.4.0",
     "@types/jsdom": "^12.2.3",
     "@types/react": "^17.0.43",
     "@types/react-dom": "^17.0.14",
     "@types/use-sync-external-store": "^0.0.3",
-    "@xstate/fsm": "3.0.0-alpha.0",
     "jsdom": "^14.0.0",
     "jsdom-global": "^3.0.2",
     "react": "^18.0.0",
     "react-dom": "^18.0.0",
-    "xstate": "5.0.0-alpha.1"
-  },
-  "preconstruct": {
-    "entrypoints": [
-      "./index.ts",
-      "./fsm.ts"
-    ]
+    "xstate": "5.0.0-beta.29"
   }
 }

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

@@ -1,3 +0,0 @@
-import { MachineImplementationsFrom, ServiceFrom, StateFrom, StateMachine } from '@xstate/fsm';
-export declare function useMachine<TMachine extends StateMachine.AnyMachine>(stateMachine: TMachine, options?: MachineImplementationsFrom<TMachine>): [StateFrom<TMachine>, ServiceFrom<TMachine>['send'], ServiceFrom<TMachine>];
-export declare function useService<TService extends StateMachine.AnyService>(service: TService): [StateFrom<TService>, TService['send'], TService];

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

@@ -1,15 +0,0 @@
-import { EventObject, MachineContext, StateConfig } from 'xstate';
-export declare type MaybeLazy<T> = T | (() => T);
-export declare type NoInfer<T> = [T][T extends any ? 0 : any];
-export declare type Prop<T, K> = K extends keyof T ? T[K] : never;
-export interface UseMachineOptions<TContext extends MachineContext, TEvent extends EventObject> {
-    /**
-     * If provided, will be merged with machine's `context`.
-     */
-    context?: Partial<TContext>;
-    /**
-     * The state to rehydrate the machine to. The machine will
-     * start at this state instead of its `initialState`.
-     */
-    state?: StateConfig<TContext, TEvent>;
-}

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

@@ -1 +0,0 @@
-export default function useConstant<T>(fn: () => T): T;

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

@@ -1,13 +0,0 @@
-import { AnyInterpreter, AnyStateMachine, AreAllImplementationsAssumedToBeProvided, InternalMachineImplementations, InterpreterFrom, InterpreterOptions, MachineImplementations, Observer, StateFrom } from 'xstate';
-import { MaybeLazy } from './types';
-import { UseMachineOptions } from './useMachine';
-export declare function useIdleInterpreter(getMachine: MaybeLazy<AnyStateMachine>, options: Partial<InterpreterOptions> & Partial<UseMachineOptions<any, never>> & Partial<MachineImplementations<any, never>>): AnyInterpreter;
-declare type RestParams<TMachine extends AnyStateMachine> = AreAllImplementationsAssumedToBeProvided<TMachine['__TResolvedTypesMeta']> extends false ? [
-    options: InterpreterOptions & UseMachineOptions<TMachine['__TContext'], TMachine['__TEvent']> & InternalMachineImplementations<TMachine['__TContext'], TMachine['__TEvent'], TMachine['__TResolvedTypesMeta'], true>,
-    observerOrListener?: Observer<StateFrom<TMachine>> | ((value: StateFrom<TMachine>) => void)
-] : [
-    options?: InterpreterOptions & UseMachineOptions<TMachine['__TContext'], TMachine['__TEvent']> & InternalMachineImplementations<TMachine['__TContext'], TMachine['__TEvent'], TMachine['__TResolvedTypesMeta']>,
-    observerOrListener?: Observer<StateFrom<TMachine>> | ((value: StateFrom<TMachine>) => void)
-];
-export declare function useInterpret<TMachine extends AnyStateMachine>(getMachine: MaybeLazy<TMachine>, ...[options, observerOrListener]: RestParams<TMachine>): InterpreterFrom<TMachine>;
-export {};