react-router 0.0.0-experimental-c7dd3d3a → 0.0.0-experimental-e53172d16

package/dist/lib/dom/ssr/errorBoundaries.d.ts

@@ -0,0 +1,33 @@
+import * as React from "react";
+import type { Location } from "../../router/history";
+type RemixErrorBoundaryProps = React.PropsWithChildren<{
+    location: Location;
+    error?: Error;
+}>;
+type RemixErrorBoundaryState = {
+    error: null | Error;
+    location: Location;
+};
+export declare class RemixErrorBoundary extends React.Component<RemixErrorBoundaryProps, RemixErrorBoundaryState> {
+    constructor(props: RemixErrorBoundaryProps);
+    static getDerivedStateFromError(error: Error): {
+        error: Error;
+    };
+    static getDerivedStateFromProps(props: RemixErrorBoundaryProps, state: RemixErrorBoundaryState): {
+        error: Error | null;
+        location: Location<any>;
+    };
+    render(): string | number | boolean | Iterable<React.ReactNode> | React.JSX.Element | null | undefined;
+}
+/**
+ * When app's don't provide a root level ErrorBoundary, we default to this.
+ */
+export declare function RemixRootDefaultErrorBoundary({ error }: {
+    error: unknown;
+}): React.JSX.Element;
+export declare function BoundaryShell({ title, renderScripts, children, }: {
+    title: string;
+    renderScripts?: boolean;
+    children: React.ReactNode | React.ReactNode[];
+}): string | number | boolean | Iterable<React.ReactNode> | React.JSX.Element | null | undefined;
+export {};

package/dist/lib/dom/ssr/errors.d.ts

@@ -0,0 +1,2 @@
+import type { Router as RemixRouter } from "../../router";
+export declare function deserializeErrors(errors: RemixRouter["state"]["errors"]): RemixRouter["state"]["errors"];

package/dist/lib/dom/ssr/fallback.d.ts

@@ -0,0 +1,2 @@
+import * as React from "react";
+export declare function RemixRootDefaultHydrateFallback(): React.JSX.Element;

package/dist/lib/dom/ssr/invariant.d.ts

@@ -0,0 +1,2 @@
+export default function invariant(value: boolean, message?: string): asserts value;
+export default function invariant<T>(value: T | null | undefined, message?: string): asserts value is T;

package/dist/lib/dom/ssr/links.d.ts

