@lwrjs/router 0.10.0-alpha.12 → 0.10.0-alpha.13

package/build/bundle/prod/lwr/router/es/modules/lwr/outlet/outlet.d.ts

@@ -0,0 +1,19 @@
+import { LightningElement } from 'lwc';
+import type { Constructable } from 'lwr/routerUtils';
+export interface OutletErrorCallback {
+    (error: Error, stack: string): void;
+}
+export default class Outlet extends LightningElement {
+    static renderMode: string;
+    refocusOff: boolean;
+    outletErrorCallback?: OutletErrorCallback;
+    viewName: string;
+    viewCtor?: Constructable;
+    previousViewCtor?: Constructable;
+    hasError: boolean;
+    setView(currentView: Constructable): void;
+    renderedCallback(): void;
+    errorCallback(e: Error, stack: string): void;
+    refocus(): void;
+}
+//# sourceMappingURL=outlet.d.ts.map

package/build/bundle/prod/lwr/router/es/modules/lwr/router/router.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Copyright (c) 2019, salesforce.com, inc.
+ * All rights reserved.
+ * SPDX-License-Identifier: MIT
+ * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
+ */
+import type { PageReference, RouteCallback, RouteDefinition, RouteHandler, RouteHandlerClass, Router, RouterConfig, RouteDestination, RoutingMatch, RoutingResult, ViewSet, ViewInfo } from 'lwr/routerUtils';
+export declare function createRouter(config?: RouterConfig): Router<PageReference>;
+export type { PageReference, Router, RouterConfig, RouteCallback, RouteDefinition, RouteDestination, RouteHandler, RouteHandlerClass, RoutingMatch, RoutingResult, ViewSet, ViewInfo, };
+export type { Module, RouteHandlerCallback, RouteHandlerModule, RouteInstance, StringAttributes, } from 'lwr/routerUtils';
+//# sourceMappingURL=router.d.ts.map

package/build/bundle/prod/lwr/router/es/modules/lwr/routerBridge/routerBridge.d.ts

@@ -0,0 +1,13 @@
+import type { PageReference } from 'lwr/router';
+import type { MessageObject } from 'lwr/routerUtils';
+export interface RouterBridgeApi {
+    navigate: (pageRef: PageReference) => boolean;
+}
+export interface RouterBridgeConfig {
+    historyDisabled?: boolean;
+    onReady?: () => void;
+    onPostNavigate?: (pageRef: PageReference | undefined) => void;
+    onError?: (error: MessageObject) => boolean;
+}
+export declare function createBridge(config?: RouterBridgeConfig, target?: globalThis.EventTarget): RouterBridgeApi;
+//# sourceMappingURL=routerBridge.d.ts.map

package/build/bundle/prod/lwr/router/es/modules/lwr/routerContainer/routerContainer.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Copyright (c) 2019, salesforce.com, inc.
+ * All rights reserved.
+ * SPDX-License-Identifier: MIT
+ * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
+ */
+import { LightningElement } from 'lwc';
+import type { RouterApi } from './utils';
+import type { MessageObject } from 'lwr/routerUtils';
+import type { PageReference, Router, RoutingResult } from 'lwr/router';
+import type { RouteChange } from 'lwr/domRouterUtils';
+export default class RouterContainer extends LightningElement {
+    static renderMode: string;
+    routerApi?: RouterApi;
+    router?: Router<PageReference>;
+    historyDisabled: boolean;
+    currentTitle: string;
+    constructor();
+    /**
+     * Create a router attached to this component.
+     */
+    connectedCallback(): void;
+    /**
+     * The preNavigate hook surfaced as a cancelable CustomEvent.
+     * @param {RouteChange} - the current and proposed route information
+     */
+    preNavigate(routeChange: RouteChange): boolean;
+    /**
+     * The postNavigate hook surfaced as a CustomEvent.
+     * @param {RoutingResult} - the resulting navigation information
+     */
+    postNavigate(routingResult: RoutingResult): void;
+    /**
+     * The errorNavigate hook surfaced as a CustomEvent.
+     * @param {MessageObject} - error, the error encountered while navigating (if applicable)
+     */
+    errorNavigate(error: MessageObject): boolean;
+    /**
+     * The preNavigate hook surfaced as a cancelable CustomEvent.
+     * @param {object} - address: The address being navigated to
+     * @param {boolean} - shouldReplace
+     */
+    handleNavigation(address: PageReference, replace?: boolean): boolean;
+    /**
+     * Disconnect the router after DOM removal.
+     */
+    disconnectedCallback(): void;
+    private _createEvent;
+}
+export type { RouteChange } from 'lwr/domRouterUtils';
+//# sourceMappingURL=routerContainer.d.ts.map

