index.d.ts

declare module "connected-react-router" {
  import * as React from "react";
  import { Middleware, Reducer } from "redux";
  import { ReactReduxContextValue } from "react-redux";
  import { match, matchPath } from "react-router-v5";
  import {
    Action,
    Hash,
    History,
    Path,
    Location,
    LocationState,
    LocationDescriptorObject,
    Search,
  } from "history";

  type PathParam = Parameters<typeof matchPath>[1];

  interface ConnectedRouterProps<S = LocationState> {
    history: History<S>;
    context?: React.Context<ReactReduxContextValue>;
    noInitialPop?: boolean;
    noTimeTravelDebugging?: boolean;
    omitRouter?: boolean;
    children?: React.ReactNode;
  }

  export type RouterActionType = Action;

  export interface RouterLocation<S> extends Location<S> {
    query: Record<string, string>;
  }

  export interface RouterState<S = LocationState> {
    location: RouterLocation<S>;
    action: RouterActionType;
  }

  export const LOCATION_CHANGE: "@@router/LOCATION_CHANGE";
  export const CALL_HISTORY_METHOD: "@@router/CALL_HISTORY_METHOD";

  export interface LocationChangeAction<S = LocationState> {
    type: typeof LOCATION_CHANGE;
    payload: LocationChangePayload<S>;
  }

  export interface LocationChangePayload<S = LocationState>
    extends RouterState<S> {
    isFirstRendering: boolean;
  }

  export interface CallHistoryMethodAction<A = any[]> {
    type: typeof CALL_HISTORY_METHOD;
    payload: LocationActionPayload<A>;
  }

  export interface RouterRootState<S = LocationState> {
    router: RouterState<S>;
  }

  export type matchSelectorFn<
    S extends RouterRootState,
    Params extends { [K in keyof Params]?: string }
  > = (state: S) => match<Params> | null;

  export type RouterAction<S = LocationState> =
    | LocationChangeAction<S>
    | CallHistoryMethodAction;

  export function push<S = LocationState>(
    path: Path,
    state?: S
  ): CallHistoryMethodAction<[Path, S?]>;
  export function push<S = LocationState>(
    location: LocationDescriptorObject<S>
  ): CallHistoryMethodAction<[LocationDescriptorObject<S>]>;
  export function replace<S = LocationState>(
    path: Path,
    state?: S
  ): CallHistoryMethodAction<[Path, S?]>;
  export function replace<S = LocationState>(
    location: LocationDescriptorObject<S>
  ): CallHistoryMethodAction<[LocationDescriptorObject<S>]>;
  export function go(n: number): CallHistoryMethodAction<[number]>;
  export function goBack(): CallHistoryMethodAction<[]>;
  export function goForward(): CallHistoryMethodAction<[]>;
  export function getRouter<S extends RouterRootState<LS>, LS = LocationState>(
    state: S
  ): RouterState<LS>;
  export function getAction<S extends RouterRootState>(
    state: S
  ): RouterActionType;
  export function getHash<S extends RouterRootState>(state: S): Hash;
  export function getLocation<
    S extends RouterRootState<LS>,
    LS = LocationState
  >(state: S): RouterLocation<LS>;
  export function getSearch<S extends RouterRootState>(state: S): Search;
  export function createMatchSelector<
    S extends RouterRootState,
    Params extends { [K in keyof Params]?: string }
  >(path: PathParam): matchSelectorFn<S, Params>;
  export function onLocationChanged<S = LocationState>(
    location: Location<S>,
    action: RouterActionType,
    isFirstRendering?: boolean
  ): LocationChangeAction<S>;

  export type Push = typeof push;
  export type Replace = typeof replace;
  export type Go = typeof go;
  export type GoBack = typeof goBack;
  export type GoForward = typeof goForward;

  export const routerActions: {
    push: Push;
    replace: Replace;
    go: Go;
    goBack: GoBack;
    goForward: GoForward;
  };

  export interface LocationActionPayload<A = any[]> {
    method: string;
    args?: A;
  }

  export class ConnectedRouter<S = LocationState> extends React.Component<
    ConnectedRouterProps<S>,
    {}
  > {}

  export function connectRouter<S = LocationState>(
    history: History<S>
  ): Reducer<RouterState<S>>;

  export function routerMiddleware<S = LocationState>(
    history: History<S>
  ): Middleware;
}