@@ -0,0 +1,127 @@
+import type { AgnosticDataRouteMatch, Location } from "../../router";
+import type { AssetsManifest } from "./entry";
+import type { RouteModules, RouteModule } from "./routeModules";
+import type { EntryRoute } from "./routes";
+type Primitive = null | undefined | string | number | boolean | symbol | bigint;
+type LiteralUnion<LiteralType, BaseType extends Primitive> = LiteralType | (BaseType & Record<never, never>);
+interface HtmlLinkProps {
+    /**
+     * Address of the hyperlink
+     */
+    href?: string;
+    /**
+     * How the element handles crossorigin requests
+     */
+    crossOrigin?: "anonymous" | "use-credentials";
+    /**
+     * Relationship between the document containing the hyperlink and the destination resource
+     */
+    rel: LiteralUnion<"alternate" | "dns-prefetch" | "icon" | "manifest" | "modulepreload" | "next" | "pingback" | "preconnect" | "prefetch" | "preload" | "prerender" | "search" | "stylesheet", string>;
+    /**
+     * Applicable media: "screen", "print", "(max-width: 764px)"
+     */
+    media?: string;
+    /**
+     * Integrity metadata used in Subresource Integrity checks
+     */
+    integrity?: string;
+    /**
+     * Language of the linked resource
+     */
+    hrefLang?: string;
+    /**
+     * Hint for the type of the referenced resource
+     */
+    type?: string;
+    /**
+     * Referrer policy for fetches initiated by the element
+     */
+    referrerPolicy?: "" | "no-referrer" | "no-referrer-when-downgrade" | "same-origin" | "origin" | "strict-origin" | "origin-when-cross-origin" | "strict-origin-when-cross-origin" | "unsafe-url";
+    /**
+     * Sizes of the icons (for rel="icon")
+     */
+    sizes?: string;
+    /**
+     * Potential destination for a preload request (for rel="preload" and rel="modulepreload")
+     */
+    as?: LiteralUnion<"audio" | "audioworklet" | "document" | "embed" | "fetch" | "font" | "frame" | "iframe" | "image" | "manifest" | "object" | "paintworklet" | "report" | "script" | "serviceworker" | "sharedworker" | "style" | "track" | "video" | "worker" | "xslt", string>;
+    /**
+     * Color to use when customizing a site's icon (for rel="mask-icon")
+     */
+    color?: string;
+    /**
+     * Whether the link is disabled
+     */
+    disabled?: boolean;
+    /**
+     * The title attribute has special semantics on this element: Title of the link; CSS style sheet set name.
+     */
+    title?: string;
+    /**
+     * Images to use in different situations, e.g., high-resolution displays,
+     * small monitors, etc. (for rel="preload")
+     */
+    imageSrcSet?: string;
+    /**
+     * Image sizes for different page layouts (for rel="preload")
+     */
+    imageSizes?: string;
+}
+interface HtmlLinkPreloadImage extends HtmlLinkProps {
+    /**
+     * Relationship between the document containing the hyperlink and the destination resource
+     */
+    rel: "preload";
+    /**
+     * Potential destination for a preload request (for rel="preload" and rel="modulepreload")
+     */
+    as: "image";
+    /**
+     * Address of the hyperlink
+     */
+    href?: string;
+    /**
+     * Images to use in different situations, e.g., high-resolution displays,
+     * small monitors, etc. (for rel="preload")
+     */
+    imageSrcSet: string;
+    /**
+     * Image sizes for different page layouts (for rel="preload")
+     */
+    imageSizes?: string;
+}
+/**
+ * Represents a `<link>` element.
+ *
+ * WHATWG Specification: https://html.spec.whatwg.org/multipage/semantics.html#the-link-element
+ */
+export type HtmlLinkDescriptor = (HtmlLinkProps & Pick<Required<HtmlLinkProps>, "href">) | (HtmlLinkPreloadImage & Pick<Required<HtmlLinkPreloadImage>, "imageSizes">) | (HtmlLinkPreloadImage & Pick<Required<HtmlLinkPreloadImage>, "href"> & {
+    imageSizes?: never;
+});
+export interface PrefetchPageDescriptor extends Omit<HtmlLinkDescriptor, "href" | "rel" | "type" | "sizes" | "imageSrcSet" | "imageSizes" | "as" | "color" | "title"> {
+    /**
+     * The absolute path of the page to prefetch.
+     */
+    page: string;
+}
+export type LinkDescriptor = HtmlLinkDescriptor | PrefetchPageDescriptor;
+/**
+ * Gets all the links for a set of matches. The modules are assumed to have been
+ * loaded already.
+ */
+export declare function getKeyedLinksForMatches(matches: AgnosticDataRouteMatch[], routeModules: RouteModules, manifest: AssetsManifest): KeyedLinkDescriptor[];
+export declare function prefetchStyleLinks(route: EntryRoute, routeModule: RouteModule): Promise<void>;
+export declare function isPageLinkDescriptor(object: any): object is PrefetchPageDescriptor;
+export type KeyedHtmlLinkDescriptor = {
+    key: string;
+    link: HtmlLinkDescriptor;
+};
+export declare function getKeyedPrefetchLinks(matches: AgnosticDataRouteMatch[], manifest: AssetsManifest, routeModules: RouteModules): Promise<KeyedHtmlLinkDescriptor[]>;
+export declare function getNewMatchesForLinks(page: string, nextMatches: AgnosticDataRouteMatch[], currentMatches: AgnosticDataRouteMatch[], manifest: AssetsManifest, location: Location, mode: "data" | "assets"): AgnosticDataRouteMatch[];
+export declare function getDataLinkHrefs(page: string, matches: AgnosticDataRouteMatch[], manifest: AssetsManifest): string[];
+export declare function getModuleLinkHrefs(matches: AgnosticDataRouteMatch[], manifestPatch: AssetsManifest): string[];
+type KeyedLinkDescriptor<Descriptor extends LinkDescriptor = LinkDescriptor> = {
+    key: string;
+    link: Descriptor;
+};
+export {};