package/build/bundle/prod/lwr/router/es/modules/lwr/routerContainer/utils.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Copyright (c) 2019, salesforce.com, inc.
+ * All rights reserved.
+ * SPDX-License-Identifier: MIT
+ * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
+ */
+import type { Filter, MessageObject } from 'lwr/routerUtils';
+import type { PageReference, RouteCallback, Router } from 'lwr/router';
+import type { DomRouterConfig, RouteChange } from 'lwr/domRouterUtils';
+import type { ContextId } from 'lwr/navigationContext';
+export interface RouterApi {
+    addPreNavigate: (filter: Filter<RouteChange>) => RouterApi;
+    addPostNavigate: (listener: RouteCallback) => RouterApi;
+    addErrorNavigate: (listener: Filter<MessageObject>) => RouterApi;
+    connect: () => void;
+    disconnect: () => void;
+    id?: ContextId;
+}
+export interface RouterConfigApi extends DomRouterConfig {
+    historyDisabled?: boolean;
+}
+/**
+ * Create a new navigation context, attach to the given node.
+ * An application can only have ONE root router.
+ *
+ * @param {HTMLElement} - The DOM node where the navigation context should be established
+ * @param {object} config - The router config object, all properties are optional
+ *
+ * @returns {object} - { addPreNavigate, addPostNavigate, addErrorNavigate, connect, disconnect }
+ */
+export declare function createNavigationContext(node: EventTarget, config: RouterConfigApi | undefined, portableRouter: Router<PageReference>): RouterApi;
+//# sourceMappingURL=utils.d.ts.map

package/build/bundle/prod/lwr/router/es/modules/lwr/routerErrors/routerErrors.d.ts

@@ -0,0 +1,13 @@
+/** @hidden */
+/**
+ * Copyright (c) 2019, salesforce.com, inc.
+ * All rights reserved.
+ * SPDX-License-Identifier: MIT
+ * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
+ */
+import type { MessageObject } from '../routerUtils/types';
+export declare function generateMessage(info: MessageObject, args?: string[]): string;
+export declare function generateMessageObject(info: MessageObject, args?: string[]): MessageObject;
+export declare function invariant(condition: boolean, errorInfo: MessageObject, args?: string[]): void;
+export declare const messages: Record<string, MessageObject>;
+//# sourceMappingURL=routerErrors.d.ts.map

package/build/bundle/prod/lwr/router/es/modules/lwr/routerUtils/domUtils.d.ts

@@ -0,0 +1,2 @@
+export declare const hasDocument: boolean;
+//# sourceMappingURL=domUtils.d.ts.map

package/build/bundle/prod/lwr/router/es/modules/lwr/routerUtils/filterUtils.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Copyright (c) 2019, salesforce.com, inc.
+ * All rights reserved.
+ * SPDX-License-Identifier: MIT
+ * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
+ */
+export declare type Filter<V> = (v: V) => Promise<boolean> | boolean;
+export interface FilterChain<V> {
+    add: (f: Filter<V>[] | Filter<V>) => void;
+    compile: (arg: V) => Promise<boolean>;
+    empty: () => boolean;
+}
+/**
+ * Creates a filter chain as an array. Filters can return true, false or a Promise resulting in true or false.
+ *
+ * @returns {object}
+ */
+export declare function createFilterChain<V>(): FilterChain<V>;
+//# sourceMappingURL=filterUtils.d.ts.map

