import { PageManager, ManageArgs } from './PageManager';
import { Controller } from '../../controller/Controller';
import { ControllerDecorator } from '../../controller/ControllerDecorator';
import { Dispatcher } from '../../event/Dispatcher';
import { Extension } from '../../extension/Extension';
import { AbstractRoute, RouteController, RouteParams, RouteView } from '../../router/AbstractRoute';
import { RouteOptions } from '../../router/Router';
import { RouterEvents } from '../../router/RouterEvents';
import { UnknownParameters } from '../../types';
import { PageHandlerRegistry } from '../handler/PageHandlerRegistry';
import { PageFactory } from '../PageFactory';
import { ManagedPage, PageAction } from '../PageTypes';
import { PageRenderer } from '../renderer/PageRenderer';
import { PageStateManager } from '../state/PageStateManager';
export interface PageManagerDispatcherEvents {
    [RouterEvents.AFTER_LOADING_ASYNC_ROUTE]: {
        route: InstanceType<typeof AbstractRoute>;
    };
    [RouterEvents.BEFORE_LOADING_ASYNC_ROUTE]: {
        route: InstanceType<typeof AbstractRoute>;
    };
}
/**
 * Page manager for controller.
 */
export declare abstract class AbstractPageManager extends PageManager {
    #private;
    /**
     * Snapshot of the previously managed page before it was replaced with
     * a new one
     */
    protected _previousManagedPage: ManagedPage;
    /**
     * Factory used by the page manager to create instances of the
     * controller for the current route, and decorate the controllers and
     * page state managers.
     */
    protected _pageFactory: PageFactory;
    /**
     * Details of the currently managed page.
     */
    protected _managedPage: ManagedPage;
    /**
     * The current renderer of the page.
     */
    protected _pageRenderer: PageRenderer;
    /**
     * The current page state manager.
     */
    protected _pageStateManager: PageStateManager;
    /**
     * A registry that holds a list of pre-manage and post-manage handlers.
     */
    protected _pageHandlerRegistry: PageHandlerRegistry;
    protected _dispatcher: Dispatcher;
    /**
     * Initializes the page manager.
     *
     * @param pageFactory Factory used by the page manager to
     *        create instances of the controller for the current route, and
     *        decorate the controllers and page state managers.
     * @param pageRenderer The current renderer of the page.
     * @param pageStateManager The current page state
     *        manager.
     * @param pageHandlerRegistry Instance of HandlerRegistry that
     *        holds a list of pre-manage and post-manage handlers.
     */
    constructor(pageFactory: PageFactory, pageRenderer: PageRenderer, pageStateManager: PageStateManager, pageHandlerRegistry: PageHandlerRegistry, dispatcher: Dispatcher);
    /**
     * @inheritDoc
     */
    init(): void;
    /**
     * @inheritDoc
     */
    preManage(): Promise<void>;
    /**
     * @inheritDoc
     */
    manage({ route, options, params, action }: ManageArgs): Promise<void | import("../PageTypes").PageData>;
    postManage(): void;
    /**
     * @inheritDoc
     */
    destroy(): Promise<void>;
    protected _constructManagedPageValue(controller: RouteController, view: unknown, route: InstanceType<typeof AbstractRoute>, options: RouteOptions, params: RouteParams, controllerInstance: InstanceType<typeof Controller>, decoratedController: ControllerDecorator, viewInstance: unknown): ManagedPage;
    /**
     * Creates a cloned version of currently managed page and stores it in
     * a helper property.
     * Snapshot is used in manager handlers to easily determine differences
     * between the current and the previous state.
     */
    protected _storeManagedPageSnapshot(): void;
    /**
     * Clear value from managed page.
     */
    protected _getInitialManagedPage(): ManagedPage;
    /**
     * Removes properties we do not want to propagate outside of the page manager
     *
     * @param value The managed page object to strip down
     */
    protected _stripManagedPageValueForPublic(value: ManagedPage): {
        controller: RouteController;
        view: unknown;
        route: AbstractRoute<string | import("../..").RoutePathExpression>;
        options: RouteOptions;
        params: RouteParams;
    };
    /**
     * Set page state manager to extension which has restricted rights to set
     * global state.
     */
    _setRestrictedPageStateManager(extension: Extension, extensionState: UnknownParameters): void;
    /**
     * For defined extension switches to pageStageManager and clears partial state
     * after extension state is loaded.
     */
    _switchToPageStateManagerAfterLoaded(extension: Extension, extensionState: UnknownParameters): void;
    /**
     * Initialize page source so call init method on controller and his
     * extensions.
     */
    protected _initPageSource(): Promise<void>;
    /**
     * Initializes managed instance of controller with the provided parameters.
     */
    protected _initController(): Promise<void>;
    /**
     * Initialize extensions for managed instance of controller with the
     * provided parameters.
     */
    protected _initExtensions(): Promise<void>;
    /**
     * Iterates over extensions of current controller and switches each one to
     * pageStateManager and clears their partial state.
     */
    protected _switchToPageStateManager(): void;
    /**
     * Load page source so call load method on controller and his extensions.
     * Merge loaded state and render it.
     */
    protected _loadPageSource(): Promise<void | import("../PageTypes").PageData>;
    /**
     * Load controller state from managed instance of controller.
     */
    protected _getLoadedControllerState(): Promise<{}>;
    /**
     * Load extensions state from managed instance of controller.
     */
    protected _getLoadedExtensionsState(controllerState?: UnknownParameters): Promise<UnknownParameters>;
    /**
     * Activate page source so call activate method on controller and his
     * extensions.
     */
    protected _activatePageSource(): Promise<void>;
    /**
     * Activate managed instance of controller.
     */
    protected _activateController(): Promise<void>;
    /**
     * Activate extensions for managed instance of controller.
     */
    protected _activateExtensions(): Promise<void>;
    /**
     * Update page source so call update method on controller and his
     * extensions. Merge updated state and render it.
     */
    protected _updatePageSource(): Promise<void | import("../PageTypes").PageData>;
    /**
     * Return updated controller state for current page controller.
     */
    protected _getUpdatedControllerState(): {} | Promise<{}>;
    /**
     * Return updated extensions state for current page controller.
     */
    protected _getUpdatedExtensionsState(controllerState?: UnknownParameters): Promise<UnknownParameters>;
    /**
     * Deactivate page source so call deactivate method on controller and his
     * extensions.
     */
    protected _deactivatePageSource(): Promise<void>;
    /**
     * Deactivate last managed instance of controller only If controller was
     * activated.
     */
    protected _deactivateController(): Promise<void>;
    /**
     * Deactivate extensions for last managed instance of controller only if
     * they were activated.
  
     */
    protected _deactivateExtensions(): Promise<void>;
    /**
     * Destroy page source so call destroy method on controller and his
     * extensions.
     */
    protected _destroyPageSource(): Promise<void>;
    /**
     * Destroy last managed instance of controller.
     */
    protected _destroyController(): Promise<void>;
    /**
     * Destroy extensions for last managed instance of controller.
     *
     * @protected
     * @return {Promise<undefined>}
     */
    protected _destroyExtensions(): Promise<void>;
    /**
     * The method clear state on current rendered component to DOM.
     *
     * @param options The current route options.
     */
    _clearComponentState(options: RouteOptions): void;
    /**
     * Return true if manager has to update last managed controller and view.
     */
    protected _hasOnlyUpdate(controller: RouteController, view: unknown, options: RouteOptions): boolean;
    protected _runPreManageHandlers(actualManagedPage: ManagedPage, action: PageAction): Promise<unknown>;
    protected _runPostManageHandlers(previousManagedPage: ManagedPage, action: PageAction): Promise<unknown>;
    protected getViewController(route: ManagedPage['route']): Promise<{
        controller: RouteController;
        view: RouteView;
    }>;
}
//# sourceMappingURL=AbstractPageManager.d.ts.map