package/dist/lib/dom/ssr/markup.d.ts

@@ -0,0 +1,5 @@
+export declare function escapeHtml(html: string): string;
+export interface SafeHtml {
+    __html: string;
+}
+export declare function createHtml(html: string): SafeHtml;

package/dist/lib/dom/ssr/routeModules.d.ts

@@ -0,0 +1,141 @@
+import type { ComponentType, ReactElement } from "react";
+import type { Location } from "../../router/history";
+import type { ActionFunction as RRActionFunction, ActionFunctionArgs as RRActionFunctionArgs, LoaderFunction as RRLoaderFunction, LoaderFunctionArgs as RRLoaderFunctionArgs, Params, ShouldRevalidateFunction, LoaderFunctionArgs } from "../../router/utils";
+import type { SerializeFrom } from "./components";
+import type { AppData } from "./data";
+import type { LinkDescriptor } from "./links";
+import type { EntryRoute } from "./routes";
+import type { DataRouteMatch } from "../../context";
+export interface RouteModules {
+    [routeId: string]: RouteModule | undefined;
+}
+export interface RouteModule {
+    clientAction?: ClientActionFunction;
+    clientLoader?: ClientLoaderFunction;
+    ErrorBoundary?: ErrorBoundaryComponent;
+    HydrateFallback?: HydrateFallbackComponent;
+    Layout?: LayoutComponent;
+    default: RouteComponent;
+    handle?: RouteHandle;
+    links?: LinksFunction;
+    meta?: MetaFunction;
+    shouldRevalidate?: ShouldRevalidateFunction;
+}
+/**
+ * A function that handles data mutations for a route on the client
+ */
+export type ClientActionFunction = (args: ClientActionFunctionArgs) => ReturnType<RRActionFunction>;
+/**
+ * Arguments passed to a route `clientAction` function
+ */
+export type ClientActionFunctionArgs = RRActionFunctionArgs<undefined> & {
+    serverAction: <T = AppData>() => Promise<SerializeFrom<T>>;
+};
+/**
+ * A function that loads data for a route on the client
+ */
+export type ClientLoaderFunction = ((args: ClientLoaderFunctionArgs) => ReturnType<RRLoaderFunction>) & {
+    hydrate?: boolean;
+};
+/**
+ * Arguments passed to a route `clientLoader` function
+ */
+export type ClientLoaderFunctionArgs = RRLoaderFunctionArgs<undefined> & {
+    serverLoader: <T = AppData>() => Promise<SerializeFrom<T>>;
+};
+/**
+ * ErrorBoundary to display for this route
+ */
+export type ErrorBoundaryComponent = ComponentType;
+/**
+ * `<Route HydrateFallback>` component to render on initial loads
+ * when client loaders are present
+ */
+export type HydrateFallbackComponent = ComponentType;
+/**
+ * Optional, root-only `<Route Layout>` component to wrap the root content in.
+ * Useful for defining the <html>/<head>/<body> document shell shared by the
+ * Component, HydrateFallback, and ErrorBoundary
+ */
+export type LayoutComponent = ComponentType<{
+    children: ReactElement<unknown, ErrorBoundaryComponent | HydrateFallbackComponent | RouteComponent>;
+}>;
+/**
+ * A function that defines `<link>` tags to be inserted into the `<head>` of
+ * the document on route transitions.
+ *
+ * @see https://remix.run/route/meta
+ */
+export interface LinksFunction {
+    (): LinkDescriptor[];
+}
+type LoaderFunction = (args: LoaderFunctionArgs & {
+    context: unknown;
+    response?: {
+        status: number | undefined;
+        headers: Headers;
+    };
+}) => ReturnType<RRLoaderFunction>;
+export interface MetaMatch<RouteId extends string = string, Loader extends LoaderFunction | unknown = unknown> {
+    id: RouteId;
+    pathname: DataRouteMatch["pathname"];
+    data: Loader extends LoaderFunction ? SerializeFrom<Loader> : unknown;
+    handle?: RouteHandle;
+    params: DataRouteMatch["params"];
+    meta: MetaDescriptor[];
+    error?: unknown;
+}
+export type MetaMatches<MatchLoaders extends Record<string, LoaderFunction | unknown> = Record<string, unknown>> = Array<{
+    [K in keyof MatchLoaders]: MetaMatch<Exclude<K, number | symbol>, MatchLoaders[K]>;
+}[keyof MatchLoaders]>;
+export interface MetaArgs<Loader extends LoaderFunction | unknown = unknown, MatchLoaders extends Record<string, LoaderFunction | unknown> = Record<string, unknown>> {
+    data: (Loader extends LoaderFunction ? SerializeFrom<Loader> : AppData) | undefined;
+    params: Params;
+    location: Location;
+    matches: MetaMatches<MatchLoaders>;
+    error?: unknown;
+}
+export interface MetaFunction<Loader extends LoaderFunction | unknown = unknown, MatchLoaders extends Record<string, LoaderFunction | unknown> = Record<string, unknown>> {
+    (args: MetaArgs<Loader, MatchLoaders>): MetaDescriptor[] | undefined;
+}
+export type MetaDescriptor = {
+    charSet: "utf-8";
+} | {
+    title: string;
+} | {
+    name: string;
+    content: string;
+} | {
+    property: string;
+    content: string;
+} | {
+    httpEquiv: string;
+    content: string;
+} | {
+    "script:ld+json": LdJsonObject;
+} | {
+    tagName: "meta" | "link";
+    [name: string]: string;
+} | {
+    [name: string]: unknown;
+};
+type LdJsonObject = {
+    [Key in string]: LdJsonValue;
+} & {
+    [Key in string]?: LdJsonValue | undefined;
+};
+type LdJsonArray = LdJsonValue[] | readonly LdJsonValue[];
+type LdJsonPrimitive = string | number | boolean | null;
+type LdJsonValue = LdJsonPrimitive | LdJsonObject | LdJsonArray;
+/**
+ * A React component that is rendered for a route.
+ */
+export type RouteComponent = ComponentType<{}>;
+/**
+ * An arbitrary object that is associated with a route.
+ *
+ * @see https://remix.run/route/handle
+ */
+export type RouteHandle = unknown;
+export declare function loadRouteModule(route: EntryRoute, routeModulesCache: RouteModules): Promise<RouteModule>;
+export {};