package/build/bundle/prod/lwr/router/es/modules/lwr/routerUtils/parseUtils.d.ts

@@ -0,0 +1,42 @@
+import type { CompiledRouteDefinition, RouterSerializationConfig } from 'lwr/routerUtils';
+import type { QueryObject, CompiledQuery, QueryMatcher } from './types';
+/**
+ * Parse the route definitions with path-to-regex functionality for paths, and
+ * query parameter validation
+ *
+ * @example
+ * {
+ *      original: the user-defined route definition
+ *      regex: regular expression based on the route definition path
+ *      toPath: function which takes an object of parameters and creates a path
+ *      params: an array of objects with info on each path parameter
+ *      compiledQuery: an object that represents defined routeDefintion query params
+ *      queryMatcher: a function that can be used to see if this route defintion
+ *                   mataches against a given input QueryObject
+ * }
+ */
+export declare function parseRoutes<TAddress>(config: RouterSerializationConfig<TAddress>): CompiledRouteDefinition[];
+/**
+ * Converts a QueryObject create from the routeDefintion.uri, and converts it into a
+ * CompiledQuery object that represents the defined 1) queryStringKeys, 2) routeParameter name,
+ * and 3) and what input is valid for this query. e.g.,
+ *
+ * Given the following uri: /path?someKey=:qParam, then "someKey" is the queryStringKey, ":qParam"
+ * is the route parameter name, and any input would be valid.
+ *
+ * @param {QueryObject} queryObject - queryObject retrieved from the routeDefinition uri
+ * @returns {CompiledQuery} - CompiledQuery
+ */
+export declare function compileQueryObject(queryObject: QueryObject): CompiledQuery;
+/**
+ * Takes a CompiledQuery a returns a QueryMatcher function that will match a QueryObject
+ * against the CompiledQuery and returns either a MatchedQuery, representing all the
+ * input values that match the CompiledQuery, or null if any input query parameter
+ * doesn't match the CompiledQuery.
+ *
+ * @param compiledQuery - CompiledQuery object to use to create the matcher
+ * @param {boolean} caseSensitive - true if this should case-sensitive match query values
+ * @returns {QueryMatcher} - The queryMatcher function
+ */
+export declare function getQueryMatcher(compiledQuery: CompiledQuery, caseSensitive?: boolean): QueryMatcher;
+//# sourceMappingURL=parseUtils.d.ts.map

package/build/bundle/prod/lwr/router/es/modules/lwr/routerUtils/pathToRegexp.d.ts

