import Rendering from './Rendering';
import { Nav3DMode, Nav3DParams } from '../../../interface/FunctionTypes';
import { ApiSettignsParams, ApiSettingsRetunParam, CallbackFunctionsParams, HandleReceiveRendering, Hybrid3DInfo_Camera, OnConnectionInitParams, Request3DParameter } from './types';
import HQRenderScript from './HQRenderScript';
import { Project3dType } from '../../../interface/Planner/Project3DTypes';
export default class PlannerHandler3D {
    private renderCache;
    private hqRenderScriptCache;
    private waitForRenderings;
    private waitForHQRenderScript;
    private lastFramePlanningHash;
    private lastRequestedRenderHash;
    private divaNr;
    private onlyRunLogic;
    private currRendering;
    private lastSavedRendering;
    private lastSavedHQRenderScript;
    private lastSavedAlternateRenderings;
    private connectionHandler;
    private viewPointHandler;
    private getOrigConfiguration;
    private updatePlannerRenderingInView;
    private updatePlannerHqRenderScriptInView;
    private updatePlannerCamInfoInView;
    private liveArSocket?;
    private liveArClientsConnected;
    private liveArViewerUrl?;
    private setRotationOfOrbitCube;
    private onRoomListLoaded;
    private handleNoRenderClientFound;
    private renderSettings;
    private todoAfterLogin;
    private currentCamera?;
    private jwt?;
    private latestHybridInfo?;
    constructor(diva3DUserID: string, deviceID: string, divaSessionID: string, applicationName: string, _noRenderClientFound: any, //This can contain a list of rooms that have to be downloaded,
    onlyRunLogic: boolean);
    setJwt(jwt?: string): void;
    /**
     * This function handels the initialization of the viewpoints of a whiteroom
     * @param standardWhiteRoom
     */
    initializeViewPoint(standardWhiteRoom: string): Promise<void>;
    /**
     * This function is called to load the viewPoint lists associated to a list of room Indices. Contains an array of all static rooms
     * @param staticRoomList
     * @param catalogMainCategory   Die Warengruppe des Catalogs mit diesen Räumen
     */
    initializeStaticRoomList(staticRoomList: string[], catalogMainCategory?: string): Promise<void>;
    /**
     * This function sets all the callback methods that are used to communicate with the view
     * @param params
     */
    initializeCallbackFunctions(params: CallbackFunctionsParams): void;
    initializeAPISettings(params: ApiSettignsParams): ApiSettingsRetunParam;
    initializeConnection(): Promise<void>;
    joinDivaNr(divaNr: string): void;
    onConnectionInitialized(params: OnConnectionInitParams): Promise<void>;
    onConnectedToDivaNr(status: 'SUCCESSFULL' | 'ERROR'): void;
    /**
     * This function is called from the connectionHandler when something happens during requesting rendering.
     * Eg. there is no free renderClient
     * @param info
     */
    onErrorRequestingRendering: (hash: string, size: string, option: string) => void;
    onReceivedAdditionalRenderInfo(hash: string, renderInfo: string): void;
    onReceiveHQRenderScript(planningHash: string, hqRenderScriptString: string): void;
    getWaitForRendering: (hash: string) => Rendering | undefined;
    getWaitForHqRenderScript: (hash: string) => HQRenderScript | undefined;
    getRenderingIsCached: (hash: string) => boolean;
    getRenderingFromCache: (hash: string) => Rendering | undefined;
    getHqRenderScriptIsCached: (hash: string) => boolean;
    getHqRenderScriptFromCache: (hash: string) => HQRenderScript | undefined;
    /**
     * This function is called when a rendering is sent over the socketIO of the MediaService
     *
     * @param divaNr
     * @param hash
     * @param buffer
     */
    handleReceiveRendering(params: HandleReceiveRendering): void;
    /**
     * This function is called when a new rendering has to be sent to the frontend for visualization.
     * This function is called in the DivaWebPlanner and sent do the view
     * @param rendering
     */
    private updatePlannerRendering;
    /**
     * This function is called, when a rendering is finished downloading.
     * This contains the additional RenderInfo Json string, the rendering itself and the layermask (if needed)
     * @param hash
     * @param rendering
     */
    private checkRenderingReady;
    /**
     * This function returns true if an image is still rendered. Sometimes it can happen, that an image gets lost. In This case this function deletes it from the images to wait.
     */
    private checkWaitForImage;
    private checkWaitForHQRenderScript;
    /**
     * This function computes the renderWidth and renderHeight that must be requested. This depends if a background img is used, or if the images are loaded from the cache.
     * @param containerWidth
     * @param containerHeight
     */
    private adjustRenderSize;
    /**
     * Returns the rendering that is currently displayed on the screen
     */
    getCurrRendering(): Rendering | undefined;
    private delay;
    /**
     * This function returns the last rendering that was saved. Everytime the application enters the summary page - a Rendering is saved temporarily and returns an url.
     */
    getLastSavedRendering(): Promise<Rendering | undefined>;
    hasLastSavedRendering(): boolean;
    /**
     * This function returns the last alternate renderings that were saved. Everytime the application enters the summary page - a Rendering is saved temporarily and returns an url.
     */
    getLastSavedAlternateRenderings(): Promise<Rendering[] | undefined>;
    /**
     * This function returns the structure of the planningJson Data. This planningJson is used by the 3D renderer to parse the current scene.
     */
    initPlannerData(useSetPlanner: boolean): Project3dType;
    private setRoomInfoInPlanningData;
    /**
     * This function is used to get a new rendering from the 3D Host
     * @param divaNr    The current DivaNr
     * @param planningData  The construction information of the current planning
     * @param width         The width of the requested image
     * @param height        The height of the requested image
     * @param isFullscreenRendering     Is the image a fullscreen Rendering
     * @param planner3DGridEnabled      When the planner3D Grid is enabled - request a rendering and a layermask
     * @param mediaServiceSaveMode    Specifies if the rendering should only streamed from the renderer to the client - or if it should be saved temporarily by the media service.
     * @param catalogCodex              The CatalogCodex in the planning
     * @param catalogGUID               The CatalogGUID in the planning
     * @param forceReloadPlanning       Force reload whole planning even if only viewPoint has changed. This is used when for example no 3D Render Client has loaded the current planning
     * @param camera  The RTV Camera Information for Unity/RTV KOMBI
     * @param useLatestCamera should the latest camera be used ? default yes when requesting the start viewpoint via the configurator button not
     */
    request3D(params: Request3DParameter): Promise<{
        planningHash: string;
        renderHash: string;
    } | undefined>;
    private checkIsRenderingCached;
    private addAlternateRenderingToSavedAlternateRenderings;
    private handleStaticVP;
    /**
     * This function is caleld when the navigation in the frontend changed (zoom/fullscreen/Swipe/ElementFocus...)
     * @param mode  Should the viewpoint change zoom/fullscreen/swipe...
     * @param params    Parameters used by the mode
     */
    handle3DVisualizationChanged(mode: Nav3DMode, params: Nav3DParams): void;
    /**
     * This function resets the viewpoint to default.
     */
    resetNav3D(): void;
    /**
     * This function returns all StaticRoomList items that should be displayed in the view
     */
    getStaticRoomListItems(): import("../../..").StaticRoomDataType[];
    clearCurrentRendering(): void;
    closeConnection(): void;
    checkConnectionInitialized(): boolean;
    checkIsWaitingForHQRenderScript(): boolean;
    setOrigConfigurationCallback(callback: any): void;
    updateCamPosition(cam: Hybrid3DInfo_Camera): void;
    getLastSavedHQRenderScript(): HQRenderScript | undefined;
    openARObserverConnection(handleNoHqrs: () => void): Promise<string>;
    sendARRenderScript(hqRenderScript: HQRenderScript): void;
}
//# sourceMappingURL=PlannerHandler3D.d.ts.map