package/dist/lib/dom/ssr/routes.d.ts

@@ -0,0 +1,32 @@
+import type { HydrationState } from "../../router";
+import type { RouteModule, RouteModules } from "./routeModules";
+import type { FutureConfig } from "./entry";
+import type { DataRouteObject } from "../../context";
+export interface RouteManifest<Route> {
+    [routeId: string]: Route;
+}
+interface Route {
+    index?: boolean;
+    caseSensitive?: boolean;
+    id: string;
+    parentId?: string;
+    path?: string;
+}
+export interface EntryRoute extends Route {
+    hasAction: boolean;
+    hasLoader: boolean;
+    hasClientAction: boolean;
+    hasClientLoader: boolean;
+    hasErrorBoundary: boolean;
+    imports?: string[];
+    css?: string[];
+    module: string;
+    parentId?: string;
+}
+export declare function createServerRoutes(manifest: RouteManifest<EntryRoute>, routeModules: RouteModules, future: FutureConfig, isSpaMode: boolean, parentId?: string, routesByParentId?: Record<string, Omit<EntryRoute, "children">[]>, spaModeLazyPromise?: Promise<{
+    Component: () => null;
+}>): DataRouteObject[];
+export declare function createClientRoutesWithHMRRevalidationOptOut(needsRevalidation: Set<string>, manifest: RouteManifest<EntryRoute>, routeModulesCache: RouteModules, initialState: HydrationState, future: FutureConfig, isSpaMode: boolean): DataRouteObject[];
+export declare function createClientRoutes(manifest: RouteManifest<EntryRoute>, routeModulesCache: RouteModules, initialState: HydrationState, future: FutureConfig, isSpaMode: boolean, parentId?: string, routesByParentId?: Record<string, Omit<EntryRoute, "children">[]>, needsRevalidation?: Set<string>): DataRouteObject[];
+export declare function shouldHydrateRouteLoader(route: EntryRoute, routeModule: RouteModule, isSpaMode: boolean): boolean;
+export {};