@@ -0,0 +1,128 @@
+export interface ParseOptions {
+    /**
+     * Set the default delimiter for repeat parameters. (default: `'/'`)
+     */
+    delimiter?: string;
+    /**
+     * List of characters to automatically consider prefixes when parsing.
+     */
+    prefixes?: string;
+}
+/**
+ * Parse a string for the raw tokens.
+ */
+export declare function parse(str: string, options?: ParseOptions): Token[];
+export interface TokensToFunctionOptions {
+    /**
+     * When `true` the regexp will be case sensitive. (default: `false`)
+     */
+    sensitive?: boolean;
+    /**
+     * Function for encoding input strings for output.
+     */
+    encode?: (value: string, token: Key) => string;
+    /**
+     * When `false` the function can produce an invalid (unmatched) path. (default: `true`)
+     */
+    validate?: boolean;
+}
+export declare type PathFunction<P extends object = object> = (data?: P) => string;
+/**
+ * Expose a method for transforming tokens into the path function.
+ */
+export declare function tokensToFunction<P extends object = object>(tokens: Token[], options?: TokensToFunctionOptions): PathFunction<P>;
+/**
+ * Compile a string to a template function for the path.
+ */
+export declare function compile<P extends object = object>(str: string, options?: ParseOptions & TokensToFunctionOptions): PathFunction<P>;
+export interface RegexpToFunctionOptions {
+    /**
+     * Function for decoding strings for params.
+     */
+    decode?: (value: string, token: Key) => string;
+}
+/**
+ * A match result contains data about the path match.
+ */
+export interface MatchResult<P extends object = object> {
+    path: string;
+    index: number;
+    params: P;
+}
+/**
+ * A match is either `false` (no match) or a match result.
+ */
+export declare type Match<P extends object = object> = false | MatchResult<P>;
+/**
+ * The match function takes a string and returns whether it matched the path.
+ */
+export declare type MatchFunction<P extends object = object> = (path: string) => Match<P>;
+/**
+ * Create a path match function from `path-to-regexp` output.
+ */
+export declare function regexpToFunction<P extends object = object>(re: RegExp, keys: Key[], options?: RegexpToFunctionOptions): MatchFunction<P>;
+/**
+ * Metadata about a key.
+ */
+export interface Key {
+    name: string | number;
+    prefix: string;
+    suffix: string;
+    pattern: string;
+    modifier: string;
+}
+/**
+ * A token is a string (nothing special) or key metadata (capture group).
+ */
+export declare type Token = string | Key;
+export interface TokensToRegexpOptions {
+    /**
+     * When `true` the regexp will be case sensitive. (default: `false`)
+     */
+    sensitive?: boolean;
+    /**
+     * When `true` the regexp won't allow an optional trailing delimiter to match. (default: `false`)
+     */
+    strict?: boolean;
+    /**
+     * When `true` the regexp will match to the end of the string. (default: `true`)
+     */
+    end?: boolean;
+    /**
+     * When `true` the regexp will match from the beginning of the string. (default: `true`)
+     */
+    start?: boolean;
+    /**
+     * Sets the final character for non-ending optimistic matches. (default: `/`)
+     */
+    delimiter?: string;
+    /**
+     * List of characters that can also be "end" characters.
+     */
+    endsWith?: string;
+    /**
+     * Encode path tokens for use in the `RegExp`.
+     */
+    encode?: (value: string) => string;
+}
+/**
+ * Expose a function for taking tokens and returning a RegExp.
+ */
+export declare function tokensToRegexp(tokens: Token[], keys?: Key[], options?: TokensToRegexpOptions): RegExp;
+/**
+ * Supported `path-to-regexp` input types.
+ */
+export declare type Path = string | RegExp | Array<string | RegExp>;
+/**
+ * Normalize the given path string, returning a regular expression.
+ *
+ * An empty array can be passed in for the keys, which will hold the
+ * placeholder key descriptions. For example, using `/user/:id`, `keys` will
+ * contain `[{ name: 'id', delimiter: '/', optional: false, repeat: false }]`.
+ */
+export declare function pathToRegexp(path: Path, keys?: Key[], options?: TokensToRegexpOptions & ParseOptions): RegExp;
+/**
+ * Create path match function from `path-to-regexp` spec.
+ */
+export declare function match<P extends object = object>(str: Path, options?: ParseOptions & TokensToRegexpOptions & RegexpToFunctionOptions): MatchFunction<P>;
+//# sourceMappingURL=pathToRegexp.d.ts.map

