@koordinates/xstate-tree 1.0.0-beta.1

package/lib/xstate-tree.d.ts

@@ -0,0 +1,580 @@
+import { AnyEventObject } from 'xstate';
+import { AnyStateMachine } from 'xstate';
+import { BaseActionObject } from 'xstate';
+import { ComponentPropsWithRef } from 'react';
+import { EventObject } from 'xstate';
+import { History as History_2 } from 'history';
+import { Interpreter } from 'xstate';
+import { JSXElementConstructor } from 'react';
+import { NoInfer } from 'xstate';
+import { ParsedQuery } from 'query-string';
+import { default as React_2 } from 'react';
+import { ResolveTypegenMeta } from 'xstate';
+import { ServiceMap } from 'xstate';
+import { StateMachine } from 'xstate';
+import { TypegenDisabled } from 'xstate';
+import { Typestate } from 'xstate';
+import * as Z from 'zod';
+
+/**
+ * @public
+ */
+export declare type AnyRoute = {
+    matches: (url: string, search: string) => any;
+    reverse: any;
+    navigate: any;
+    getEvent: any;
+    event: string;
+    url?: string;
+    basePath: string;
+    history: XstateTreeHistory;
+    parent?: AnyRoute;
+    paramsSchema?: Z.ZodObject<any>;
+    querySchema?: Z.ZodObject<any>;
+};
+
+/**
+ * @public
+ */
+export declare type ArgumentsForRoute<T> = T extends Route<infer TParams, infer TQuery, any, infer TMeta> ? RouteArguments<TParams, TQuery, TMeta> : never;
+
+/**
+ * @public
+ */
+export declare function broadcast(event: GlobalEvents): void;
+
+/**
+ * @public
+ */
+export declare function buildActions<TContext, TEvent extends EventObject, TTypestate extends Typestate<TContext>, TActions, TSelectors, TSend = (send: TEvent) => void>(__machine: StateMachine<TContext, any, TEvent, TTypestate, any, any, any>, __selectors: Selectors<TContext, TEvent, TSelectors, TTypestate["value"]>, actions: (send: TSend, selectors: TSelectors) => TActions): (send: TSend, selectors: TSelectors) => TActions;
+
+/**
+ * @public
+ */
+export declare function buildCreateRoute(history: XstateTreeHistory, basePath: string): {
+    /**
+     * Creates a dynamic Route using the supplied options
+     *
+     * The return value of dynamicRoute is a function that accepts the routes "dynamic" options
+     * The argument to dynamicRoute itself is the params/query/meta schemas defining the route
+     *
+     * The returned function accepts a singular option object with the following fields
+     *
+     * `event`, the string constant for the routes event
+     * `matches`, a function that is passed a url/query string and determines if the route matches
+     * if the route is matched it returns the extracted params/query objects
+     * `reverse`, a function that is passed params/query objects and turns them into a URL
+     *
+     * The params and query schemas are ZodSchemas, they both need to be an object (ie Z.object())
+     */
+    dynamicRoute: <TOpts extends Options<Z.ZodObject<any, "strip", Z.ZodTypeAny, {
+        [x: string]: any;
+    }, {
+        [x: string]: any;
+    }>, Z.ZodObject<any, "strip", Z.ZodTypeAny, {
+        [x: string]: any;
+    }, {
+        [x: string]: any;
+    }>, any>>(opts?: TOpts | undefined) => <TEvent extends string, TParamsSchema = Params<TOpts>, TQuerySchema = Query<TOpts>, TMeta = Meta<TOpts>, TParams = TParamsSchema extends Z.ZodObject<any, "strip", Z.ZodTypeAny, {
+        [x: string]: any;
+    }, {
+        [x: string]: any;
+    }> ? Z.TypeOf<TParamsSchema> : undefined, TQuery = TQuerySchema extends Z.ZodObject<any, "strip", Z.ZodTypeAny, {
+        [x: string]: any;
+    }, {
+        [x: string]: any;
+    }> ? Z.TypeOf<TQuerySchema> : undefined, TFullMeta = TMeta extends undefined ? SharedMeta : TMeta & SharedMeta>({ event, matches, reverse, }: {
+        event: TEvent;
+        matches: (url: string, query: ParsedQuery<string>) => false | RouteArguments<TParams, TQuery, TFullMeta>;
+        reverse: RouteArgumentFunctions<string, TParams, TQuery, TFullMeta, RouteArguments<TParams, TQuery, TFullMeta>>;
+    }) => Route<TParams, TQuery, TEvent, TFullMeta>;
+    /**
+     * Creates a static Route using the supplied options
+     *
+     * The return value of staticRoute is a function that accepts the routes options
+     * The only argument to staticRoute itself is an optional parent route
+     *
+     * The returned function accepts 3 arguments
+     *
+     * 1. URL of the route
+     * 2. The event type of the route
+     * 3. The routes options, params schema, query schema and meta type
+     *
+     * The params and query schemas are ZodSchemas, they both need to be an object (ie Z.object())
+     *
+     * When creating a route that has a parent route, the following happens
+     *
+     * 1. The parent routes url is prepended to the routes URL
+     * 2. The parents params schema is merged with the routes schema
+     * 3. The parents meta type is merged with the routes meta type
+     */
+    staticRoute: <TBaseRoute extends AnyRoute | undefined = undefined, TBaseParams = RouteParams<TBaseRoute>, TBaseMeta = RouteMeta<TBaseRoute>>(baseRoute?: TBaseRoute | undefined) => <TOpts_1 extends Options<Z.ZodObject<any, "strip", Z.ZodTypeAny, {
+        [x: string]: any;
+    }, {
+        [x: string]: any;
+    }>, Z.ZodObject<any, "strip", Z.ZodTypeAny, {
+        [x: string]: any;
+    }, {
+        [x: string]: any;
+    }>, any>, TEvent_1 extends string, TParamsSchema_1 = Params<TOpts_1>, TQuerySchema_1 = Query<TOpts_1>, TMeta_1 = Meta<TOpts_1>, TParams_1 = TParamsSchema_1 extends Z.ZodObject<any, "strip", Z.ZodTypeAny, {
+        [x: string]: any;
+    }, {
+        [x: string]: any;
+    }> ? Z.TypeOf<TParamsSchema_1> : undefined, TQuery_1 = TQuerySchema_1 extends Z.ZodObject<any, "strip", Z.ZodTypeAny, {
+        [x: string]: any;
+    }, {
+        [x: string]: any;
+    }> ? Z.TypeOf<TQuerySchema_1> : undefined, TFullParams = TParams_1 extends undefined ? TBaseParams extends undefined ? undefined : TBaseParams : TParams_1 & (TBaseParams extends undefined ? {} : TBaseParams), TFullMeta_1 = TMeta_1 extends undefined ? TBaseMeta extends undefined ? SharedMeta : TBaseMeta & SharedMeta : TMeta_1 & (TBaseMeta extends undefined ? {} : TBaseMeta) & SharedMeta>(url: string, event: TEvent_1, opts?: TOpts_1 | undefined) => Route<TFullParams, TQuery_1, TEvent_1, TFullMeta_1>;
+};
+
+/**
+ * @public
+ */
+export declare function buildRootComponent<TContext, TEvent extends EventObject, TTypeState extends Typestate<TContext>, TSelectors, TActions, TSlots extends readonly Slot[]>(machine: StateMachine<TContext, XstateTreeMachineStateSchema<TContext, TEvent, TTypeState, TSelectors, TActions, TSlots>, TEvent, TTypeState>, routing?: {
+    routes: Route<any, any, any, any>[];
+    history: History_2<{
+        meta?: any;
+    }>;
+    basePath: string;
+    getPathName?: () => string;
+    getQueryString?: () => string;
+}): {
+    (): JSX.Element | null;
+    rootMachine: StateMachine<TContext, XstateTreeMachineStateSchema<TContext, TEvent, TTypeState, TSelectors, TActions, TSlots, Interpreter<TContext, any, TEvent, TTypeState, TypegenDisabled>>, TEvent, TTypeState, BaseActionObject, ServiceMap, ResolveTypegenMeta<TypegenDisabled, NoInfer<TEvent>, BaseActionObject, ServiceMap>>;
+};
+
+/**
+ * @public
+ */
+export declare function buildSelectors<TContext, TEvent extends EventObject, TTypestate extends Typestate<TContext>, TSelectors>(__machine: StateMachine<TContext, any, TEvent, TTypestate, any, any, any>, selectors: Selectors<TContext, TEvent, TSelectors, TTypestate["value"]>): (ctx: TContext, canHandleEvent: (e: TEvent) => boolean, inState: (state: TTypestate["value"]) => boolean, currentState: TTypestate["value"]) => TSelectors;
+
+/**
+ * @internal
+ * Builds a root component for use in Storybook
+ *
+ * Pass in an initial state and context and the machine will start from that state
+ *
+ * This does _not_ work for any machines using slots, nothing will be invoked unless
+ * it would be invoked by the state you have chosen the machine to start in
+ *
+ * XState will not run any invoke handlers for parent states or sibling states that
+ * would be passed through if the machine was executing normally
+ *
+ * I have no solutions for this
+ */
+export declare function buildStorybookComponent<TContext, TEvent extends EventObject, TTypeState extends Typestate<TContext>, TSelectors, TActions, TSlots extends readonly Slot[]>(machine: StateMachine<TContext, XstateTreeMachineStateSchema<TContext, TEvent, TTypeState, TSelectors, TActions, TSlots>, TEvent, TTypeState>, state?: TTypeState["value"], context?: TContext): () => JSX.Element | null;
+
+/**
+ * @public
+ *
+ * Sets up a root component for use in an \@xstate/test model backed by \@testing-library/react for the component
+ *
+ * The logger argument should just be a simple function which forwards the arguments to console.log,
+ * this is needed because Wallaby.js only displays console logs in tests that come from source code, not library code,
+ * so any logs from inside this file don't show up in the test explorer
+ *
+ * The returned object has a `rootComponent` property and a function, `awaitTransition`, that returns a Promise
+ * when called that is resolved the next time the underlying machine transitions. This can be used in the \@xstate/test
+ * model to ensure after an event action is executed the test in the next state doesn't run until after the machine transitions
+ *
+ * It also delays for 5ms to ensure any React re-rendering happens in response to the state transition
+ */
+export declare function buildTestRootComponent<TContext, TEvent extends EventObject, TTypeState extends Typestate<TContext>, TSelectors, TActions, TSlots extends readonly Slot[]>(machine: StateMachine<TContext, XstateTreeMachineStateSchema<TContext, TEvent, TTypeState, TSelectors, TActions, TSlots>, TEvent, TTypeState>, logger: typeof console.log): {
+    rootComponent: () => JSX.Element | null;
+    addTransitionListener: (listener: () => void) => void;
+    awaitTransition(): Promise<void>;
+};
+
+/**
+ * @public
+ */
+export declare function buildView<TContext, TEvent extends EventObject, TTypestate extends Typestate<TContext>, TActions, TSelectors, TSlots extends readonly Slot[] = [], TViewProps = ViewProps<TSelectors, TActions, TSlots, TTypestate["value"]>, TSend = (send: TEvent) => void>(__machine: StateMachine<TContext, any, TEvent, TTypestate, any, any, any>, __selectors: Selectors<TContext, TEvent, TSelectors, TTypestate["value"]>, __actions: (send: TSend, selectors: TSelectors) => TActions, __slots: TSlots, view: React_2.ComponentType<TViewProps>): React_2.ComponentType<TViewProps>;
+
+/**
+ * @public
+ */
+export declare function buildViewProps<C extends keyof JSX.IntrinsicElements | JSXElementConstructor<any>>(_view: C, props: Pick<InferViewProps<PropsOf<C>>, "actions" | "selectors">): InferViewProps<PropsOf<C>>;
+
+/**
+ * @public
+ */
+export declare function buildXStateTreeMachine<TContext, TEvent extends EventObject, TTypestate extends Typestate<TContext>, TSelectors = unknown, TActions = unknown, TInterpreter extends Interpreter<TContext, any, TEvent, TTypestate> = Interpreter<TContext, any, TEvent, TTypestate>, TSlots extends readonly Slot[] = Slot[]>(machine: StateMachine<TContext, any, TEvent, TTypestate, any, any, any>, meta: XStateTreeMachineMeta<TContext, TEvent, TTypestate, TSelectors, TActions, TInterpreter, TSlots>): StateMachine<TContext, XstateTreeMachineStateSchema<TContext, TEvent, TTypestate, TSelectors, TActions, TSlots, TInterpreter>, TEvent, TTypestate, any, any, any>;
+
+declare type Context = {};
+
+declare type EmptyKeys<T> = keyof {
+    [K in keyof T as IsEmptyObject<T[K], true> extends true ? K : never]: T[K];
+};
+
+declare type EmptyRouteArguments<TParams, TQuery> = IsEmptyObject<TParams, true> extends true ? IsEmptyObject<TQuery, true> extends true ? true : false : false;
+
+declare type Events = any;
+
+/**
+ * @public
+ */
+export declare const genericSlotsTestingDummy: any;
+
+/**
+ * @internal
+ */
+export declare type GetSlotNames<TSlots extends readonly Slot[]> = TSlots[number]["name"];
+
+/**
+ * @public
+ * Extracts the properties defined on the XstateTreeEvents interface and converts them
+ * into proper event objects.
+ *
+ * Properties extending `string` have no payloads, any other type is the payload for the event
+ * The property name is extracted as the `type` of the event
+ */
+export declare type GlobalEvents = {
+    [I in keyof XstateTreeEvents]: XstateTreeEvents[I] extends string ? {
+        type: I;
+    } : XstateTreeEvents[I] & {
+        type: I;
+    };
+}[keyof XstateTreeEvents];
+
+declare type InferViewProps<T> = T extends ViewProps<infer TSelectors, infer TActions, never, infer TStates> ? {
+    selectors: TSelectors;
+    actions: TActions;
+    inState: (state: TStates) => (state: TStates) => boolean;
+} : never;
+
+declare type IsEmptyObject<Obj, ExcludeOptional extends boolean = false> = [
+keyof (ExcludeOptional extends true ? OmitOptional<Obj> : Obj)
+] extends [never] ? true : false;
+
+/**
+ * @public
+ * Wraps an xstate-tree returning Promise (generated by `import()` in an xstate-tree machine responsible for
+ * booting up the machine upon resolution
+ *
+ * @param factory - the factory function that returns the promise that resolves to the machine
+ * @param options - configure loading component and context to invoke machine with
+ * @returns an xstate-tree machine that wraps the promise, invoking the resulting machine when it resolves
+ */
+export declare function lazy<TMachine extends AnyStateMachine>(factory: () => Promise<TMachine>, { Loader, withContext, }?: Options_2<TMachine["context"]>): StateMachine<Context, any, Events, States, any, any, any>;
+
+/**
+ * @public
+ * Renders an anchor tag pointing at the provided Route
+ *
+ * The query/params/meta props are conditionally required based on the
+ * route passed as the To parameter
+ */
+export declare function Link<TRoute extends AnyRoute>({ to, children, testId, ...rest }: LinkProps<TRoute>): JSX.Element;
+
+/**
+ * @public
+ */
+export declare type LinkProps<TRoute extends AnyRoute, TRouteParams = TRoute extends Route<infer TParams, any, any, any> ? TParams : undefined, TRouteQuery = TRoute extends Route<any, infer TQuery, any, any> ? TQuery : undefined, TRouteMeta = TRoute extends Route<any, any, any, infer TMeta> ? TMeta : undefined> = {
+    to: TRoute;
+    children: React_2.ReactNode;
+    testId?: string;
+    /**
+     * onClick works as normal, but if you return false from it the navigation will not happen
+     */
+    onClick?: (e: React_2.MouseEvent<HTMLAnchorElement>) => boolean | void;
+} & RouteArguments<TRouteParams, TRouteQuery, TRouteMeta> & Omit<React_2.AnchorHTMLAttributes<HTMLAnchorElement>, "href" | "onClick">;
+
+/**
+ * @public
+ */
+export declare function loggingMetaOptions<TEvents extends EventObject, TContext>(ignoredEvents: TEvents["type"][], ignoreContext?: (keyof TContext)[] | undefined): {
+    xstateTree: {
+        ignoredEvents: Map<string, boolean>;
+        ignoreContext: (keyof TContext)[] | undefined;
+    };
+};
+
+declare type MakeEmptyObjectPropertiesOptional<T> = Omit<T, EmptyKeys<T>> & Partial<Pick<T, EmptyKeys<T>>>;
+
+/**
+ * @public
+ */
+export declare function matchRoute<TRoutes extends Route<any, any, any, any>[]>(routes: TRoutes, basePath: string, path: string, search: string): Return;
+
+declare type Meta<T> = T extends {
+    meta: infer TMeta;
+} ? TMeta : undefined;
+
+declare type MultiSlot<T> = {
+    type: SlotType.MultiSlot;
+    name: T;
+    getId(id: string): string;
+};
+
+/**
+ * @public
+ */
+export declare function multiSlot<T extends string>(name: T): MultiSlot<T>;
+
+declare type OmitOptional<T> = {
+    [P in keyof Required<T> as Pick<T, P> extends Required<Pick<T, P>> ? P : never]: T[P];
+};
+
+/**
+ * @public
+ */
+export declare function onBroadcast(handler: (event: GlobalEvents) => void): () => void;
+
+declare type Options<TParamsSchema extends Z.ZodObject<any>, TQuerySchema extends Z.ZodObject<any>, TMetaSchema> = {
+    params?: TParamsSchema;
+    query?: TQuerySchema;
+    meta?: TMetaSchema;
+};
+
+declare type Options_2<TContext> = {
+    /**
+     * Displayed while the promise is resolving, defaults to returning null
+     */
+    Loader?: React_2.ComponentType;
+    /**
+     * Allows you to specify an overriden context when the machine is invoked
+     * Automatically supplies the machines default context so only requires a partial of overrides
+     */
+    withContext?: () => Partial<TContext>;
+};
+
+declare type Params<T> = T extends {
+    params: infer TParams;
+} ? TParams : undefined;
+
+/**
+ * @public
+ *
+ * Extracts the event objects for the specified event types from the GlobalEvents union
+ */
+export declare type PickEvent<T extends Extract<GlobalEvents, {
+    type: string;
+}>["type"]> = Extract<GlobalEvents, {
+    type: T;
+}>;
+
+declare type PropsOf<C extends keyof JSX.IntrinsicElements | JSXElementConstructor<any>> = JSX.LibraryManagedAttributes<C, ComponentPropsWithRef<C>>;
+
+declare type Query<T> = T extends {
+    query: infer TQuery;
+} ? TQuery : undefined;
+
+declare type Return = {
+    type: "matched";
+    route: AnyRoute;
+    event: RoutingEvent<Route<any, any, any, any>>;
+} | {
+    type: "no-matches";
+} | {
+    type: "match-error";
+};
+
+/**
+ * @public
+ */
+export declare type Route<TParams, TQuery, TEvent, TMeta> = {
+    /**
+     * Returns an event object for this route, or undefined if the route does not match
+     *
+     * The params are automatically extracted out of the url
+     * The query data is automatically extracted out the search
+     *
+     * The params/query objects are validated against the routes Zod schemas
+     * if they fail to validate an error is thrown
+     *
+     * @param url - the pathname portion of a url, this function expects the base path to have been stripped
+     * @param search - the query string information (ie "?foo=bar")
+     * @returns undefined if the route doesn't match the supplied url, event object otherwise
+     * @throws Error if the params or query schemas fail to parse the params/query objects
+     */
+    matches: (url: string, search: string) => ({
+        type: TEvent;
+        originalUrl: string;
+    } & RouteArguments<TParams, TQuery, TMeta>) | undefined;
+    /**
+     * Takes in query/params objects as required by the route and returns a URL for that route
+     *
+     * The returned URL does not contain the base path
+     *
+     * Reverse can't do anything with meta arguments, so they are removed from the types
+     */
+    reverse: RouteArgumentFunctions<string, TParams, TQuery, undefined>;
+    /**
+     * Takes in query/params/meta objects as required by the route and updates the
+     * url via History.push
+     */
+    navigate: RouteArgumentFunctions<void, TParams, TQuery, TMeta>;
+    /**
+     * Returns an event object for this route based on the supplied params/query/meta
+     *
+     * Primarily intended for internal use
+     */
+    getEvent: RouteArgumentFunctions<{
+        type: TEvent;
+    } & RouteArguments<TParams, TQuery, TMeta>, TParams, TQuery, TMeta>;
+    event: TEvent;
+    url?: string;
+    history: XstateTreeHistory;
+    basePath: string;
+    parent?: AnyRoute;
+    paramsSchema?: Z.ZodObject<any>;
+    querySchema?: Z.ZodObject<any>;
+};
+
+declare type RouteArgumentFunctions<TReturn, TParams, TQuery, TMeta, TArgs = RouteArguments<TParams, TQuery, TMeta>> = IsEmptyObject<TArgs> extends true ? () => TReturn : keyof TArgs extends "meta" ? (args?: TArgs) => TReturn : EmptyRouteArguments<TParams, TQuery> extends true ? (args?: Partial<TArgs>) => TReturn : (args: MakeEmptyObjectPropertiesOptional<TArgs>) => TReturn;
+
+declare type RouteArguments<TParams, TQuery, TMeta> = TParams extends undefined ? TQuery extends undefined ? TMeta extends undefined ? {} : {
+    meta?: TMeta;
+} : TMeta extends undefined ? {
+    query: TQuery;
+} : {
+    query: TQuery;
+    meta?: TMeta;
+} : TQuery extends undefined ? TMeta extends undefined ? {
+    params: TParams;
+} : {
+    params: TParams;
+    meta?: TMeta;
+} : TMeta extends undefined ? {
+    params: TParams;
+    query: TQuery;
+} : {
+    params: TParams;
+    query: TQuery;
+    meta?: TMeta;
+};
+
+/**
+ * @public
+ */
+declare type RouteMeta<T> = T extends Route<any, any, any, infer TMeta> ? TMeta : undefined;
+
+/**
+ * @public
+ */
+export declare type RouteParams<T> = T extends Route<infer TParams, any, any, any> ? TParams : undefined;
+
+/**
+ * @public
+ */
+export declare type Routing404Event = {
+    type: "ROUTING_404";
+    url: string;
+};
+
+/**
+ * @public
+ * Converts a Route type into the Event that will be broadcast for that route
+ *
+ * All routes a machine should handle should be added to the machines event union using this type
+ */
+export declare type RoutingEvent<T> = T extends Route<infer TParams, infer TQuery, infer TEvent, infer TMeta> ? {
+    type: TEvent;
+    originalUrl: string;
+    params: TParams;
+    query: TQuery;
+    meta: TMeta;
+} : never;
+
+declare type Selectors<TContext, TEvent extends EventObject, TSelectors, TStates> = (ctx: TContext, canHandleEvent: (e: TEvent) => boolean, inState: (state: TStates) => boolean, __currentState: TStates) => TSelectors;
+
+declare type SharedMeta = {
+    /**
+     * Suppresses this routing change event from being picked up by react-router
+     */
+    doNotNotifyReactRouter?: boolean;
+    /**
+     * True if this was the last routing event in the chain
+     */
+    indexEvent?: boolean;
+    /**
+     * If true, use history.replace instead history.push
+     */
+    replace?: boolean;
+};
+
+declare type SingleSlot<T> = {
+    type: SlotType.SingleSlot;
+    name: T;
+    getId(): string;
+};
+
+/**
+ * @public
+ */
+export declare function singleSlot<T extends string>(name: T): SingleSlot<T>;
+
+/**
+ * @public
+ */
+export declare type Slot = SingleSlot<any> | MultiSlot<any>;
+
+/**
+ * @public
+ */
+export declare function slotTestingDummyFactory(name: string): StateMachine<unknown, XstateTreeMachineStateSchema<unknown, AnyEventObject, {
+    value: any;
+    context: unknown;
+}, {}, {}, never[], Interpreter<unknown, any, AnyEventObject, {
+value: any;
+context: unknown;
+}, TypegenDisabled>>, AnyEventObject, {
+    value: any;
+    context: unknown;
+}, any, any, any>;
+
+declare enum SlotType {
+    SingleSlot = 0,
+    MultiSlot = 1
+}
+
+declare type States = {
+    value: "loading";
+    context: Context;
+} | {
+    value: "rendering";
+    context: Context;
+};
+
+/**
+ * @public
+ */
+export declare type StyledLink<TStyleProps = {}> = <TRoute extends AnyRoute>(props: LinkProps<TRoute> & TStyleProps) => JSX.Element;
+
+/**
+ * @public
+ */
+export declare type ViewProps<TSelectors, TActions, TSlots extends readonly Slot[], TState> = {
+    slots: Record<GetSlotNames<TSlots>, React_2.ComponentType>;
+    actions: TActions;
+    selectors: TSelectors;
+    inState: (state: TState) => boolean;
+};
+
+/**
+ * @public
+ */
+export declare type XstateTreeHistory = History_2<{
+    meta?: unknown;
+    previousUrl?: string;
+}>;
+
+/**
+ * @public
+ */
+export declare type XStateTreeMachineMeta<TContext, TEvent extends EventObject, TTypestate extends Typestate<TContext>, TSelectors = unknown, TActions = unknown, TInterpreter extends Interpreter<TContext, any, TEvent, TTypestate> = Interpreter<TContext, any, TEvent, TTypestate>, TSlots extends readonly Slot[] = Slot[]> = {
+    slots: TSlots;
+    view: React_2.ComponentType<ViewProps<TSelectors, TActions, TSlots, TTypestate["value"]>>;
+    selectors: (ctx: TContext, canHandleEvent: (e: TEvent) => boolean, inState: (state: TTypestate["value"]) => boolean, _state: TTypestate["value"]) => TSelectors;
+    actions: (send: TInterpreter["send"], selectors: TSelectors) => TActions;
+    xstateTreeMachine?: true;
+};
+
+/**
+ * @public
+ */
+export declare type XstateTreeMachineStateSchema<TContext, TEvent extends EventObject, TTypestate extends Typestate<TContext>, TSelectors = unknown, TActions = unknown, TSlots extends readonly Slot[] = Slot[], TInterpreter extends Interpreter<TContext, any, TEvent, TTypestate> = Interpreter<TContext, any, TEvent, TTypestate>> = {
+    meta: XStateTreeMachineMeta<TContext, TEvent, TTypestate, TSelectors, TActions, TInterpreter, TSlots>;
+};
+
+export { }