package/dist/lib/dom/ssr/server.d.ts

@@ -0,0 +1,13 @@
+import type { ReactElement } from "react";
+import type { EntryContext } from "./entry";
+export interface RemixServerProps {
+    context: EntryContext;
+    url: string | URL;
+    abortDelay?: number;
+}
+/**
+ * The entry point for a Remix app when it is rendered on the server (in
+ * `app/entry.server.js`). This component is used to generate the HTML in the
+ * response from the server.
+ */
+export declare function RemixServer({ context, url, abortDelay, }: RemixServerProps): ReactElement;

package/dist/lib/dom/ssr/single-fetch.d.ts

@@ -0,0 +1,36 @@
+import * as React from "react";
+import type { unstable_DataStrategyFunction as DataStrategyFunction } from "../../router";
+import type { AssetsManifest, EntryContext } from "./entry";
+import type { RouteModules } from "./routeModules";
+import type { DataRouteObject } from "../../context";
+export declare const SingleFetchRedirectSymbol: unique symbol;
+export type SingleFetchRedirectResult = {
+    redirect: string;
+    status: number;
+    revalidate: boolean;
+    reload: boolean;
+};
+export type SingleFetchResult = {
+    data: unknown;
+} | {
+    error: unknown;
+} | SingleFetchRedirectResult;
+export type SingleFetchResults = {
+    [key: string]: SingleFetchResult;
+    [SingleFetchRedirectSymbol]?: SingleFetchRedirectResult;
+};
+interface StreamTransferProps {
+    context: EntryContext;
+    identifier: number;
+    reader: ReadableStreamDefaultReader<Uint8Array>;
+    textDecoder: TextDecoder;
+}
+export declare function StreamTransfer({ context, identifier, reader, textDecoder, }: StreamTransferProps): React.JSX.Element | null;
+export declare function getSingleFetchDataStrategy(manifest: AssetsManifest, routeModules: RouteModules): DataStrategyFunction;
+export declare function addRevalidationParam(manifest: AssetsManifest, routeModules: RouteModules, matchedRoutes: DataRouteObject[], loadRoutes: DataRouteObject[], url: URL): URL;
+export declare function singleFetchUrl(reqUrl: URL | string): URL;
+export declare function decodeViaTurboStream(body: ReadableStream<Uint8Array>, global: Window | typeof globalThis): Promise<{
+    done: Promise<undefined>;
+    value: unknown;
+}>;
+export {};

package/dist/lib/hooks.d.ts

@@ -1,6 +1,6 @@
 import * as React from "react";
-import type { Blocker, BlockerFunction, Location, ParamParseKey, Params, Path, PathMatch, PathPattern, RelativeRoutingType, Router as RemixRouter, RevalidationState, To, UIMatch } from "@remix-run/router";
-import { Action as NavigationType } from "@remix-run/router";
+import type { Blocker, BlockerFunction, Location, ParamParseKey, Params, Path, PathMatch, PathPattern, RelativeRoutingType, Router as RemixRouter, RevalidationState, To, UIMatch } from "./router";
+import { Action as NavigationType } from "./router";
 import type { NavigateOptions, RouteContextObject, RouteMatch, RouteObject } from "./context";
 /**
  * Returns the full href for the given "to" value. This is useful for building
@@ -131,7 +131,7 @@ export declare function useRouteId(): string;
  * Returns the current navigation, defaulting to an "idle" navigation when
  * no navigation is in progress
  */