package/build/bundle/prod/lwr/router/es/modules/lwr/routerUtils/routeDefUtils.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Copyright (c) 2019, salesforce.com, inc.
+ * All rights reserved.
+ * SPDX-License-Identifier: MIT
+ * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
+ */
+import type { CompiledRouteDefinition, PageReference, StringAttributes, QueryObject, NullableStringAttributes } from './types';
+/**
+ * f(route, routes[]) -> RouteDef
+ * Match a route's id to a Route Definition id from the given list.
+ *
+ * @param {object} route - Route to match to a Route Definition
+ * @param {array[object]} routeDefs - List of Route Definitions to match to the url
+ *
+ * @returns {object | null}
+ */
+export declare function matchRouteDefinitionByPageReference(pageReference: PageReference, routeDefs: CompiledRouteDefinition[]): CompiledRouteDefinition | null;
+/**
+ * Returns an object of paramName->pathValue pairs based on the given path string
+ * and the params defined within the routeDef uri
+ * @param path
+ * @param routeDef
+ */
+export declare function getPathParams(path: string, routeDef: CompiledRouteDefinition): StringAttributes | null;
+/**
+ * Returns an object of paramName->queryValue pairs based on the given queryObject
+ * and bindings defined within the routeDef uri
+ * @param queryObj
+ * @param routeDef
+ */
+export declare function getQueryParams(queryObj: QueryObject, routeDef: CompiledRouteDefinition): NullableStringAttributes | null;
+/**
+ * f(path, routeDef) -> { "attr1": "one", "attr2": "two" }
+ * Parse a path into an object of attributes based on the Route Definition's parameterized path.
+ * URI decode the path parts that are parsed as attributes.
+ *
+ * @param {string} path - A path (hopefully) matching the Route Definition
+ * @param {object} routeDef - Route Definition containing the path to parameterize
+ *
+ * @returns {object}
+ */
+export declare function getPageReferenceFromUriAndRouteDef(uri: string, routeDef: CompiledRouteDefinition): PageReference | null;
+//# sourceMappingURL=routeDefUtils.d.ts.map

package/build/bundle/prod/lwr/router/es/modules/lwr/routerUtils/routeUtils.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Copyright (c) 2019, salesforce.com, inc.
+ * All rights reserved.
+ * SPDX-License-Identifier: MIT
+ * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
+ */
+import type { CompiledRouteDefinition, CompiledRoutingMatch, PageReference } from './types';
+/**
+ * f(URL, routes[]?) -> route
+ * Match a URL's path to a Route Definition, use these to build a route.
+ *
+ * @param {string} url - URL string to turn into a route
+ * @param {array[object]} routeDefs - List of Route Definitions to match to the url
+ * @param {string} basePath - Optional: if provided, remove the base path before conversion.
+ *
+ * @returns {object}
+ */
+export declare function matchRouteByUrl(url: string, routeDefs: CompiledRouteDefinition[], basePath?: string): CompiledRoutingMatch | null;
+/**
+ * Serializes the given pageReference into a url based on the first route definition
+ * with a binding the pageReference matches against.
+ * @param pageReference pageReference to serialize into url
+ * @param routeDefs RouteDefs to match pageReference against
+ * @param basePath Base path for the url
+ * @returns the url or null if no match
+ */
+export declare function getUrlFromPageReference(pageReference: PageReference, routeDefs: CompiledRouteDefinition[], basePath?: string): string | null;
+/**
+ * Generates a url for the given pageReference using the given routeDef
+ * @param pageReference pageReference to serialize
+ * @param routeDef routeDef to that defines how serialize the given pageReference
+ * @returns url for the given pageReference
+ */
+export declare function getUrlFromPageReferenceAndRouteDef(pageReference: PageReference, routeDef: CompiledRouteDefinition, basePath?: string): string;
+/**
+ * Obtains the pageReference for the given URL
+ */
+export declare function getPageReferenceFromUrl(url: string, routeDefs: CompiledRouteDefinition[], basePath?: string): PageReference | null;
+//# sourceMappingURL=routeUtils.d.ts.map

