import { AbstractRoute, AsyncRouteController, AsyncRouteView, RouteParams } from './AbstractRoute';
import { RouteFactory } from './RouteFactory';
import { MIDDLEWARE_ABORT_ROUTE, Router, RouteOptions, RouterMiddleware, RouteAction, RouteLocals } from './Router';
import { RouterEvents } from './RouterEvents';
import { Settings } from '../boot';
import { IMAError } from '../error/Error';
import { Dispatcher } from '../event/Dispatcher';
import { PageManager } from '../page/manager/PageManager';
import { UnknownParameters } from '../types';
type BeforeHandleRouteEventData = {
    route: InstanceType<typeof AbstractRoute>;
    path: string;
    params?: RouteParams;
    options?: Partial<RouteOptions>;
    action?: RouteAction;
};
type AfterHandleRouteEventData = BeforeHandleRouteEventData & {
    response?: any;
};
export interface RouterDispatcherEvents {
    [RouterEvents.AFTER_HANDLE_ROUTE]: AfterHandleRouteEventData;
    [RouterEvents.BEFORE_HANDLE_ROUTE]: BeforeHandleRouteEventData;
}
/**
 * The basic implementation of the {@link Router} interface, providing the
 * common or default functionality for parts of the API.
 */
export declare abstract class AbstractRouter extends Router {
    #private;
    /**
     * The page manager handling UI rendering, and transitions between
     * pages if at the client side.
     */
    protected _pageManager: PageManager;
    /**
     * Factory for routes.
     */
    protected _factory: RouteFactory;
    /**
     * Dispatcher fires events to app.
     */
    protected _dispatcher: Dispatcher;
    /**
     * The current protocol used to access the application, terminated by a
     * colon (for example `https:`).
     */
    protected _protocol: string;
    /**
     * The application's host.
     */
    protected _host: string;
    /**
     * The URL path pointing to the application's root.
     */
    protected _root: string;
    /**
     * The URL path fragment used as a suffix to the `_root` field
     * that specifies the current language.
     */
    protected _languagePartPath: string;
    /**
     * Storage of all known routes and middlewares. The key are their names.
     */
    protected _routeHandlers: Map<string, InstanceType<typeof AbstractRoute> | RouterMiddleware>;
    /**
     * Middleware ID counter which is used to auto-generate unique middleware
     * names when adding them to routeHandlers map.
     */
    protected _currentMiddlewareId: number;
    protected _currentlyRoutedPath: string;
    protected _middlewareTimeout: number;
    protected _isSPARouted: NonNullable<Settings['$Router']>['isSPARouted'] | undefined;
    /**
     * Initializes the router.
     *
     * @param pageManager The page manager handling UI rendering,
     *        and transitions between pages if at the client side.
     * @param factory Factory for routes.
     * @param dispatcher Dispatcher fires events to app.
     * @example
     *      router.link('article', {articleId: 1});
     * @example
     *      router.redirect('http://www.example.com/web');
     * @example
     *      router.add(
     *        'home',
     *        '/',
     *        ns.app.page.home.Controller,
     *        ns.app.page.home.View,
     *        {
     *          onlyUpdate: false,
     *          autoScroll: true,
     *          documentView: null,
     *          managedRootView: null,
     *          viewAdapter: null
     *        }
     *      );
     */
    constructor(pageManager: PageManager, factory: RouteFactory, dispatcher: Dispatcher, settings: Settings['$Router'] | number);
    /**
     * @inheritDoc
     */
    init(config: {
        $Protocol?: string;
        $Root?: string;
        $LanguagePartPath?: string;
        $Host: string;
    }): void;
    /**
     * @inheritDoc
     */
    add(name: string, pathExpression: string, controller: AsyncRouteController, view: AsyncRouteView, options?: Partial<RouteOptions>): this;
    /**
     * @inheritDoc
     */
    use(middleware: RouterMiddleware): this;
    /**
     * @inheritDoc
     */
    remove(name: string): this;
    /**
     * @inheritDoc
     */
    getRouteHandler(name: string): AbstractRoute<string | import("./DynamicRoute").RoutePathExpression> | RouterMiddleware | undefined;
    /**
     * @inheritDoc
     */
    getPath(): string;
    /**
     * @inheritDoc
     */
    getUrl(): string;
    /**
     * @inheritDoc
     */
    getBaseUrl(): string;
    /**
     * @inheritDoc
     */
    getDomain(): string;
    /**
     * @inheritDoc
     */
    getHost(): string;
    /**
     * @inheritDoc
     */
    getProtocol(): string;
    /**
     * @inheritDoc
     */
    getCurrentRouteInfo(): {
        route: AbstractRoute<string | import("./DynamicRoute").RoutePathExpression>;
        params: RouteParams<{}>;
        path: string;
    };
    /**
     * @inheritDoc
     */
    getRouteHandlers(): Map<string, AbstractRoute<string | import("./DynamicRoute").RoutePathExpression> | RouterMiddleware>;
    /**
     * @inheritDoc
     * @abstract
     */
    listen(): this;
    /**
     * @inheritDoc
     */
    unlisten(): this;
    /**
     * @inheritDoc
     */
    unlistenAll(): this;
    /**
     * @inheritDoc
     */
    redirect(url: string, options?: Partial<RouteOptions>, action?: RouteAction, locals?: RouteLocals): void;
    /**
     * @inheritDoc
     */
    link(routeName: string, params: RouteParams): string;
    /**
     * @inheritDoc
     */
    route(path: string, options?: Partial<RouteOptions>, action?: RouteAction, locals?: RouteLocals): Promise<void | UnknownParameters>;
    /**
     * @inheritDoc
     */
    handleError(params: RouteParams, options?: Partial<RouteOptions>, locals?: RouteLocals): Promise<void | UnknownParameters>;
    /**
     * @inheritDoc
     */
    handleNotFound(params: RouteParams, options?: Partial<RouteOptions>, locals?: RouteLocals): Promise<void | UnknownParameters>;
    /**
     * @inheritDoc
     */
    isClientError(reason: IMAError | Error): boolean;
    /**
     * @inheritDoc
     */
    isRedirection(reason: IMAError | Error): boolean;
    /**
     * Strips the URL path part that points to the application's root (base
     * URL) from the provided path.
     *
     * @protected
     * @param path Relative or absolute URL path.
     * @return URL path relative to the application's base URL.
     */
    _extractRoutePath(path: string): string;
    /**
     * Handles the provided route and parameters by initializing the route's
     * controller and rendering its state via the route's view.
     *
     * The result is then sent to the client if used at the server side, or
     * displayed if used as the client side.
     *
     * @param route The route that should have its
     *        associated controller rendered via the associated view.
     * @param params Parameters extracted from
     *        the URL path and query.
     * @param options The options overrides route options defined in the
     *        `routes.js` configuration file.
     * @param action An action
     *        object describing what triggered this routing.
     * @return A promise that resolves when the
     *         page is rendered and the result is sent to the client, or
     *         displayed if used at the client side.
     */
    _handle(route: InstanceType<typeof AbstractRoute>, params: RouteParams, options?: Partial<RouteOptions>, action?: RouteAction): Promise<void | UnknownParameters>;
    /**
     * Returns the route matching the provided URL path part (the path may
     * contain a query) and all middlewares preceding this route definition.
     *
     * @param path The URL path.
     * @return The route
     *         matching the path and middlewares preceding it or `{}`
     *         (empty object) if no such route exists.
     */
    getRouteHandlersByPath(path: string): {
        route?: InstanceType<typeof AbstractRoute>;
        middlewares: RouterMiddleware[];
    };
    /**
     * Returns middlewares preceding given route name.
     */
    _getMiddlewaresForRoute(routeName: string): RouterMiddleware[];
    /**
     * Returns path that is stored in private property when a `route`
     * method is called.
     */
    _getCurrentlyRoutedPath(): string;
    /**
     * Runs provided middlewares in sequence.
     *
     * @param middlewares Array of middlewares.
     * @param params Router params that can be
     *        mutated by middlewares.
     * @param locals The locals param is used to pass local data
     *        between middlewares.
     * @returns Promise resolving to `MIDDLEWARE_ABORT_ROUTE` if a middleware aborted the
     *          entire routing pipeline, or `void` if all middlewares completed
     *          normally (including early stop via `MIDDLEWARE_STOP_PROPAGATION`).
     */
    _runMiddlewares(middlewares: RouterMiddleware[] | undefined, params: RouteParams, locals: RouteLocals): Promise<typeof MIDDLEWARE_ABORT_ROUTE | void>;
}
export {};
//# sourceMappingURL=AbstractRouter.d.ts.map