-export declare function useNavigation(): import("@remix-run/router").Navigation;
+export declare function useNavigation(): import("./router").Navigation;
 /**
  * Returns a revalidate function for manually triggering revalidation, as well
  * as the current state of any manual revalidations

package/dist/lib/router/history.d.ts

@@ -0,0 +1,250 @@
+/**
+ * Actions represent the type of change to a location value.
+ */
+export declare enum Action {
+    /**
+     * A POP indicates a change to an arbitrary index in the history stack, such
+     * as a back or forward navigation. It does not describe the direction of the
+     * navigation, only that the current index changed.
+     *
+     * Note: This is the default action for newly created history objects.
+     */
+    Pop = "POP",
+    /**
+     * A PUSH indicates a new entry being added to the history stack, such as when
+     * a link is clicked and a new page loads. When this happens, all subsequent
+     * entries in the stack are lost.
+     */
+    Push = "PUSH",
+    /**
+     * A REPLACE indicates the entry at the current index in the history stack
+     * being replaced by a new one.
+     */
+    Replace = "REPLACE"
+}
+/**
+ * The pathname, search, and hash values of a URL.
+ */
+export interface Path {
+    /**
+     * A URL pathname, beginning with a /.
+     */
+    pathname: string;
+    /**
+     * A URL search string, beginning with a ?.
+     */
+    search: string;
+    /**
+     * A URL fragment identifier, beginning with a #.
+     */
+    hash: string;
+}
+/**
+ * An entry in a history stack. A location contains information about the
+ * URL path, as well as possibly some arbitrary state and a key.
+ */
+export interface Location<State = any> extends Path {
+    /**
+     * A value of arbitrary data associated with this location.
+     */
+    state: State;
+    /**
+     * A unique string associated with this location. May be used to safely store
+     * and retrieve data in some other storage API, like `localStorage`.
+     *
+     * Note: This value is always "default" on the initial location.
+     */
+    key: string;
+}
+/**
+ * A change to the current location.
+ */
+export interface Update {
+    /**
+     * The action that triggered the change.
+     */
+    action: Action;
+    /**
+     * The new location.
+     */
+    location: Location;
+    /**
+     * The delta between this location and the former location in the history stack
+     */
+    delta: number | null;
+}
+/**
+ * A function that receives notifications about location changes.
+ */
+export interface Listener {
+    (update: Update): void;
+}
+/**
+ * Describes a location that is the destination of some navigation, either via
+ * `history.push` or `history.replace`. This may be either a URL or the pieces
+ * of a URL path.
+ */
+export type To = string | Partial<Path>;
+/**
+ * A history is an interface to the navigation stack. The history serves as the
+ * source of truth for the current location, as well as provides a set of
+ * methods that may be used to change it.
+ *
+ * It is similar to the DOM's `window.history` object, but with a smaller, more
+ * focused API.
+ */
+export interface History {
+    /**
+     * The last action that modified the current location. This will always be
+     * Action.Pop when a history instance is first created. This value is mutable.
+     */
+    readonly action: Action;
+    /**
+     * The current location. This value is mutable.
+     */
+    readonly location: Location;
+    /**
+     * Returns a valid href for the given `to` value that may be used as
+     * the value of an <a href> attribute.
+     *
+     * @param to - The destination URL
+     */
+    createHref(to: To): string;
+    /**
+     * Returns a URL for the given `to` value
+     *
+     * @param to - The destination URL
+     */
+    createURL(to: To): URL;
+    /**
+     * Encode a location the same way window.history would do (no-op for memory
+     * history) so we ensure our PUSH/REPLACE navigations for data routers
+     * behave the same as POP
+     *
+     * @param to Unencoded path
+     */
+    encodeLocation(to: To): Path;
+    /**
+     * Pushes a new location onto the history stack, increasing its length by one.
+     * If there were any entries in the stack after the current one, they are
+     * lost.
+     *
+     * @param to - The new URL
+     * @param state - Data to associate with the new location
+     */
+    push(to: To, state?: any): void;
+    /**
+     * Replaces the current location in the history stack with a new one.  The
+     * location that was replaced will no longer be available.
+     *
+     * @param to - The new URL
+     * @param state - Data to associate with the new location
+     */
+    replace(to: To, state?: any): void;
+    /**
+     * Navigates `n` entries backward/forward in the history stack relative to the
+     * current index. For example, a "back" navigation would use go(-1).
+     *
+     * @param delta - The delta in the stack index
+     */
+    go(delta: number): void;
+    /**
+     * Sets up a listener that will be called whenever the current location
+     * changes.
+     *
+     * @param listener - A function that will be called when the location changes
+     * @returns unlisten - A function that may be used to stop listening
+     */
+    listen(listener: Listener): () => void;
+}
+/**
+ * A user-supplied object that describes a location. Used when providing
+ * entries to `createMemoryHistory` via its `initialEntries` option.
+ */
+export type InitialEntry = string | Partial<Location>;
+export type MemoryHistoryOptions = {
+    initialEntries?: InitialEntry[];
+    initialIndex?: number;
+    v5Compat?: boolean;
+};
+/**
+ * A memory history stores locations in memory. This is useful in stateful
+ * environments where there is no web browser, such as node tests or React
+ * Native.
+ */
+export interface MemoryHistory extends History {
+    /**
+     * The current index in the history stack.
+     */
+    readonly index: number;
+}
+/**
+ * Memory history stores the current location in memory. It is designed for use
+ * in stateful non-browser environments like tests and React Native.
+ */
+export declare function createMemoryHistory(options?: MemoryHistoryOptions): MemoryHistory;
+/**
+ * A browser history stores the current location in regular URLs in a web
+ * browser environment. This is the standard for most web apps and provides the
+ * cleanest URLs the browser's address bar.
+ *
+ * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#browserhistory
+ */
+export interface BrowserHistory extends UrlHistory {
+}
+export type BrowserHistoryOptions = UrlHistoryOptions;
+/**
+ * Browser history stores the location in regular URLs. This is the standard for
+ * most web apps, but it requires some configuration on the server to ensure you
+ * serve the same app at multiple URLs.
+ *
+ * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#createbrowserhistory
+ */
+export declare function createBrowserHistory(options?: BrowserHistoryOptions): BrowserHistory;
+/**
+ * A hash history stores the current location in the fragment identifier portion
+ * of the URL in a web browser environment.
+ *
+ * This is ideal for apps that do not control the server for some reason
+ * (because the fragment identifier is never sent to the server), including some
+ * shared hosting environments that do not provide fine-grained controls over
+ * which pages are served at which URLs.
+ *
+ * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#hashhistory
+ */
+export interface HashHistory extends UrlHistory {
+}
+export type HashHistoryOptions = UrlHistoryOptions;
+/**
+ * Hash history stores the location in window.location.hash. This makes it ideal
+ * for situations where you don't want to send the location to the server for
+ * some reason, either because you do cannot configure it or the URL space is
+ * reserved for something else.
+ *
+ * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#createhashhistory
+ */
+export declare function createHashHistory(options?: HashHistoryOptions): HashHistory;
+/**
+ * @private
+ */
+export declare function invariant(value: boolean, message?: string): asserts value;
+export declare function invariant<T>(value: T | null | undefined, message?: string): asserts value is T;
+export declare function warning(cond: any, message: string): void;
+/**
+ * Creates a Location object with a unique key from the given Path
+ */
+export declare function createLocation(current: string | Location, to: To, state?: any, key?: string): Readonly<Location>;
+/**
+ * Creates a string URL path from the given pathname, search, and hash components.
+ */
+export declare function createPath({ pathname, search, hash, }: Partial<Path>): string;
+/**
+ * Parses a string URL path into its separate pathname, search, and hash components.
+ */
+export declare function parsePath(path: string): Partial<Path>;
+export interface UrlHistory extends History {
+}
+export type UrlHistoryOptions = {
+    window?: Window;
+    v5Compat?: boolean;
+};