package/build/bundle/prod/lwr/router/es/modules/lwr/routerUtils/routerUtils.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Copyright (c) 2019, salesforce.com, inc.
+ * All rights reserved.
+ * SPDX-License-Identifier: MIT
+ * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
+ */
+export { createFilterChain } from './filterUtils';
+export { getPageReferenceFromUriAndRouteDef } from './routeDefUtils';
+export { getUrlFromPageReference, getPageReferenceFromUrl, matchRouteByUrl, getUrlFromPageReferenceAndRouteDef, } from './routeUtils';
+export { isObject, freeze, guid, isValidRoute } from './typeUtils';
+export { parseRoutes } from './parseUtils';
+import { pathToRegexp as ptr, compile as ptrCompile } from './pathToRegexp';
+export declare const pathToRegexp: {
+    pathToRegexp: typeof ptr;
+    compile: typeof ptrCompile;
+};
+export { getPathFromUrl, getQueryFromUrl, getQueryString, encode, decode } from './uriUtils';
+export { hasDocument } from './domUtils';
+export type { Key } from './pathToRegexp';
+export type { Filter, FilterChain } from './filterUtils';
+export type { CompiledRouteDefinition, CompiledRoutingMatch, Constructor, Constructable, MessageObject, Module, PageReference, RouteCallback, RouteDefinition, RouteHandler, RouteHandlerCallback, RouteHandlerClass, RouteHandlerModule, Router, RouterConfig, RouteDestination, RouteInstance, RoutingMatch, RoutingResult, StringAttributes, UrlMapper, ViewSet, ViewInfo, RouterSerializationConfig, } from './types';
+//# sourceMappingURL=routerUtils.d.ts.map

package/build/bundle/prod/lwr/router/es/modules/lwr/routerUtils/typeUtils.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Copyright (c) 2019, salesforce.com, inc.
+ * All rights reserved.
+ * SPDX-License-Identifier: MIT
+ * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
+ */
+/**
+ * @param {*} o - Item to check if it's an object
+ * @returns {boolean}
+ */
+export declare function isObject(o: unknown): boolean;
+/**
+ * true if input is string
+ * @param o
+ */
+export declare function isString(o: unknown): boolean;
+/**
+ * @param {*} o - Object to freeze N layers deep (e.g. { prop: 'p', o: { one: 1, two: 2 } })
+ */
+export declare function freeze(o: object, depthLimit?: number): object;
+/**
+ * Return a 4 character identifier.
+ */
+export declare function guid(): string;
+/**
+ * f(route) -> true/false
+ *
+ * @param {*} route - Item to check if it's a valid route
+ *
+ * @returns {boolean}
+ */
+export declare function isValidRoute(object: unknown): boolean;
+/**
+ * Returns true if the given object is a valid pageReference.
+ * @param object
+ */
+export declare function isValidPageReference(object: unknown): boolean;
+//# sourceMappingURL=typeUtils.d.ts.map

package/build/bundle/prod/lwr/router/es/modules/lwr/routerUtils/types.d.ts

