import * as StateManager from '../store/state/state-manager';
import * as ActionCreators from '../store/state/actions/action-creators';
import * as RoutingManager from '../router/routing-manager';
import * as StreamObservable from '../observables/stream-observable';
import ActionProcessor from '../actions/processor';
import * as ContextUtils from '../utils/context-utils';
import CaseApis from '../case/apis';
import MashupApis from '../mashup/apis';
declare class BootstrapUtils {
    createC11nEnv: (meta: any) => import("../interpreter/types").CreateC11nEnv;
    getContextUtils: () => typeof ContextUtils;
    getRoutingManager: () => typeof RoutingManager;
    getComponentsRegistry: () => {
        customComponentLazyMap: {
            [key: string]: {
                [key: string]: any;
                component: string;
                scripts?: string[];
                styles?: string[];
            };
        };
        componentMap: {
            [key: string]: {
                [key: string]: any;
                component: string;
                scripts?: string[];
                styles?: string[];
            };
        };
        overrideMap: {
            [key: string]: {
                [key: string]: any;
                component: string;
                scripts?: string[];
                styles?: string[];
            };
        };
        lazyMap: {
            [key: string]: {
                [key: string]: any;
                component: string;
                scripts?: string[];
                styles?: string[];
            };
        };
        register(componentName: string, component: {
            [key: string]: any;
            component: string;
            scripts?: string[];
            styles?: string[];
        }): void;
        registerLazyMap(componentName: string, component: {
            [key: string]: any;
            component: string;
            scripts?: string[];
            styles?: string[];
        }): void;
        registerCustomComponentLazyMap(componentName: string, component: {
            [key: string]: any;
            component: string;
            scripts?: string[];
            styles?: string[];
        }): void;
        getComponent(componentName: string): {
            [key: string]: any;
            component: string;
            scripts?: string[];
            styles?: string[];
        } | undefined;
        getLazyComponent(componentName: string): {
            [key: string]: any;
            component: string;
            scripts?: string[];
            styles?: string[];
        } | undefined;
        getCustomComponent(componentName: string): {
            [key: string]: any;
            component: string;
            scripts?: string[];
            styles?: string[];
        } | undefined;
        mergeComponentsMap(componentsMap?: {
            [key: string]: {
                [key: string]: any;
                component: string;
                scripts?: string[];
                styles?: string[];
            };
        }): void;
        mergeOverrideMap(overrideMap?: {
            [key: string]: {
                [key: string]: any;
                component: string;
                scripts?: string[];
                styles?: string[];
            };
        }): void;
        getOverrideMap(): {
            [key: string]: {
                [key: string]: any;
                component: string;
                scripts?: string[];
                styles?: string[];
            };
        };
        getLazyMap(): {
            [key: string]: {
                [key: string]: any;
                component: string;
                scripts?: string[];
                styles?: string[];
            };
        };
    };
    getStateManager: () => typeof StateManager;
    getActionCreators: () => typeof ActionCreators;
    getStreamObservable: () => typeof StreamObservable;
    getActionProcessor: () => typeof ActionProcessor;
    getActionHandler: () => {
        actionHandlers: {
            [key: string]: Function;
        };
        getHandler(actionName: string | number): Function;
        registerHandler(actionName: string | number, handler: Function): void;
    };
    renderApp: (translatedDXAPIResponse: any, domContainerID: any) => void;
    /** updates store with apiResponse
     * @public
     * @param {*} dxAPIResponse - uiResources response
     * @param {string} containerName - container name
     * @param {boolean} isPortal - is portal
     */
    updateStoreWithUiRoot: (dxAPIResponse: any, containerName: any, isPortal: any) => Promise<void>;
    fetchEndPointResource: (endPoint: any, containerName: any, isPortal: any) => void;
    loadComponent: (componentConfig: any, domContainerID: any, additionalComponents: any) => Promise<void>;
    setStaticServerUrl: (staticUrl: any, appStaticUrl: any, b2sJWT: any) => void;
    loadView: (dxAPIResponse: any, domContainerID: any, additionalComponents?: never[]) => Promise<void>;
    /**
     * This is common method to initialize app shell and it gets invoked from pxBootstrapShell
     * @param {*} appRoutingTable - appRoutingTable
     * @param {*} actionsTargetModel -  actionsTargetModel
     * @param {*} servicesObj - servicesObj
     */
    initAppShell: (appRoutingTable: any, actionsTargetModel: any, servicesObj: any) => void;
    /**
     * This method on the bootstrap is used to initialize just the routing table - this is used in scenarios such as the constellation
     * bridge wherein actions targeting and service objects are not useful
     * @param {*} appRoutingTable - appRoutingTable
     *  @param {*} servicesObj - servicesObj
     */
    initRoutingTable: (appRoutingTable: any, servicesObj: any) => void;
    setAppAlias: (appAlias: any) => void;
    getHomeRestApi: (portalName: any) => string;
    /**
     * Returns the full path to the view endpoint
     * @param {string} viewID - View Name passed in the queryparam
     * @param {string} viewClass - View Name passed in the queryparam
     * @returns {string} Full path to the view endpoint
     */
    getViewRestApi: (viewID: any, viewClass: any) => string;
    /**
     * Renders RootContainer initially
     * @param {*} domContainerID - Container under which view must be loaded
     * @param {*} componentMetaData - componentMetaData of RootContainer
     * @param {*} additionalComponents - Additional components
     * @param {*} [portalTarget] - (optional), DOM element into which view will be loaded and used as cosmos portal target(usually a shadowdom element)
     * @param {*} [styleSheetTarget] - (optional), DOM element into which cosmos styles will be injected
     * @param {boolean} [removeContainer] - check to remove the container
     */
    loadRootComponent: (domContainerID: string, componentMetaData: {
        [key: string]: any;
    }, additionalComponents?: string[], portalTarget?: string, styleSheetTarget?: string, removeContainer?: boolean) => Promise<void>;
    /**
     * Loads the view under the given container after hitting the view endpoint and getting the view response.
     * @param {string}  viewName - View Name passed in the queryparam
     * @param {string}  portalName - Default portal, used for a fallback when the viewName can not be resolved
     * @param {string}  viewClass - View Name passed in the queryparam
     * @param {string}  containerName - container name
     */
    loadViewByName: (viewName: any, portalName: any, viewClass: any, containerName: any) => void;
    loadPortalView: (portalName: any, containerName: any) => void;
    configureForBrowserBookmark: (payload: any) => void;
    checkIfSemanticURL: () => boolean;
    /**
     * onPCoreReady API ensures that PCore is loaded and ready to use. This accepts a callback function,
     * that will be called once the application (PCore) infrastructure has established and is ready to perform its initial render.
     *
     * This API registers a callback that will be called once the application infrastructure has established the store and is ready to perform its initial render.
     *
     * @param {Function} callback callback function
     * @example <caption>Usage of onPCoreReady</caption>
     * Usage:
     * const render = function(){
     *  // logic to render and bootstrap your application.
     * };
     * onPCoreReady usage: onPCoreReady((args) => render(args));
     *
     * the callback function with render is called once the infrastructure is ready.
     */
    onPCoreReady: (callback: any) => void;
    /**
     * onPCoreCleanup API ensures that PCore is properly unmounted. This accepts a callback function,
     * that will be called once the application (PCore) should be unmounted.  This need not be invoked for
     * regular Constellation portal where the React root is the entire page, but is critical for Constellation
     * Web Embeddings.
     *
     * This API registers a callback that will be called when PCore should be unmounted.
     *
     * @param {Function} callback callback function
     * @example <caption>Usage of onPCoreCleanup</caption>
     * Usage:
     * const unmount = function(){
     *  // logic to cleanup application as PCore as Constellation is about to be unmounted
     * };
     * onPCoreCleanup usage: onPCoreCleanup((args) => unmount(args));
     *
     * the callback function with unount is invoked when Constellation should be unmounted.
     */
    onPCoreCleanup: (callback: any) => void;
    setFieldsDefaultConfigs: (config: any) => void;
    setGoogleMapsAPIKey: (googleMapsAPIKey: any) => void;
    setFetchDefaultHeaders: (headersObj: any) => void;
    setFetchAuthInfo: (authInfo: any) => void;
    getCaseApi: () => typeof CaseApis;
    getMashupApi: () => typeof MashupApis;
    enableAppRouting: (enableRouting: any) => void;
    initStore: () => void;
    getBootstrapConfig: (restServerUrl: any, tokenInfo: any) => Promise<any>;
    initCoreContainers: (options?: {}) => {
        props: {
            getPConnect: () => import("../interpreter/c11n-env").C11nEnv;
        };
    };
}
declare const _default: BootstrapUtils;
export default _default;