import type { InitialEntry, LazyRouteFunction, Location, RelativeRoutingType, Router as RemixRouter, To, TrackedPromise } from "@remix-run/router"; import { Action as NavigationType } from "@remix-run/router"; import * as React from "react"; import type { IndexRouteObject, Navigator, NonIndexRouteObject, RouteMatch, RouteObject } from "./context"; export interface FutureConfig { v7_startTransition: boolean; } export interface RouterProviderProps { fallbackElement?: React.ReactNode; router: RemixRouter; future?: Partial; } /** * Given a Remix Router instance, render the appropriate UI */ export declare function RouterProvider({ fallbackElement, router, future, }: RouterProviderProps): React.ReactElement; export interface MemoryRouterProps { basename?: string; children?: React.ReactNode; initialEntries?: InitialEntry[]; initialIndex?: number; future?: Partial; } /** * A `` that stores all entries in memory. * * @see https://reactrouter.com/router-components/memory-router */ export declare function MemoryRouter({ basename, children, initialEntries, initialIndex, future, }: MemoryRouterProps): React.ReactElement; export interface NavigateProps { to: To; replace?: boolean; state?: any; relative?: RelativeRoutingType; } /** * Changes the current location. * * Note: This API is mostly useful in React.Component subclasses that are not * able to use hooks. In functional components, we recommend you use the * `useNavigate` hook instead. * * @see https://reactrouter.com/components/navigate */ export declare function Navigate({ to, replace, state, relative, }: NavigateProps): null; export interface OutletProps { context?: unknown; } /** * Renders the child route's element, if there is one. * * @see https://reactrouter.com/components/outlet */ export declare function Outlet(props: OutletProps): React.ReactElement | null; export interface PathRouteProps { caseSensitive?: NonIndexRouteObject["caseSensitive"]; path?: NonIndexRouteObject["path"]; id?: NonIndexRouteObject["id"]; lazy?: LazyRouteFunction; loader?: NonIndexRouteObject["loader"]; action?: NonIndexRouteObject["action"]; hasErrorBoundary?: NonIndexRouteObject["hasErrorBoundary"]; shouldRevalidate?: NonIndexRouteObject["shouldRevalidate"]; handle?: NonIndexRouteObject["handle"]; index?: false; children?: React.ReactNode; element?: React.ReactNode | null; errorElement?: React.ReactNode | null; Component?: React.ComponentType | null; ErrorBoundary?: React.ComponentType | null; } export interface LayoutRouteProps extends PathRouteProps { } export interface IndexRouteProps { caseSensitive?: IndexRouteObject["caseSensitive"]; path?: IndexRouteObject["path"]; id?: IndexRouteObject["id"]; lazy?: LazyRouteFunction; loader?: IndexRouteObject["loader"]; action?: IndexRouteObject["action"]; hasErrorBoundary?: IndexRouteObject["hasErrorBoundary"]; shouldRevalidate?: IndexRouteObject["shouldRevalidate"]; handle?: IndexRouteObject["handle"]; index: true; children?: undefined; element?: React.ReactNode | null; errorElement?: React.ReactNode | null; Component?: React.ComponentType | null; ErrorBoundary?: React.ComponentType | null; } export type RouteProps = PathRouteProps | LayoutRouteProps | IndexRouteProps; /** * Declares an element that should be rendered at a certain URL path. * * @see https://reactrouter.com/components/route */ export declare function Route(_props: RouteProps): React.ReactElement | null; export interface RouterProps { basename?: string; children?: React.ReactNode; location: Partial | string; navigationType?: NavigationType; navigator: Navigator; static?: boolean; } /** * Provides location context for the rest of the app. * * Note: You usually won't render a `` directly. Instead, you'll render a * router that is more specific to your environment such as a `` * in web browsers or a `` for server rendering. * * @see https://reactrouter.com/router-components/router */ export declare function Router({ basename: basenameProp, children, location: locationProp, navigationType, navigator, static: staticProp, }: RouterProps): React.ReactElement | null; export interface RoutesProps { children?: React.ReactNode; location?: Partial | string; } /** * A container for a nested tree of `` elements that renders the branch * that best matches the current location. * * @see https://reactrouter.com/components/routes */ export declare function Routes({ children, location, }: RoutesProps): React.ReactElement | null; export interface AwaitResolveRenderFunction { (data: Awaited): React.ReactNode; } export interface AwaitProps { children: React.ReactNode | AwaitResolveRenderFunction; errorElement?: React.ReactNode; resolve: TrackedPromise | any; } /** * Component to use for rendering lazily loaded data from returning defer() * in a loader function */ export declare function Await({ children, errorElement, resolve }: AwaitProps): React.JSX.Element; /** * Creates a route config from a React "children" object, which is usually * either a `` element or an array of them. Used internally by * `` to create a route config from its children. * * @see https://reactrouter.com/utils/create-routes-from-children */ export declare function createRoutesFromChildren(children: React.ReactNode, parentPath?: number[]): RouteObject[]; /** * Renders the result of `matchRoutes()` into a React element. */ export declare function renderMatches(matches: RouteMatch[] | null): React.ReactElement | null;