@@ -0,0 +1,133 @@
+import type { Key, PathFunction } from './pathToRegexp';
+import type { ContextId } from 'lwr/navigationContext';
+import { Unsubscriber } from 'lwr/observable';
+export declare type Module = Record<string | symbol | number, unknown>;
+export declare type Constructor<T = object> = new (...args: any[]) => T;
+export interface Constructable<T = object> {
+    constructor: Constructor<T>;
+}
+export declare type UrlMapper<TAddress> = {
+    generateUrl(address: TAddress): string | null;
+    parseUrl(url: string): TAddress | null;
+};
+export declare type RouteMatcher<TAddress> = {
+    matchRoute(address: TAddress): RoutingMatch | null;
+};
+export declare type ViewMapper<TAddress> = {
+    navigate(address: TAddress): void;
+    subscribe(callback: RouteCallback, replay?: boolean): Unsubscriber;
+    resolveView(address: TAddress): Promise<RouteDestination>;
+    contextId?: ContextId;
+};
+export declare type Router<TAddress = string> = ViewMapper<TAddress> & UrlMapper<TAddress> & RouteMatcher<TAddress>;
+export interface DEPRECATED_getRouteFromUrl {
+    <TAddress>(url: string, defaultImpl: Function): TAddress | null;
+}
+export interface DEPRECATED_getUrlFromRoute {
+    <TAddress>(route: TAddress, defaultImpl: Function): string | null;
+}
+export declare type RouterConfig = {
+    basePath?: string;
+    routes?: RouteDefinition[];
+    caseSensitive?: boolean;
+    DEPRECATED_getRouteFromUrl?: DEPRECATED_getRouteFromUrl;
+    DEPRECATED_getUrlFromRoute?: DEPRECATED_getUrlFromRoute;
+};
+export declare type RouterSerializationConfig<TAddress> = Required<Omit<RouterConfig, 'DEPRECATED_getRouteFromUrl' | 'DEPRECATED_getUrlFromRoute'> & UrlMapper<TAddress>>;
+export declare type RouteParameterPatterns = {
+    [paramName: string]: string;
+};
+export interface RouteDefinition<TMetadata = Record<string, any>> {
+    id: string;
+    uri: string;
+    patterns?: RouteParameterPatterns;
+    exact?: boolean;
+    page: Partial<PageReference>;
+    handler: () => Promise<RouteHandlerModule>;
+    metadata?: TMetadata;
+}
+export declare type PageBindings = {
+    attributeBindings: NullableStringAttributes;
+    stateBindings: NullableStringAttributes;
+};
+declare type CompiledQueryResult = {
+    literalValue?: string | null;
+    routeParamName?: string;
+};
+export declare type CompiledQuery = Record<string, CompiledQueryResult>;
+declare type MatchedQueryResult = {
+    value: string | null;
+    routeParamName?: string;
+};
+export declare type MatchedQuery = Record<string, MatchedQueryResult>;
+export declare type QueryMatcher = (queryObject: QueryObject) => MatchedQuery | null;
+export interface CompiledRouteDefinition {
+    original: RouteDefinition;
+    regex: RegExp;
+    params: Key[];
+    toPath: PathFunction<object>;
+    compiledQuery: CompiledQuery;
+    queryMatcher: QueryMatcher;
+}
+export declare type RouteHandlerCallback = (routeDestination: RouteDestination) => void;
+export declare type RouteHandlerClass = {
+    new (callback: RouteHandlerCallback): RouteHandler;
+};
+export declare type RouteHandlerModule = {
+    default: RouteHandlerClass;
+};
+export interface RouteInstance {
+    id: string;
+    attributes: NullableStringAttributes;
+    state: NullableStringAttributes;
+    pageReference: PageReference;
+}
+export declare type RouteDestination = {
+    status?: 200 | 404 | 500;
+    viewset: ViewSet;
+    error?: Error;
+};
+export declare type RoutingMatch = {
+    pathMatch: string;
+    route: RouteInstance;
+    routeDefinition: RouteDefinition;
+};
+export interface CompiledRoutingMatch {
+    route: RouteInstance;
+    routeDefinition: CompiledRouteDefinition;
+}
+export declare type RoutingResult = RoutingMatch & RouteDestination;
+export interface ViewSet {
+    [viewName: string]: (() => Promise<Module>) | ViewInfo;
+}
+export interface ViewInfo {
+    module: () => Promise<Module>;
+    specifier: string;
+}
+export declare type RouteCallback = (result: RoutingResult) => void;
+export interface RouteHandler {
+    dispose(): void;
+    update(routeInfo: RouteInstance): void;
+}
+export interface PageReference {
+    type: string;
+    attributes: NullableStringAttributes;
+    state: NullableStringAttributes;
+}
+export interface MessageObject {
+    code: string | number;
+    message: string;
+    level: number;
+    stack?: string;
+    url?: string;
+    address?: string;
+}
+export declare type QueryObject = NullableStringAttributes;
+export interface StringAttributes {
+    [key: string]: string;
+}
+export interface NullableStringAttributes {
+    [key: string]: string | null;
+}
+export {};
+//# sourceMappingURL=types.d.ts.map