@microsoft/fast-router 0.4.2 → 1.0.0-alpha.1

package/dist/fast-router.untrimmed.d.ts

@@ -0,0 +1,825 @@
+import { AddViewBehaviorFactory } from '@microsoft/fast-element';
+import { Behavior } from '@microsoft/fast-element';
+import { ComposableStyles } from '@microsoft/fast-element';
+import { Constructable } from '@microsoft/fast-element';
+import { ExecutionContext } from '@microsoft/fast-element';
+import { FASTElement } from '@microsoft/fast-element';
+import { HTMLDirective } from '@microsoft/fast-element';
+import { ViewBehaviorTargets } from '@microsoft/fast-element';
+import { ViewTemplate } from '@microsoft/fast-element';
+
+/**
+ * @internal
+ */
+export declare const childRouteParameter = "fast-child-route";
+
+/**
+ * @beta
+ */
+export declare type CommandFallbackRouteDefinition<TSettings = any> = HasCommand & SupportsSettings<TSettings> & HasTitle;
+
+/**
+ * @beta
+ */
+export declare type CommandRouteDefinition<TSettings = any> = PathedRouteDefinition<TSettings> & HasCommand & HasTitle;
+
+/**
+ * @beta
+ */
+export declare class ConfigurableRoute implements Route {
+    readonly path: string;
+    readonly name: string;
+    readonly caseSensitive: boolean;
+    constructor(path: string, name: string, caseSensitive: boolean);
+}
+
+/**
+ * @beta
+ */
+export declare type ContributorOptions = {
+    lifecycle?: boolean;
+    parameters?: boolean;
+};
+
+/**
+ * @beta
+ */
+export declare type ConverterObject = {
+    convert: RouteParameterConverter;
+};
+
+/**
+ * @beta
+ */
+export declare class DefaultLinkHandler implements LinkHandler {
+    private handler;
+    connect(): void;
+    disconnect(): void;
+    private getEventInfo;
+    private findClosestAnchor;
+    private targetIsThisWindow;
+}
+
+/**
+ * @beta
+ */
+export declare class DefaultNavigationProcess<TSettings> {
+    private phases;
+    run(router: Router, message: NavigationMessage): Promise<void>;
+    commit(phase: NavigationPhaseImpl): void;
+}
+
+/**
+ * @beta
+ */
+export declare class DefaultNavigationQueue implements NavigationQueue, NavigationHandler {
+    private queue;
+    private promise;
+    private resolve;
+    connect(): void;
+    disconnect(): void;
+    receive(): Promise<NavigationMessage>;
+    enqueue(msg: NavigationMessage): void;
+    private tryDequeue;
+    handleEvent(event: PopStateEvent): void;
+}
+
+/**
+ * @beta
+ */
+export declare class DefaultRouter implements Router {
+    readonly host: HTMLElement;
+    private parentRouter;
+    private contributors;
+    private navigationQueue;
+    private linkHandler;
+    private newView;
+    private newRoute;
+    private childCommandContributor;
+    private childRoute;
+    private isConnected;
+    private routerConfig;
+    private view;
+    route: RecognizedRoute | null;
+    constructor(host: HTMLElement);
+    get config(): RouterConfiguration | null;
+    set config(value: RouterConfiguration | null);
+    get parent(): Router<any> | null;
+    get level(): number;
+    shouldRender(route: RecognizedRoute): boolean;
+    beginRender(route: RecognizedRoute, command: RenderCommand): Promise<{
+        commit: any;
+        rollback: any;
+    }>;
+    connect(): void;
+    disconnect(): void;
+    addContributor(contributor: NavigationContributor): void;
+    removeContributor(contributor: NavigationContributor): void;
+    private tryConnect;
+    private onNavigationMessage;
+    private renderOperationCommit;
+    private renderOperationRollback;
+    private navigate;
+    private leave;
+    private construct;
+    private enter;
+    private commit;
+    private tunnel;
+}
+
+/**
+ * @beta
+ */
+export declare class DefaultRouteRecognizer<TSettings> implements RouteRecognizer<TSettings> {
+    private names;
+    private paths;
+    private readonly rootState;
+    add(routeOrRoutes: Route | readonly Route[], settings?: TSettings): void;
+    private $add;
+    recognize(path: string, converters?: Readonly<Record<string, RouteParameterConverter>>): Promise<RecognizedRoute<TSettings> | null>;
+    /**
+     * Generate a path and query string from a route name and params object.
+     *
+     * @param name - The name of the route to generate from.
+     * @param params - The route params to use when populating the pattern.
+     * Properties not required by the pattern will be appended to the query string.
+     * @returns The generated absolute path and query string.
+     */
+    generateFromName(name: string, params: object): string | null;
+    /**
+     * Generate a path and query string from a route path and params object.
+     *
+     * @param path - The path of the route to generate from.
+     * @param params - The route params to use when populating the pattern.
+     * Properties not required by the pattern will be appended to the query string.
+     * @returns The generated absolute path and query string.
+     */
+    generateFromPath(path: string, params: object): string | null;
+    private generate;
+}
+
+/**
+ * @beta
+ */
+export declare type DefinitionCallback = () => Promise<FallbackRouteDefinition> | FallbackRouteDefinition;
+
+/**
+ * @beta
+ */
+export declare type ElementFallbackRouteDefinition<TSettings = any> = LayoutAndTransitionRouteDefinition & HasElement & SupportsSettings<TSettings> & HasTitle;
+
+/**
+ * @beta
+ */
+export declare type ElementRouteDefinition<TSettings = any> = NavigableRouteDefinition<TSettings> & HasElement;
+
+/**
+ * @beta
+ */
+export declare class Endpoint<TSettings = any> {
+    readonly route: ConfigurableRoute;
+    readonly paramNames: readonly string[];
+    readonly paramTypes: readonly string[];
+    readonly settings: TSettings | null;
+    constructor(route: ConfigurableRoute, paramNames: readonly string[], paramTypes: readonly string[], settings: TSettings | null);
+    get path(): string;
+}
+
+/**
+ * @beta
+ */
+export declare type FallbackRouteDefinition<TSettings = any> = ElementFallbackRouteDefinition<TSettings> | TemplateFallbackRouteDefinition<TSettings> | Pick<RedirectRouteDefinition<TSettings>, "redirect"> | CommandFallbackRouteDefinition<TSettings>;
+
+/**
+ * @beta
+ */
+export declare type FASTElementConstructor = new () => FASTElement;
+
+/**
+ * @beta
+ */
+export declare class FASTElementLayout implements Layout {
+    private readonly template;
+    private runBeforeCommit;
+    private styles;
+    constructor(template?: ViewTemplate | null, styles?: ComposableStyles | ComposableStyles[] | null, runBeforeCommit?: boolean);
+    beforeCommit(routerElement: HTMLElement): Promise<void>;
+    afterCommit(routerElement: HTMLElement): Promise<void>;
+    private apply;
+}
+
+/**
+ * @beta
+ */
+export declare class FASTRouter extends FASTRouter_base {
+}
+
+declare const FASTRouter_base: new () => FASTElement & RouterElement;
+
+/**
+ * @beta
+ */
+export declare type HasCommand = {
+    command: NavigationCommand;
+};
+
+/**
+ * @beta
+ */
+export declare type HasElement = {
+    element: string | FASTElementConstructor | HTMLElement | (() => Promise<string | FASTElementConstructor | HTMLElement>);
+};
+
+/**
+ * @beta
+ */
+export declare type HasTemplate = {
+    template: ViewTemplate | (() => Promise<ViewTemplate>);
+};
+
+/**
+ * @beta
+ */
+export declare type HasTitle = {
+    title?: string;
+};
+
+/**
+ * @beta
+ */
+export declare type IgnorableRouteDefinition<TSettings = any> = PathedRouteDefinition<TSettings>;
+
+/**
+ * @beta
+ */
+export declare class Ignore implements NavigationCommand {
+    createContributor(): Promise<{
+        navigate(phase: NavigationPhase): Promise<void>;
+    }>;
+}
+
+/**
+ * @beta
+ */
+export declare function isFASTElementHost(host: HTMLElement): host is HTMLElement & FASTElement;
+
+/**
+ * @beta
+ */
+export declare function isNavigationPhaseContributor<T extends NavigationPhaseName>(object: any, phase: T): object is Record<T, NavigationPhaseHook>;
+
+/**
+ * @beta
+ */
+export declare interface Layout {
+    beforeCommit(routerElement: HTMLElement): Promise<void>;
+    afterCommit(routerElement: HTMLElement): Promise<void>;
+}
+
+/**
+ * @beta
+ */
+export declare const Layout: Readonly<{
+    default: Readonly<Layout>;
+}>;
+
+/**
+ * @beta
+ */
+export declare type LayoutAndTransitionRouteDefinition = {
+    layout?: Layout | ViewTemplate;
+    transition?: Transition;
+};
+
+/**
+ * @beta
+ */
+export declare interface LinkHandler {
+    connect(): void;
+    disconnect(): void;
+}
+
+/**
+ * @beta
+ */
+export declare type MappableRouteDefinition<TSettings = any> = RenderableRouteDefinition<TSettings> | RedirectRouteDefinition<TSettings> | CommandRouteDefinition<TSettings> | ParentRouteDefinition<TSettings>;
+
+/**
+ * @beta
+ */
+export declare type NavigableRouteDefinition<TSettings = any> = PathedRouteDefinition<TSettings> & LayoutAndTransitionRouteDefinition & HasTitle & {
+    childRouters?: boolean;
+};
+
+/**
+ * @beta
+ */
+export declare interface NavigationCommand {
+    createContributor(router: Router, route: RecognizedRoute): Promise<NavigationContributor>;
+}
+
+/**
+ * @beta
+ */
+export declare interface NavigationCommitPhase<TSettings = any> extends Omit<NavigationPhase<TSettings>, "cancel" | "canceled" | "onCancel"> {
+    setTitle(title: string): any;
+}
+
+/**
+ * @beta
+ */
+export declare type NavigationCommitPhaseHook<TSettings = any> = (phase: NavigationCommitPhase<TSettings>) => Promise<any> | any;
+
+/**
+ * @beta
+ */
+export declare type NavigationContributor<TSettings = any> = Partial<Record<Exclude<NavigationPhaseName, "commit">, NavigationPhaseHook<TSettings>>> & {
+    commit?: NavigationCommitPhaseHook<TSettings>;
+};
+
+/**
+ * @beta
+ */
+export declare function navigationContributor(options?: ContributorOptions): NavigationContributorDirective;
+
+declare class NavigationContributorBehavior implements Behavior {
+    private contributor;
+    private options;
+    private router;
+    constructor(contributor: HTMLElement & NavigationContributor, options: Required<ContributorOptions>);
+    bind(source: unknown, context: RouterExecutionContext): void;
+    unbind(source: unknown): void;
+}
+
+declare class NavigationContributorDirective implements HTMLDirective {
+    private options;
+    id: string;
+    nodeId: string;
+    constructor(options: Required<ContributorOptions>);
+    createHTML(add: AddViewBehaviorFactory): string;
+    createBehavior(targets: ViewBehaviorTargets): NavigationContributorBehavior;
+}
+
+/**
+ * @beta
+ */
+export declare interface NavigationHandler {
+    enqueue(msg: NavigationMessage): void;
+}
+
+/**
+ * @beta
+ */
+export declare const NavigationHandler: Readonly<{
+    register(handler: NavigationHandler): void;
+    unregister(handler: NavigationHandler): void;
+}>;
+
+/**
+ * @beta
+ */
+export declare class NavigationMessage {
+    path: string;
+    constructor(path: string);
+}
+
+/**
+ * @beta
+ */
+export declare interface NavigationPhase<TSettings = any> {
+    readonly name: NavigationPhaseName;
+    readonly route: RecognizedRoute<TSettings>;
+    readonly router: Router<TSettings>;
+    readonly canceled: boolean;
+    cancel(callback?: NavigationPhaseFollowupAction): void;
+    onCancel(callback: NavigationPhaseFollowupAction): void;
+    onCommit(callback: NavigationPhaseFollowupAction): void;
+    evaluateContributor(contributor: any, route?: RecognizedRoute<TSettings>, router?: Router<TSettings>): Promise<void>;
+}
+
+/**
+ * @beta
+ */
+export declare type NavigationPhaseFollowupAction = () => Promise<any> | any;
+
+/**
+ * @beta
+ */
+export declare type NavigationPhaseHook<TSettings = any> = (phase: NavigationPhase<TSettings>) => Promise<any> | any;
+
+declare class NavigationPhaseImpl<TSettings = any> implements NavigationCommitPhase<TSettings> {
+    readonly name: NavigationPhaseName;
+    private readonly commitActions;
+    private readonly cancelActions;
+    private routes;
+    private routers;
+    canceled: boolean;
+    titles: Array<Array<string>>;
+    get route(): RecognizedRoute<TSettings>;
+    get router(): Router;
+    constructor(name: NavigationPhaseName, route: RecognizedRoute<TSettings>, router: Router<TSettings>, commitActions: NavigationPhaseFollowupAction[], cancelActions: NavigationPhaseFollowupAction[]);
+    cancel(callback?: NavigationPhaseFollowupAction): void;
+    onCommit(callback: NavigationPhaseFollowupAction): void;
+    onCancel(callback: NavigationPhaseFollowupAction): void;
+    setTitle(title: string): void;
+    evaluateContributor(contributor: any, route?: RecognizedRoute<TSettings>, router?: Router): Promise<void>;
+}
+
+/**
+ * @beta
+ */
+export declare type NavigationPhaseName = "navigate" | "leave" | "construct" | "enter" | "commit";
+
+/**
+ * @beta
+ */
+export declare interface NavigationProcess {
+    run(router: Router, message: NavigationMessage): Promise<void>;
+}
+
+/**
+ * @beta
+ */
+export declare interface NavigationQueue {
+    connect(): void;
+    disconnect(): void;
+    receive(): Promise<NavigationMessage>;
+}
+
+/**
+ * @beta
+ */
+export declare type ParameterConverter = RouteParameterConverter | ConverterObject | Constructable<ConverterObject>;
+
+/**
+ * @beta
+ */
+export declare type ParentRouteDefinition<TSettings = any> = PathedRouteDefinition<TSettings> & LayoutAndTransitionRouteDefinition & {
+    children: MappableRouteDefinition<TSettings>[];
+};
+
+/**
+ * @beta
+ */
+export declare type PathedRouteDefinition<TSettings = any> = SupportsSettings<TSettings> & Route;
+
+/**
+ * @beta
+ */
+export declare const QueryString: Readonly<{
+    readonly current: string;
+    /**
+     * Generate a query string from an object.
+     *
+     * @param params - Object containing the keys and values to be used.
+     * @param traditional - Boolean Use the old URI template standard (RFC6570)
+     * @returns The generated query string, excluding leading '?'.
+     */
+    build(params: Object, traditional?: boolean): string;
+    /**
+     * Separate the query string from the path and returns the two parts.
+     * @param path - The path to separate.
+     */
+    separate(path: string): Readonly<{
+        path: string;
+        queryString: string;
+    }>;
+    /**
+     * Parse a query string.
+     *
+     * @param queryString - The query string to parse.
+     * @returns Object with keys and values mapped from the query string.
+     */
+    parse(queryString: string): Readonly<Record<string, string>>;
+}>;
+
+/**
+ * @beta
+ */
+export declare class RecognizedRoute<TSettings = any> {
+    readonly endpoint: Endpoint<TSettings>;
+    readonly params: Readonly<Record<string, string | undefined>>;
+    readonly typedParams: Readonly<Record<string, any>>;
+    readonly queryParams: Readonly<Record<string, string>>;
+    readonly allParams: Readonly<Record<string, string | undefined>>;
+    readonly allTypedParams: Readonly<Record<string, any>>;
+    constructor(endpoint: Endpoint<TSettings>, params: Readonly<Record<string, string | undefined>>, typedParams: Readonly<Record<string, any>>, queryParams: Readonly<Record<string, string>>);
+    get settings(): TSettings | null;
+}
+
+/**
+ * @beta
+ */
+export declare class Redirect implements NavigationCommand {
+    private redirect;
+    constructor(redirect: string);
+    createContributor(): Promise<{
+        navigate(phase: NavigationPhase): Promise<void>;
+    }>;
+}
+
+/**
+ * @beta
+ */
+export declare type RedirectRouteDefinition<TSettings = any> = PathedRouteDefinition<TSettings> & {
+    redirect: string;
+};
+
+/**
+ * @beta
+ */
+export declare class Render implements RenderCommand {
+    private owner;
+    createView: () => Promise<RouteView>;
+    private _layout;
+    private _transition;
+    title: string;
+    constructor(owner: RouterConfiguration, createView: () => Promise<RouteView>);
+    get transition(): Transition;
+    set transition(value: Transition);
+    get layout(): Layout;
+    set layout(value: Layout);
+    createContributor(router: Router, route: RecognizedRoute): Promise<RenderContributor>;
+    static fromDefinition(owner: RouterConfiguration, definition: ElementRouteDefinition | TemplateRouteDefinition | ElementFallbackRouteDefinition | TemplateFallbackRouteDefinition): Render;
+}
+
+/**
+ * @beta
+ */
+export declare type RenderableRouteDefinition<TSettings = any> = ElementRouteDefinition<TSettings> | TemplateRouteDefinition<TSettings>;
+
+/**
+ * @beta
+ */
+export declare interface RenderCommand extends NavigationCommand {
+    layout: Layout;
+    transition: Transition;
+    createView(): Promise<RouteView>;
+}
+
+declare class RenderContributor {
+    private router;
+    private route;
+    private command;
+    private operation;
+    constructor(router: Router, route: RecognizedRoute, command: Render);
+    construct(phase: NavigationPhase): Promise<void>;
+    commit(phase: NavigationCommitPhase): Promise<void>;
+}
+
+/**
+ * @beta
+ */
+export declare interface RenderOperation {
+    commit(): Promise<void>;
+    rollback(): Promise<void>;
+}
+
+/**
+ * @beta
+ */
+export declare interface Route {
+    readonly path: string;
+    readonly name?: string;
+    readonly caseSensitive?: boolean;
+}
+
+/**
+ * @beta
+ */
+export declare const Route: Readonly<{
+    path: Readonly<{
+        readonly current: string;
+        generateRoute(relativeTo: HTMLElement | Router, path: string, params?: Object): Promise<string | null>;
+        push(path: string, trigger?: boolean): void;
+        replace(path: string, trigger?: boolean): void;
+        trigger(path: string): void;
+    }>;
+    name: Readonly<{
+        generateRoute(relativeTo: HTMLElement | Router, name: string, params?: Object): Promise<string | null>;
+        push(relativeTo: HTMLElement | Router, name: string, params?: Object, trigger?: boolean): Promise<void>;
+        replace(relativeTo: HTMLElement | Router, name: string, params?: Object, trigger?: boolean): Promise<void>;
+        trigger(relativeTo: HTMLElement | Router, name: string, params?: Object): Promise<void>;
+    }>;
+}>;
+
+/**
+ * @beta
+ */
+export declare class RouteCollection<TSettings = any> {
+    private owner;
+    private _recognizer;
+    private pathToCommand;
+    private fallbackCommand;
+    private fallbackSettings;
+    private converters;
+    constructor(owner: RouterConfiguration);
+    private get recognizer();
+    ignore(definitionOrString: IgnorableRouteDefinition<TSettings> | string): void;
+    map(...routes: MappableRouteDefinition<TSettings>[]): void;
+    fallback(definitionOrCallback: FallbackRouteDefinition<TSettings> | DefinitionCallback): void;
+    converter(name: string, converter: ParameterConverter): void;
+    recognize(path: string): Promise<RouteMatch<TSettings> | null>;
+    /**
+     * Generate a path and query string from a route name and params object.
+     *
+     * @param name - The name of the route to generate from.
+     * @param params - The route params to use when populating the pattern.
+     * Properties not required by the pattern will be appended to the query string.
+     * @returns The generated absolute path and query string.
+     */
+    generateFromName(name: string, params: object): string | null;
+    /**
+     * Generate a path and query string from a route path and params object.
+     *
+     * @param path - The path of the route to generate from.
+     * @param params - The route params to use when populating the pattern.
+     * Properties not required by the pattern will be appended to the query string.
+     * @returns The generated absolute path and query string.
+     */
+    generateFromPath(path: string, params: object): string | null;
+    private aggregateConverters;
+}
+
+/**
+ * @beta
+ */
+export declare type RouteMatch<TSettings = any> = {
+    route: RecognizedRoute<TSettings>;
+    command: NavigationCommand;
+};
+
+/**
+ * @beta
+ */
+export declare type RouteParameterConverter = (value: string | undefined) => any | Promise<any>;
+
+/**
+ * @beta
+ */
+export declare interface Router<TSettings = any> {
+    readonly level: number;
+    readonly parent: Router | null;
+    readonly route: RecognizedRoute | null;
+    config: RouterConfiguration | null;
+    connect(): void;
+    disconnect(): void;
+    shouldRender(route: RecognizedRoute<TSettings>): boolean;
+    beginRender(route: RecognizedRoute<TSettings>, command: RenderCommand): Promise<RenderOperation>;
+    addContributor(contributor: NavigationContributor): void;
+    removeContributor(contributor: NavigationContributor): void;
+}
+
+/**
+ * @beta
+ */
+export declare const Router: Readonly<{
+    getOrCreateFor(element: HTMLElement): Router<any> | DefaultRouter;
+    find(element: HTMLElement): Router | null;
+    from<TBase extends {
+        new (): HTMLElement;
+        prototype: HTMLElement;
+    }>(BaseType: TBase): new () => InstanceType<TBase> & RouterElement;
+}>;
+
+/**
+ * @beta
+ */
+export declare abstract class RouterConfiguration<TSettings = any> {
+    private isConfigured;
+    readonly routes: RouteCollection<TSettings>;
+    readonly contributors: NavigationContributor<TSettings>[];
+    defaultLayout: Layout;
+    defaultTransition: Readonly<Transition>;
+    title: string;
+    parent: RouterConfiguration<TSettings> | null;
+    createNavigationQueue(): NavigationQueue;
+    createLinkHandler(): LinkHandler;
+    createNavigationProcess(): NavigationProcess;
+    createEventSink(): RoutingEventSink;
+    createTitleBuilder(): TitleBuilder;
+    createRouteRecognizer(): RouteRecognizer<TSettings>;
+    construct<T>(Type: Constructable<T>): T;
+    recognizeRoute(path: string): Promise<RouteMatch<TSettings> | null>;
+    /**
+     * Generate a path and query string from a route name and params object.
+     *
+     * @param name - The name of the route to generate from.
+     * @param params - The route params to use when populating the pattern.
+     * Properties not required by the pattern will be appended to the query string.
+     * @returns The generated absolute path and query string.
+     */
+    generateRouteFromName(name: string, params: object): Promise<string | null>;
+    /**
+     * Generate a path and query string from a route path and params object.
+     *
+     * @param path - The path of the route to generate from.
+     * @param params - The route params to use when populating the pattern.
+     * Properties not required by the pattern will be appended to the query string.
+     * @returns The generated absolute path and query string.
+     */
+    generateRouteFromPath(path: string, params: object): Promise<string | null>;
+    findContributors<T extends NavigationPhaseName>(phase: T): Record<T, NavigationPhaseHook<TSettings>>[];
+    protected abstract configure(): Promise<void> | void;
+    protected cached(ElementType: new () => HTMLElement): () => Promise<HTMLElement>;
+    private ensureConfigured;
+}
+
+/**
+ * @beta
+ */
+export declare interface RouteRecognizer<TSettings> {
+    add(routeOrRoutes: Route | readonly Route[], settings?: TSettings): void;
+    recognize(path: string, converters?: Readonly<Record<string, RouteParameterConverter>>): Promise<RecognizedRoute<TSettings> | null>;
+    generateFromName(name: string, params: object): string | null;
+    generateFromPath(path: string, params: object): string | null;
+}
+
+/**
+ * @beta
+ */
+export declare interface RouterElement extends HTMLElement {
+    readonly [routerProperty]: Router;
+    config: RouterConfiguration | null;
+    connectedCallback(): any;
+    disconnectedCallback(): any;
+}
+
+/**
+ * @beta
+ */
+export declare type RouterExecutionContext = ExecutionContext & {
+    router: Router;
+};
+
+/**
+ * @beta
+ */
+export declare const RouterExecutionContext: Readonly<{
+    create(router: Router): any;
+}>;
+
+declare const routerProperty = "$router";
+
+/**
+ * @beta
+ */
+export declare interface RouteView {
+    bind(allTypedParams: Readonly<Record<string, any>>, context: RouterExecutionContext): void;
+    appendTo(host: HTMLElement): void;
+    dispose(): void;
+}
+
+/**
+ * @beta
+ */
+declare interface RoutingEventSink {
+    onUnhandledNavigationMessage(router: Router, message: NavigationMessage): void;
+    onNavigationBegin(router: Router, route: RecognizedRoute, command: NavigationCommand): void;
+    onPhaseBegin(phase: NavigationPhase): void;
+    onPhaseEnd(phase: NavigationPhase): void;
+    onNavigationEnd(router: Router, route: RecognizedRoute, command: NavigationCommand): void;
+}
+
+/**
+ * @beta
+ */
+export declare type SupportsSettings<TSettings = any> = {
+    settings?: TSettings;
+};
+
+/**
+ * @beta
+ */
+export declare type TemplateFallbackRouteDefinition<TSettings = any> = LayoutAndTransitionRouteDefinition & HasTemplate & SupportsSettings<TSettings> & HasTitle;
+
+/**
+ * @beta
+ */
+export declare type TemplateRouteDefinition<TSettings = any> = NavigableRouteDefinition<TSettings> & HasTemplate;
+
+/**
+ * @beta
+ */
+declare interface TitleBuilder {
+    joinTitles(parentTitle: string, childTitle: string): string;
+    buildTitle(rootTitle: string, routeTitles: string[][]): string;
+}
+
+/**
+ * @beta
+ */
+export declare interface Transition {
+    begin(host: HTMLElement, prev: RouteView | null, next: RouteView): Promise<void>;
+    rollback(host: HTMLElement, prev: RouteView | null, next: RouteView): Promise<void>;
+    commit(host: HTMLElement, prev: RouteView | null, next: RouteView): Promise<void>;
+}
+
+/**
+ * @beta
+ */
+export declare const Transition: Readonly<{
+    default: Readonly<Transition>;
+}>;
+
+export { }