import type { Url } from '@tinkoff/url';
import type { AsyncParallelTapableHookInstance, AsyncTapableHookInstance, SyncTapableHookInstance } from '@tinkoff/hook-runner';
import { TapableHooks } from '@tinkoff/hook-runner';
import { Route, NavigateOptions, UpdateCurrentRouteOptions, Navigation, NavigationGuard, NavigationHook, NavigationSyncHook, HookName, Params, SyncHookName, HistoryOptions, RouterPlugin, BackNavigationType, NavigationRoute } from '../types';
import type { History } from '../history/base';
import type { RouteTree } from '../tree/tree';
export interface Options {
    trailingSlash?: boolean;
    mergeSlashes?: boolean;
    enableViewTransitions?: boolean;
    backNavigationWithinRouteType?: BackNavigationType;
    routes?: Route[];
    onRedirect?: NavigationHook;
    onNotFound?: NavigationHook;
    onBlock?: NavigationHook;
    beforeResolve?: NavigationHook[];
    beforeNavigate?: NavigationHook[];
    afterNavigate?: NavigationHook[];
    beforeUpdateCurrent?: NavigationHook[];
    afterUpdateCurrent?: NavigationHook[];
    guards?: NavigationGuard[];
    onChange?: NavigationSyncHook[];
    defaultRedirectCode?: number;
    hooksFactory?: TapableHooks;
    plugins?: RouterPlugin[];
}
interface InternalOptions {
    history?: boolean;
    redirect?: boolean;
}
export declare abstract class AbstractRouter {
    protected started: boolean;
    protected trailingSlash: boolean;
    protected strictTrailingSlash: boolean;
    protected viewTransitionsEnabled: boolean;
    protected mergeSlashes: boolean;
    protected currentNavigation: Navigation;
    protected lastNavigation: Navigation;
    protected history: History;
    protected tree?: RouteTree;
    readonly guards: AsyncParallelTapableHookInstance<{
        navigation: Navigation;
        allResults: Array<void | NavigateOptions | string | boolean>;
    }>;
    readonly hooks: Map<HookName, AsyncParallelTapableHookInstance<{
        navigation: Navigation;
    }>>;
    readonly syncHooks: Map<SyncHookName, SyncTapableHookInstance<{
        navigation: Navigation;
    }>>;
    readonly internalHooks: {
        'router:add-route': SyncTapableHookInstance<Route, void>;
        'router:resolve-route': SyncTapableHookInstance<Parameters<AbstractRouter['_resolveRoute']>, NavigationRoute | undefined>;
        'router:resolve-url': SyncTapableHookInstance<NavigateOptions, Url>;
        'router:resolve-view-transition': SyncTapableHookInstance<{
            navigation: Navigation;
            from: string;
            to: string;
            previousViewTransition: {
                viewTransition: boolean;
                viewTransitionTypes?: string[];
            };
        }, {
            viewTransition?: boolean;
            viewTransitionTypes?: string[];
        } | null>;
    };
    readonly navigateHook: AsyncTapableHookInstance<{
        navigateOptions: NavigateOptions | string;
    }>;
    readonly updateHook: AsyncTapableHookInstance<{
        updateRouteOptions: UpdateCurrentRouteOptions;
    }>;
    readonly runNavigateHook: AsyncTapableHookInstance<{
        navigation: Navigation;
    }>;
    readonly runUpdateHook: AsyncTapableHookInstance<{
        navigation: Navigation;
    }>;
    readonly redirectHook: AsyncTapableHookInstance<{
        navigation: Navigation;
    }>;
    readonly notfoundHook: AsyncTapableHookInstance<{
        navigation: Navigation;
    }>;
    readonly blockHook: AsyncTapableHookInstance<{
        navigation: Navigation;
    }>;
    protected hooksFactory: TapableHooks;
    protected plugins?: RouterPlugin[];
    private currentUuid;
    private hooksIndex;
    private syncHooksIndex;
    private guardsIndex;
    constructor({ trailingSlash, mergeSlashes, enableViewTransitions, beforeResolve, beforeNavigate, afterNavigate, beforeUpdateCurrent, afterUpdateCurrent, guards, onChange, onRedirect, onNotFound, onBlock, hooksFactory, plugins, }: Options);
    protected onRedirect?: NavigationHook;
    protected onNotFound?: NavigationHook;
    protected onBlock?: NavigationHook;
    start(): Promise<void>;
    getCurrentRoute(): NavigationRoute;
    getCurrentUrl(): Url;
    getCurrentViewTransition(): {
        viewTransition: boolean;
        viewTransitionTypes?: string[];
    };
    getLastRoute(): NavigationRoute;
    getLastUrl(): Url;
    getCurrentNavigation(): Navigation;
    getLastNavigation(): Navigation;
    protected commitNavigation(navigation: Navigation): void;
    updateCurrentRoute(updateRouteOptions: UpdateCurrentRouteOptions): Promise<void>;
    protected internalUpdateCurrentRoute(updateRouteOptions: UpdateCurrentRouteOptions, { history }: InternalOptions): Promise<void>;
    protected runUpdateCurrentRoute(navigation: Navigation): Promise<void>;
    navigate(navigateOptions: NavigateOptions | string): Promise<void>;
    protected internalNavigate(navigateOptions: NavigateOptions, { history, redirect }: InternalOptions): Promise<void>;
    protected runNavigate(navigation: Navigation): Promise<void>;
    protected run(navigation: Navigation): Promise<void>;
    resolve(resolveOptions: NavigateOptions | string, options?: Parameters<AbstractRouter['resolveRoute']>[1]): NavigationRoute;
    back(options?: HistoryOptions): Promise<void>;
    forward(): Promise<void>;
    go(to: number, options?: HistoryOptions): Promise<void>;
    isNavigating(): boolean;
    dehydrate(): Promise<Navigation>;
    rehydrate(navigation: Partial<Navigation>): Promise<void>;
    unsubscribe(): void;
    addRoute(route: Route): void;
    protected redirect(navigation: Navigation, target: NavigateOptions): Promise<void>;
    protected notfound(navigation: Navigation): Promise<void>;
    protected block(navigation: Navigation): Promise<void>;
    cancel(_?: Navigation): Navigation | void;
    protected normalizePathname(pathname?: string): string;
    protected resolveUrl(navigation: NavigateOptions): Url;
    protected resolveRoute(...args: Parameters<AbstractRouter['_resolveRoute']>): NavigationRoute;
    protected runGuards(navigation: Navigation): Promise<void>;
    registerGuard(guard: NavigationGuard): import("@tinkoff/hook-runner/lib/types").UntapCallback;
    protected runSyncHooks(hookName: SyncHookName, navigation: Navigation): void;
    registerSyncHook(hookName: SyncHookName, hook: NavigationSyncHook): import("@tinkoff/hook-runner/lib/types").UntapCallback;
    protected runHooks(hookName: HookName, navigation: Navigation): Promise<void>;
    registerHook(hookName: HookName, hook: NavigationHook): import("@tinkoff/hook-runner/lib/types").UntapCallback;
    private uuid;
    protected _resolveUrl({ url, query, params, preserveQuery, hash }: NavigateOptions): Url;
    protected _addRoute(route: Route): void;
    protected _resolveRoute({ url, params, navigateState }: {
        url?: Url;
        params?: Params;
        navigateState?: any;
    }, { wildcard }?: {
        wildcard?: boolean;
    }): NavigationRoute;
    protected _resolveViewTransition(params: {
        navigation: Navigation;
        from: string;
        to: string;
        previousViewTransition: {
            viewTransition: boolean;
            viewTransitionTypes?: string[];
        };
    }): any;
}
export {};
//# sourceMappingURL=abstract.d.ts.map