import Door from './ConfigTree/DoorPlanner/Door';
import { IDivaViewVisualizedNotPlannedElement } from './Set/DivaSetHandler';
import Rendering from './Planner/Rendering/Rendering';
import { DoorPlannerView } from '../interface/DoorPlanner';
import { Vector3 } from '../model/Planner/wcVectors';
import Grid, { ReturnTryFit } from './ConfigTree/Shelfplanner/ShelfPlannerGrid';
import { BasketEvent } from '../interface/Basket/BasketEvent';
import HQRenderScript from './Planner/Rendering/HQRenderScript';
import { ClientEvents, PlannerStepsType } from '../interface/API/ViewConfigDataType';
import { Langs } from '../interface/Configuration';
import { TabGroup } from '../interface/ConfiguratorStructureDataType';
import { BasketData, BBoxType, OrderSetData } from '@crystaldesign/basket-model';
import { StaticRoomDataType } from '../interface/Planner/StaticRoomDataType';
import { AccessoireItemType } from '../interface/Articles/AccessoireItemType';
import { AlternativeRendering } from '../interface/Rendering/AlternativeRendering';
import { SummaryPaletteItemType } from '../interface/Summary/SummaryPaletteItemType';
import { PlannerPaletteViewDataType } from '../interface/PlannerPaletteViewDataType';
import { FreePlacesOnGrids, PlannedPlacesOnGrids, ShelfAccessoriesView } from '../interface/ShelfPlanner/ShelfAccessoiresView';
import { ArticleOptionValueView } from '../interface/OptionTypes/ArticleOptionValueView';
import { Actions, Event, Modal, ProductData, State, UserRole } from '../interface/CoreTypes';
import { ContentItemTeaser } from '../interface/ViewTypes';
import { AdditionalGroupFilter, DockingPoint, ArticleInfoType, BboxInfo2D, InitMode, ItemPaletteType, PlannerMessageType, WebPlannerConfigParams } from '../';
import { PlannerMode, ParamsAddPlannerElement, Nav3DMode, Nav3DParams, PriceFormat, ViewChangedCause, ParamPlanPlannerElementInfo } from '../interface/FunctionTypes';
import DivaSet from './Set/DivaSet';
import DivaPlannerHandler from './Planner/DivaPlannerHandler';
import DivaCatalogData from '../model/Catalog/CatalogData';
import { PlannerType, ReturnTo } from '../interface/webPlannerParams/WebPlannerParamsType';
import { ApiCache } from '../interface/API/ApiCache';
import { NotificationEventType } from '../interface/Rules/NotificationRule';
import { Hybrid3DInfo, Hybrid3DInfo_Camera } from './Planner/Rendering/types';
import { CustomDimensionsType } from '../interface/DivaSetDataType';
import { PlannedArticleViewDataType } from '../interface/Articles/PlannedArticleViewDataType';
import { GeneralPlanningState } from '../model/Planner/PlannerInteractionData';
import PlannerElementData from '../model/Planner/PlannerElementData';
export default class DivaWebPlanner {
    private divaBasketHandler;
    onClickAddToBasket?: (viewHandler?: any, event?: BasketEvent | undefined, force?: boolean, returnTo?: ReturnTo, dontGoToSummary?: boolean, hideLoading?: boolean) => Promise<boolean>;
    private initPlannerView?;
    private initViewApiDependencies;
    private initConfiguratorStructure?;
    private onBasketInitialized?;
    private initConfiguratorMode;
    private updatePlannerMsgContainer?;
    private navigateToConfigStep;
    private updateConfiguratorStructure;
    private navigateToTabGroup?;
    private getCurPlannerViewMode;
    private getInitPlannerViewMode;
    private updatePlanner3DImage;
    private setRotationOrbitCube?;
    private getCanvas2DAsJPG;
    private updateFullscreenRendering;
    private plannerHandler;
    private updateSetImage?;
    private updatePlanner2DGrid;
    private getPlannerRenderingSize;
    private getPlanner3DGridEnabled;
    private updateCatalogPlannerArticles?;
    private updateCatalogPlanner2Dot0Articles?;
    private updateAccessoiresPalette;
    private updatePaletteInfos;
    private updateElementSelectionConfig;
    private updateBBox?;
    private updateElementSelectionPlanner?;
    private updateConfigItems?;
    private updateSummaryItems?;
    private updateStaticRoomListItems?;
    private updateShelfPlannerItems?;
    private updateFreePlacesOnGrids?;
    private updateDoorPlannerItems?;
    private updatePrice?;
    private updateViewButtonsDependigOnConfigStructure;
    private updateViewPlannerElements?;
    private getDoShow3DDimensionLines?;
    getCurrentAlternativRendering?: () => AlternativeRendering[];
    private setWebConifguratorTitle?;
    private plannerConfig;
    actions?: Actions;
    private handler?;
    state?: State;
    private _doLoadHQR?;
    divaNr: string;
    returnTo?: ReturnTo;
    initMode?: InitMode;
    initOpt?: string;
    private sets;
    private divaCatalogs;
    private abTest?;
    private i18n;
    private api;
    private setHQRenderScript?;
    private setCamInfo?;
    constructor(plannerConfig: WebPlannerConfigParams);
    initialize(cache?: ApiCache): Promise<boolean>;
    private initializeSets;
    updatePlannerConfig(plannerConfig: WebPlannerConfigParams): void;
    private getPlannerHandlerFunctions;
    private getInitStateForSet;
    initToExistingPlanning(): boolean;
    private onInitializationError;
    getDivaArticles(visiblePartlistArticlesAlso?: boolean, allPartlistArticlesAlso?: boolean): {
        [basketId: string]: import("./Article/DivaArticle").default;
    } | undefined;
    getFirstDivaArticles(): import("./Article/DivaArticle").default;
    getHiddenOptions(): import("./ConfigTree/DivaConfigTree").default | undefined;
    getPlannerHandler(): DivaPlannerHandler;
    initView(): Promise<void>;
    updateWebConfiguratorTitle(): void;
    private updateConfigStructure;
    private runInitMode;
    addSetToActPlanningByDivaNr(divaNr: string): Promise<void>;
    cleanUpEmptySets(ignoreActSet?: boolean): boolean;
    private deleteSet;
    addSet: (set: DivaSet, isActSet: boolean) => void;
    setActSet: (setId: string, oldTabgroupType?: string) => boolean;
    setActSetCurConfigStepKey(curConfigStepKey: string): Promise<void>;
    updateConfiguratorStructureOfActSet(): void;
    getOrderSetsByDivaNr(divaNr?: string): OrderSetData[];
    /**
     * This function is called when the RoomList is loaded from the 3D host. Now we have to update the TabGroup View - if the configurator is currently in the Roomlist state
     * @param succ
     */
    onRoomListLoaded: () => void;
    /**
     * This function is called when the planner Rendering should be updated
     * @param rendering The new rendering that should be loaded into the view
     */
    updatePlannerRendering: (rendering: Rendering, onlyUpdateState?: boolean) => void;
    /**
     * This function is called when the planner Rendering should be updated
     * @param rendering The new rendering that should be loaded into the view
     */
    updatePlannerHqRenderScript: (hqRenderscript: HQRenderScript) => void;
    registerSetHQRenderScript(setHQRenderScript: (hqRenderScript: string) => void): void;
    registerSetCamInfo(setCamInfo: (camInfo: any) => void): void;
    /**
     * This function is called when the planner view should be updated
     * @param callingFrom This parameter is used for debug Reasons. It can have information from where in the code the updatePlannerView is called
     * @param viewpoint This parameter is used to send the viewpoint information from the rtv to unity
     */
    updatePlannerView(callingFrom: ViewChangedCause, onDoConfigureValues?: {
        [optCodex: string]: string;
    }, hybridInfo?: Hybrid3DInfo): void;
    /**
     * This function forces loading the 3D image of a planning and the 2D planner.
     * @param renderSavingMode  Specifies if the rendering should be saved or not. If Stream is used, the rendering is only streamed from the 3DRenderer to the client and not saved.
     *                          If TEMP is used the rendered image is saved temporarily on the MediaService - DEPRECTED
     *                          If PERMANENT the rendering is saved permanent in the MediaService
     * @param doLoadAllAltnerateRenderings  Force load all alternate renderings - eg entering summary page load rendering with doors and without doors
     */
    forceUpdatePlannerView(renderSavingMode: 'STREAM' | 'PERMANENT', doLoadAllAlternateRenderings: boolean): void;
    private update2DGrid;
    getAlternateRenderingsForSummary(): AlternativeRendering[] | undefined;
    getPlanning2DAsJpg: () => any;
    /***********************************Functions in Logik called From View *************************************/
    onElementSelectionChanged: (setId: string, elementId: number, oldTabgroupType?: string) => boolean;
    /**
     * This Function ist call from the View when all Planner Article are Requested for listing
     */
    loadCatalogPlannerArticles: (paletteeId: number, isUpdate: boolean, type: "PLANNERSWITCH" | "ART" | "ART_2", dockFilter: string, actStepName: string, stepKey: string, selectedArticle?: string) => void;
    loadCatalogPlannerArticles2Dot0: (isUpdate: boolean, onlySelectionChanged?: boolean, dp?: DockingPoint) => void;
    /**
     * this fuction loads the accessoires of a specific article -> could be more than one article in the future
     * @param targetArticles the article of which we load the accessoires
     */
    loadAccessoiresOfArticles: (targetArticles: string[]) => void;
    /**
     * this function is called when all Items of a ConfigStep are requested
     * @param configStepKey unique indentifier for configStep
     */
    loadConfigItemsOfOptions: (configStepKey: string, paletteId: number, isUpdate: boolean, visible: boolean) => Promise<void>;
    /**
     * this function laods the summary Items
     */
    loadSummaryItems: () => Promise<void>;
    loadStaticRoomList: (dontUpdateView?: boolean) => void;
    loadShelfPlannerItems: (paletteId: number, configStepKey: string, from: string) => void;
    loadDoorPlannerItems: (configStepKey: string) => void;
    /**
     * this function destroys some instances of the webPlanner bevor a new one gets created. Goal of this function is that the old webPlanner object doesnt make any trouble.
     */
    destroyWebPlanner(): ApiCache;
    /**
     * This function is called when switching from one planning to another. All Planner handler are destroyed.
     * @param doDestroy3DHostConnection      The whole renderCache is cleared and the connection to the 3D render host is cleared
     */
    destroyPlannerHandler: (doDestroy3DHostConnection: boolean) => void;
    /**
     * this Function is called when new Planner Article is Loaded
     * @param elementCodex unique Codex to identify the article
     * @param parentElement ElementID of the parent element used for docking
     */
    addPlannerElement: (elementCodex: string, initParams: ParamsAddPlannerElement, dontUpdateView?: boolean) => Promise<"AccessoireNotVisualized" | "AccessorieNoFreeSpace" | "ElementAdded">;
    /**
     * this function implements a switch logic of 2 elements also called "Tauschfunktion"
     * @param setId actSet
     * @param elementId Id of the element that gets deleted
     * @param articleCodex articleCodex of the new Element
     */
    switchPlannerElement: (setId: string, elementId: number, articleCodex: string, initParams: ParamsAddPlannerElement) => Promise<void>;
    deletePlannerElement(setId: string, elementId: number, denyElementSelectionClear?: boolean): Promise<void>;
    /**
     *  This function moves an element from its origin to the desired index
     *  current implementation is only for the new boxplanner
     *
     */
    movePlannerElement(setId: string, elementId: number, curConfigKey: string, absoluteIndex: {
        x: number;
        y: number;
    }): Promise<void>;
    /**
     * This function is called when a element should be copied.
     * @param  setId the setId the element to copy belongs too
     * @param  elementId  The elementId that should be copied
     * @param   copyInfo  This objects hold information that is needed for copying. For example when copying an element in the box planner, the information in which direction it should be copied is important.
     */
    copyPlannerElement(setId: string, elementId: number, curConfigKey: string, copyInfo?: ParamPlanPlannerElementInfo): Promise<string | undefined>;
    addAccessorieOnShelfPlanner: (paletteId: number, gridIndex: number, cellIndex: number, parentBasketId: string, configStepKey: string, partlistCodexToInit?: string) => Promise<false | ReturnTryFit>;
    moveShelfItem: (paletteId: number, grid: Grid, initialIndex: number, finalIndex: number, configStepKey: string) => Promise<void>;
    moveDoors: (movedDoor: Door, targetDoor: Door) => void;
    deleteAccessorieOnShelfPlanner: (paletteId: number, gridIndex: number, cellIndex: number, parentBasketId: string, configStepKey: string) => Promise<void>;
    /**
     * This function is called every time the transformation of an Element is changed
     * @param plannerElementID
     * @param deltaMove
     * @param deltaAngleDeg
     * @param transState
     */
    updatePlannerTrans: (setId: string, plannerElementID: number, deltaMove: Vector3, deltaAngleDeg: number, rotCorrection: number, transState: "START" | "UPDATE" | "END", autoDockingDistance: number) => Promise<void>;
    /**
     * This function returns true if all Plannings are complete. Otherwise it returns false (Open AVL and AVR).
     */
    getPlanningIsComplete(forceCheck?: boolean): boolean;
    getPlanningIsEmpty(): boolean;
    /**
     * This function is called when the user interacts with the navigation in the 3D Image view.
     * The mode indicates what should be done in the navigation like zooming or swiping.
     * @param avoidUpdateRendering    If this parameter is set to true, the function only updates the viewPointHandler - no rendering is made.
     */
    handle3DVisualizationChanged: (mode: Nav3DMode, params: Nav3DParams, avoidUpdateRendering?: boolean) => void;
    updateAccessoireQuantity: (accessoireItem: AccessoireItemType, relatedToBasketId: string, newQuantity: number, forceConfigSingle?: boolean) => Promise<void>;
    deleteAccessoire: (articleCodex: string, parentBasketId: string) => Promise<boolean | {
        success: boolean;
        selectElementId: number | undefined;
        setId: string;
        oldTransform?: import("../interface/FunctionTypes").PlannerTransform;
    }>;
    selectShelfAccArticle(gridGroup: string, targetArticles: string[], articleCodex?: string): void;
    getFreePlacesOnGrids(gridGroup?: string, from?: string): Promise<{
        freeShelfGrids: FreePlacesOnGrids[] | undefined;
        plannedShelfGrids: PlannedPlacesOnGrids[];
    }>;
    getFreeToMovePlacesOnGrids(gridName: string, basketId: string): FreePlacesOnGrids[] | undefined;
    moveShelfItemToGrid(accessoireBasketId: string, parentBasketId: string, gridName: string, cellIndex: number): Promise<void>;
    getPlannerInteractionInformation(): import("../model/Planner/PlannerInteractionData").PlannerInteractionInformation | undefined;
    getGeneralPlanningState(setId: string, selectedElementId?: number): GeneralPlanningState | undefined;
    loadPaletteInfos: (configStepKey?: string, activeArticles?: string[], targetArticles?: string[]) => void;
    getBasketIdsOfElementIdLogic: (elementId: number[]) => string[];
    /**
     * This function is called when the the checkBox to ConfigSingle is triggered
     * @param doConfigSingle new ConfigSingle value
     * @param configStepKey act ConfigStep
     */
    configSingleIsChanged: (doConfigSingle: boolean, configStepKey?: string, groupedOptions?: string[], groupedArticles?: string[], optionCodex?: string, tabGroupKey?: string) => Promise<string | undefined>;
    resetArticle(basketId: string): Promise<void>;
    /**
     *  this function is called when the an ConfigItem is clicked
     *  the configuration of targetArticles gets updated
     *
     * @param myValues a dictionary with the key of the OptionCodex and the value of the OptionValueCodex
     * @param targetArticles array if BasketIds
     * @param freeText freeText is null when specificly set to null. When nopt set at all its undefined
     *
     */
    doConfigure: (myValues: {
        [optCodex: string]: string;
    }, targetArticles: string[], dontUpdatePlannerView?: boolean, dontCallEvents?: boolean, eventKey?: string) => Promise<void>;
    fillBaksetforOnWebPlanerConfigChange: (myValues?: {
        [opt: string]: string;
    }, isInit?: boolean, eventKey?: string) => Promise<{
        changedValues: {
            [optionCodex: string]: import("../interface/classifications/changedValues").LiveClassifiaction[];
        };
        variantValues: {
            [codex: string]: string;
        };
        isInit: boolean | undefined;
        sendToSap: import("../interface/classifications/changedValues").SendToSAP[];
        eventKey: string | undefined;
        SessionGUID?: string;
        BasketVersion?: string;
        SendIWOBasket: boolean;
        MatchingProductId?: string;
        MatchingProductRetailerArticleNr?: string;
        RetailArticleNr?: string;
        ProductSetName?: string;
        ReportConfigIdentifier?: string;
        OrganizationId: string;
        InheritedOrganizations: string[];
        OrganizationId_displayText?: string;
        Client?: import("@crystaldesign/basket-model").ClientData;
        ClientLanguage?: "DE" | "IT" | "FR" | "EN";
        ClientRemark?: string;
        ClientGUID?: string;
        catalogStatus?: "LISTED" | "NOTLISTED" | "ARCHIVED";
        catalogSearch?: string[];
        ApplicationEnvironment?: "SELLER" | "WEB" | "TEST" | "WYSIWYG";
        DocumentVersion: number;
        Status: import("@crystaldesign/basket-model").BasketStatus;
        StatusKey: "USER_CONFIGURATION" | "BASE_CONFIGURATION";
        ApplicationSource: "WEB" | "SELLER";
        DivaNr: string;
        OrigProductId?: string;
        OrigDivaNr?: string;
        OrigCatalogCodex?: string;
        OrigArticleCodexes?: string[];
        RetailerName: string;
        RetailerInfo: string;
        RetailerNr: string;
        RetailerGUID: string;
        RetailerOrderNum: string;
        RetailerOfferNum: string;
        Username: string;
        UserGUID: string;
        UserLanguage: "DE" | "IT" | "FR" | "EN";
        LocatedStore?: string;
        Salesperson?: string;
        SalespersonID?: string;
        SalespersonOverwrite?: string;
        SalespersonEmail?: string;
        SalespersonPhone?: string;
        SalespersonNr?: string;
        SetName?: string;
        SetName_locales?: {
            [lang: string]: string;
        };
        SetPlannerInfos?: import("@crystaldesign/basket-model").SetPlannerInfos;
        OrderSets: OrderSetData[];
        SAPOrderLines: import("@crystaldesign/basket-model").SAPOrderLineData[];
        PrintOptions: import("@crystaldesign/basket-model").PrintOptionsData;
        PrintLogo: string;
        PrintRetailLogo: string;
        Gdpr: boolean;
        Updated?: number;
        BestPriceLogicActive?: boolean;
        PriceFormat?: import("@crystaldesign/diva-utils").PriceFormat;
        _discounts: import("@crystaldesign/basket-model").Discount[];
        AdditionalPrices: import("@crystaldesign/basket-model").AdditionalPrice[];
        OrderStatus?: "SEND";
        OriginBaseUrl?: string;
        PDFDocumentURL?: string;
        ReturnTo?: string;
        pdfs?: string;
        HQRendering?: boolean;
        ConverterStatus3D?: string;
        ConverterFormat3D: string[];
        RenderBatch?: string;
        RenderType?: string;
        DocumentOrder?: string;
        RenderPipeline?: string;
        Viewpoint?: string;
        ImageFileFormat?: string;
        ResolutionMax?: string;
        ResolutionUnity?: string;
        Diva3DProject?: string;
        VariantDescription?: string;
        CustomerJourneyId?: string;
    } | undefined>;
    defineArticlesOnOptions(basketIdsOnOptions: {
        [basketId: string]: string[];
    } | 'defineAll'): void;
    checkIfAllOptionsAreDefined(): true | {
        articles: string[];
        options: {
            title: string;
            configStepKey: string;
        }[];
    };
    changeOnFavorites(opt: string, opvs: string[], targetArticles: string[], remove: boolean): void;
    setDifferentOptions(options: string[]): void;
    checkMatchingProducts(from: string): Promise<void>;
    /**
     * Updated the Price in the View.
     * Should always be called after something was changed!
     */
    updatePriceInView(): void;
    /**
     * this functions check if a specific event is taken care of by our client or if we have to do something. For example opening the Fullscreen 3D-Image window
     * @param event to identify which event
     */
    eventIsManagedByClient(event: ClientEvents): boolean;
    showModal(data: Modal): void;
    logGA(action: string): void;
    /**
     * this function calls genericly any event and passes specific params
     * @param event to identify which event
     * @param param parameters to pass over the event
     */
    callEvent(event: 'onWebPlanerHelp' | 'onWebPlanerClose' | 'onWebPlanerZoomClick' | 'onFullscreenClose', param?: any): void;
    saveToBasketWrapper(event?: BasketEvent, repairOnly?: boolean, returnToParam?: ReturnTo, hideLoading?: boolean): Promise<'saved' | 'canceled' | ProductData>;
    private saveToBasket;
    checkNotificationRules(targetArticles: string[], visitedOptions: {
        [basketId: string]: string[];
    }, event: NotificationEventType): any[] | undefined;
    generateAiImageWithReferenceImages(data: {
        promptId: string;
        referenceImages: string[];
        additionalPrompt?: string;
        variables?: Record<string, number>;
        divaSession?: string;
        configuratorSessionId?: string;
        catalogCodex?: string;
        organizations?: {
            id: string;
            name?: string;
        }[];
    }, leadKey?: string): Promise<string | import("../interface/API/AiImageResult").AiImageResult>;
    getUsageLimits(): Promise<import("../").UsageLimits>;
    getAiRoomRenderings(): Promise<any[]>;
    createLeadKey(email: string): Promise<{
        key: string;
        expiresAt: Date;
        totalRenderings: number;
        wasExisting?: boolean;
        remainingRenderings?: number;
        message: string;
    }>;
    showAiRoomRenderingInSummary(): boolean | undefined;
    clearAllAiImagesAsJpg(): void;
    setAiImageAsJpg(promptId: string, base64: string): void;
    removeAiImageAsJpg(promptId: string): void;
    checkBannerRules(visitedOptions: {
        [basketId: string]: string[];
    }, event: NotificationEventType): import("../").BannerRule | undefined;
    /**
     * This function returns true if the Planner Mode should be visible and the planner Step should be shown.
     * The planner step is not shown if:
     * - There is no viewer Option set for the Planner
     * - The box Planner is loaded
     */
    getCurPlannerType(): PlannerType;
    getPosNr: (basketId: string) => number;
    getReturnTo: (event?: BasketEvent) => ReturnTo;
    getCurCatalogCodex(): string | undefined;
    getCurCatalogName(): string | undefined;
    getCurAccountName(): string | undefined;
    getCurSupplierGuid(): string | undefined;
    getCurSetPrice(): number;
    getCurImageMode(): "2D" | "3D";
    getViewConfig(): import("../").ViewConfigData | undefined;
    getEmailConfig(): import("../interface/Configuration").EmailConfigType | undefined;
    getAllConfig(): import("../").Configuration | undefined;
    getTemplateConfig(): import("../").TemplateConfigType | undefined;
    showDivaNr(): boolean | undefined;
    doAllowSetPlanner(): boolean;
    doShow3DDimensionLines(): boolean | undefined;
    doShowMainDimensions(): boolean | undefined;
    defaultDimensionsActive(): boolean | undefined;
    autoOpenContentItem(): boolean | string[] | undefined;
    hidePlannerUiIcons(): boolean | undefined;
    getPlanner2Dot0Active(): boolean | undefined;
    doShowPlannerReplaceMode(): boolean | undefined;
    doPlannerReplaceAutoSwitch(): boolean | undefined;
    getHidePlanner(): boolean;
    getFilterForCheckoutButtons(): string[];
    getAllowRTV(): boolean | undefined;
    getForceRTV(): boolean;
    getPricePreview(): "fromBasePrice" | "fromCurrentPrice" | "fromCurrentPriceHideCurrent" | "off" | undefined;
    hide2DPlanner(): boolean | undefined;
    getAllowQRCodeAR(): boolean;
    getEnableUnityRtvKombi(): boolean;
    getShelfPlannerRTV(): boolean | undefined;
    getBasketData(): BasketData;
    getStartProductId(): string | undefined;
    getBasketDataWithEkText(): Promise<BasketData>;
    getCatalogData(): DivaCatalogData | undefined;
    set ReturnTo(val: ReturnTo | undefined);
    get ReturnTo(): ReturnTo | undefined;
    addToBasket(actBasket: BasketData, event?: BasketEvent): Promise<any>;
    openPDFpostAsEvent(mongoDBId: string): boolean;
    clearCache(): void;
    getCurrentBasket(event?: BasketEvent | undefined, force?: boolean, returnTo?: ReturnTo, dontGoToSummary?: boolean, hideLoading?: boolean): Promise<boolean | 'BASKET_ALREADY_SAVED'>;
    /*********************************END Functions in Logik called From View END *************************************/
    /*********************************** Register Funictions from Logik to View ***************************************/
    registerInitPlannerView(initPlannerView: () => Promise<void>): void;
    registerInitApiDependencies(initApiDependencies: () => void): void;
    registerUpdatePlannerMsgContainer(updatePlannerMsgContainer: (codex: PlannerMessageType, doShowPlannerMsg: boolean, type: 'WARNING' | 'INFO', content: string, autoHide: boolean, timeoutDuration?: number) => void): void;
    registerInitConfiguratorMode(initConfiguratorMode: (plannerMode: PlannerMode) => void): void;
    registerUpdateFullScreenRendering(updateFullscreenRendering: (rendering: Rendering) => void): void;
    registerUpdateSetImage(updateSetImage: (url: string) => void): void;
    registerGetPlannerRenderingSize(getPlannerRenderingSize: () => any): void;
    registerGetPlanner3DGridEnabled(getPlanner3DGridEnabled: () => any): void;
    registerGetDoShow3DDimensionLines(getDoShow3DDimensionLines: () => boolean): void;
    registerGetCurrentAlternativRendering(getCurrentAlternativRendering: () => AlternativeRendering[]): void;
    registerUpdatePlanner3DImage(updatePlanner3DImage: (rendering: Rendering) => void): void;
    registerSetRotationOrbitCube(setRotationOrbitCube: (forceOrbitTo: boolean, rotHori: number, rotVert: number) => void): void;
    registerGetCanvas2DAsJPG(getCanvas2DAsJPG: () => string): void;
    registerUpdatePlanner2DGrid(updatePlanner2DGrid: (boundingBox: BboxInfo2D) => void): void;
    registerGetCurPlannerViewMode(getCurPlannerViewMode: () => PlannerMode): void;
    registerGetInitPlannerViewMode(getInitPlannerViewMode: () => PlannerMode): void;
    registerNavigateToTabGroup(navigateToTabGroup: (type: string, autoNavIfNotFound?: boolean, dontNavigate?: boolean) => boolean): void;
    registerNavigateToConfigStep(navigateToConfigStep: (configstep: string, dontScroll?: boolean, visitRest?: boolean) => void): void;
    registerInitConfiguratorStructure(initConfiguratorStructure: (configuratorStructure: Map<string, TabGroup>) => void): void;
    registerOnBasketInitialized(onBasketInitialized: (favoriteAiRoomData?: {
        favoriteAiRoomKeys: string[];
        setImages: any[];
    }) => void): void;
    registerUpdateConfiguratorStructure(updateConfiguratorStructure: (data: Map<string, TabGroup>, dontUpdateView?: boolean) => void): void;
    registerSetWebConifguratorTitle(setWebConifguratorTitle: (setName?: string) => void): void;
    registerUpdateCatalogPlannerArticles(updateCatalogPlannerArticles: (plannerItems: PlannerPaletteViewDataType, paletteId: number, isUpdate: boolean, type: ItemPaletteType, dockFilter: string, actStepName: string, stepKey: string) => void): void;
    registerUpdateCatalogPlanner2Dot0Articles(updateCatalogPlanner2Dot0Articles: (catalogPlannerArticles: PlannedArticleViewDataType[], isUpdate: boolean, onlySelectionChanged?: boolean, dp?: DockingPoint) => void): void;
    registerUpdateAccessoiresPalette(updateAccessoiresPalette: (accessoires: AccessoireItemType[], accType: 'ACC' | 'ACC_CONFIG') => void): void;
    registerUpdatePaletteInfos(updatePaletteInfos: (articleInfos: {
        [posNr: number]: ArticleInfoType;
    }, doShowConfigSingle: boolean, isConfigSingle: boolean, bbox: BBoxType) => void): void;
    registerUpdateBBox(updateBBox: (bbox: BBoxType) => void): void;
    registerUpdateElementSelectionConfig(updateElementSelectionConfig: (articleInfos: {
        [posNr: number]: ArticleInfoType;
    }, allSelectable?: boolean) => void): void;
    registerUpdateElementSelectionPlanner(updateElementSelectionPlanner: (selectedElementSetIds: string[], selectedElementIds: number[], setOthersSelectable: boolean) => void, somethingChanged?: boolean): void;
    registerUpdatePlannerElements(updatePlannerElements: (elements: Map<string, PlannerElementData[]>, visualiedNotPlannedElements: Map<string, IDivaViewVisualizedNotPlannedElement[]>, setId?: string, elementId?: number, notEffects?: boolean) => void): void;
    registerUpdateConfigItems(updateConfigItems: (configStepKey: string, configItems: ArticleOptionValueView[], selectedItem: ArticleOptionValueView[], actStepName: string, paletteType: ItemPaletteType, filterType: string, paletteId: number, isupdate: boolean, visible: boolean, stepInfo: string | undefined, isRenderedInAccessorieStep: boolean, isRenderedNotInSettingPalette: boolean, optionCodex: string, notTotallyMatichingOPVs?: boolean, isMultiselect?: boolean, groupsDefaultClosed?: boolean, contentItemId?: string, conceptFilter?: AdditionalGroupFilter[], contentItemTeaser?: ContentItemTeaser, description?: string) => void): void;
    registerUpdateSummaryItems(updateSummaryItems: (ret: SummaryPaletteItemType[], articlePriceFormat?: PriceFormat, stepInfo?: string) => void): void;
    registerUpdateStaticRoomListItems(updateStaticRoomListItems: (roomListItems: StaticRoomDataType[], dontUpdateView?: boolean) => void): void;
    registerUpdateShelfPlannerItems(updateShelfPlannerItems: (paletteId: number, accessoires: ShelfAccessoriesView[], grids: Grid[], configStepKey: string, from: string) => void): void;
    registerUpdateShelfPlannerGrids(updateFreePlacesOnGrids: (data: {
        freeShelfGrids: FreePlacesOnGrids[] | undefined;
        plannedShelfGrids: PlannedPlacesOnGrids[];
    }) => void): void;
    registerUpdateDoorPlannerItems(updateDoorPlannerItems: (items: DoorPlannerView[], configStepKey: string) => void): void;
    registerUpdatePrice(updatePrice: (newTotalPrice: number, newCurSetPrice: number, bruttoPrice?: number, articlePriceFormat?: PriceFormat, customDimensions?: Promise<CustomDimensionsType[]>) => void): void;
    registerUpdateViewButtonsDependigOnConfigStructure(updateViewButtonsDependigOnConfigStructure: () => void): void;
    registerOnClickAddToBasket(onClickAddToBasket: (viewHandler?: any, event?: BasketEvent | undefined, force?: boolean, returnTo?: ReturnTo, dontGoToSummary?: boolean) => Promise<boolean>): void;
    /***********************************Outside events the webPlanner subscribes to ******************************************/
    private subscribeToWebPlannerEvents;
    private unsubscribeFromWebPlannerEvents;
    addToBasketEventFunction: (e: Event) => void;
    initApiForLogicOnly(organization: any, lang: Langs, getSessionGuid: (u: UserRole) => Promise<string>, handler?: any, applicationEnvironment?: 'SELLER' | 'WEB' | 'WYSIWYG', apiKey?: string, jwt?: string): Promise<void>;
    setI18n(i18n: any): void;
    loadBasket(): Promise<any>;
    getBasket(): BasketData;
    initBasket(init3D?: boolean, ignoreFavorites?: boolean): Promise<BasketData>;
    getFavoriteAiRoomKeysFromSet(): {
        favoriteAiRoomKeys: string[];
        setImages: any[];
    } | undefined;
    favoritesDefined(): boolean;
    getVariantValues(basketIds?: string[]): {
        OPT: string;
        OPV: string;
    }[];
    getValidVariantsLength(): Promise<number>;
    handleFavorites(mode: 'SAVE' | 'CALC' | 'REPAIR'): Promise<any>;
    getCatalogCodexesOfOrderSets(): string[];
    initSapOrderLinesFromBasket(divaNr?: string, init3D?: boolean, onlyLoadOldBakset?: boolean): Promise<{
        oldBasket: BasketData;
        cache: {};
        basket?: undefined;
    } | {
        basket: BasketData;
        oldBasket: BasketData;
        cache: ApiCache;
    }>;
    setJsonDataCache(cache: ApiCache): void;
    get userIsLoggedIn(): boolean | undefined;
    actSet(): DivaSet | undefined;
    get setsAsArray(): DivaSet[];
    getPlannerType(): PlannerStepsType | undefined;
    /**
     * This function returns the planner mode.
     */
    getPlannerMode(): PlannerMode;
    openARObserverConnection(handleNoHqrs: () => void): Promise<string>;
    updateCameraInformation(cam: Hybrid3DInfo_Camera): void;
    get doLoadHQR(): boolean;
    set doLoadHQR(loadhqr: boolean);
    private plannerChangeLog;
    private configuratorChangeLog;
    private clearRegisteredFunctions;
}
//# sourceMappingURL=DivaWebPlanner.d.ts.map