universal-router generated type definitions

generate-urls.d.ts

import { Params } from './types';
import UniversalRouter from './universal-router';
export default function generateUrls(router: UniversalRouter<any, any>, options?: any): (routeName: string, params: Params) => string;
//# sourceMappingURL=generate-urls.d.ts.map

index.d.ts

export * from './types';
export * from './match-path';
export * from './match-route';
export * from './resolve-route';
export * from './is-child-route';
export { default as generateUrls } from './generate-urls';
export { default as UniversalRouter } from './universal-router';
export { default as UniversalRouterSync } from './universal-router-sync';
//# sourceMappingURL=index.d.ts.map

is-child-route.d.ts

/**
 * Universal Router (https://www.kriasoft.com/universal-router/)
 *
 * Copyright (c) 2015-present Kriasoft.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE.txt file in the root directory of this source tree.
 */
declare type WithParent = {
    parent?: WithParent | null | undefined;
};
export declare function isChildRoute(parentRoute: WithParent | null, childRoute: WithParent | null | undefined): boolean;
export {};
//# sourceMappingURL=is-child-route.d.ts.map

match-path.d.ts

/**
 * Universal Router (https://www.kriasoft.com/universal-router/)
 *
 * Copyright (c) 2015-present Kriasoft.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE.txt file in the root directory of this source tree.
 */
import { MatchedKeys, MatchedPath, Params, Route } from './types';
export declare function matchPath<Context extends object, Result>(route: Route<Context, Result>, pathname: string, parentKeys: MatchedKeys, parentParams?: Params | null): MatchedPath | null;
//# sourceMappingURL=match-path.d.ts.map

match-route.d.ts

/**
 * Universal Router (https://www.kriasoft.com/universal-router/)
 *
 * Copyright (c) 2015-present Kriasoft.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE.txt file in the root directory of this source tree.
 */
import { MatchedKeys, MatchedRoute, Params, Route } from './types';
export declare function matchRoute<Context extends object, Result>(route: Route<Context, Result>, baseUrl: string, pathname: string, parentKeys: MatchedKeys, parentParams?: Params | null): {
    next(routeToSkip?: Route<Context, Result> | null | undefined): MatchedRoute<Context, Result>;
};
//# sourceMappingURL=match-route.d.ts.map

resolve-route.d.ts

/**
 * Universal Router (https://www.kriasoft.com/universal-router/)
 *
 * Copyright (c) 2015-present Kriasoft.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE.txt file in the root directory of this source tree.
 */
import { Params, ResultReturn, RouteContext } from './types';
export declare function resolveRoute<Context extends object, Result>(context: RouteContext<Context, Result>, params: Params): ResultReturn<Result>;
//# sourceMappingURL=resolve-route.d.ts.map

types.d.ts

import UniversalRouter from './universal-router';
export interface Params {
    [paramName: string]: string | string[];
    [paramIndex: number]: string | string[];
}
export declare type MatchedKeys = Array<import('path-to-regexp').Key>;
export declare type MatchedPath = {
    path: string;
    keys: MatchedKeys;
    params: Params;
};
export interface MatchedRouteValue<Context extends object, Result> {
    route: Route<Context, Result>;
    baseUrl: string;
    path: string;
    keys: MatchedKeys;
    params: Params;
}
export declare type MatchedRoute<Context extends object, Result> = {
    done: true;
    value: undefined;
} | {
    done: false;
    value: MatchedRouteValue<Context, Result>;
};
export interface ResolveContext {
    pathname: string;
}
export declare type MayBePromiseLike<T> = T | PromiseLike<T>;
export declare type ResultReturn<Result> = MayBePromiseLike<Result | null | undefined>;
export interface RouteContext<Context extends object, Result> extends ResolveContext, MatchedRouteValue<Context, Result> {
    router: UniversalRouter<Context, Result>;
    next(resume?: boolean, parent?: Route<Context, Result> | null | undefined, prevResult?: Result): ResultReturn<Result>;
}
export interface Route<Context extends object, Result> {
    path?: string | RegExp | Array<string | RegExp>;
    name?: string;
    parent?: Route<Context, Result> | null;
    children?: Routes<Context, Result> | null;
    action?: (context: RouteContext<Context, Result>, params: Params) => ResultReturn<Result>;
    [name: string]: unknown;
}
export declare type Routes<Context extends object, Result> = Array<Route<Context, Result>>;
export declare type RouteOrRoutes<Context extends object, Result> = Routes<Context, Result> | Route<Context, Result>;
export declare type ResolveRoute<Context extends object, Result> = (context: RouteContext<Context, Result>, params: Params) => ResultReturn<Result>;
export declare type ErrorHandler<Context extends object, Result> = (error: Error & {
    status?: number;
}, context: RouteContext<Context, Result>) => ResultReturn<Result>;
export interface Options<Context extends object, Result> {
    context?: Context;
    baseUrl?: string;
    resolveRoute?: ResolveRoute<Context, Result>;
    errorHandler?: ErrorHandler<Context, Result>;
}
export declare type RouteNameMap = Map<string, any>;
//# sourceMappingURL=types.d.ts.map

universal-router-generate-urls.d.ts

/**
 * Universal Router (https://www.kriasoft.com/universal-router/)
 *
 * Copyright (c) 2015-present Kriasoft.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE.txt file in the root directory of this source tree.
 */
export * from './types';
export { default as generateUrls } from './generate-urls';
export { default as UniversalRouter } from './universal-router';
//# sourceMappingURL=universal-router-generate-urls.d.ts.map

universal-router-sync.d.ts

/**
 * Universal Router (https://www.kriasoft.com/universal-router/)
 *
 * Copyright (c) 2015-present Kriasoft.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE.txt file in the root directory of this source tree.
 */
import pathToRegexp from 'path-to-regexp';
import { ErrorHandler, Options, ResolveContext, ResolveRoute, ResultReturn, Route, RouteOrRoutes } from './types';
declare type RouterContext<Context extends object, Result> = Context & {
    router: UniversalRouterSync<Context, Result>;
};
export default class UniversalRouterSync<Context extends object, Result> {
    static pathToRegexp: typeof pathToRegexp;
    baseUrl: string;
    errorHandler?: ErrorHandler<Context, Result>;
    resolveRoute: ResolveRoute<Context, Result>;
    context: RouterContext<Context, Result>;
    root: Route<Context, Result>;
    constructor(routes: RouteOrRoutes<Context, Result>, options?: Options<Context, Result>);
    resolve(pathnameOrContext: string | (ResolveContext & Context)): ResultReturn<Result>;
}
export {};
//# sourceMappingURL=universal-router-sync.d.ts.map

universal-router.d.ts

/**
 * Universal Router (https://www.kriasoft.com/universal-router/)
 *
 * Copyright (c) 2015-present Kriasoft.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE.txt file in the root directory of this source tree.
 */
import pathToRegexp from 'path-to-regexp';
import { ErrorHandler, Options, ResolveContext, ResolveRoute, ResultReturn, Route, RouteNameMap, RouteOrRoutes } from './types';
declare type RouterContext<Context extends object, Result> = Context & {
    router: UniversalRouter<Context, Result>;
};
export default class UniversalRouter<Context extends object, Result> {
    static pathToRegexp: typeof pathToRegexp;
    routesByName?: RouteNameMap;
    baseUrl: string;
    errorHandler?: ErrorHandler<Context, Result>;
    resolveRoute: ResolveRoute<Context, Result>;
    context: RouterContext<Context, Result>;
    root: Route<Context, Result>;
    constructor(routes: RouteOrRoutes<Context, Result>, options?: Options<Context, Result>);
    resolve(pathnameOrContext: string | (ResolveContext & Context)): ResultReturn<Result>;
}
export {};
//# sourceMappingURL=universal-router.d.ts.map