import { IDisposable } from '../Interfaces/IDisposable';
import { TryOnFineTuningSettings } from '../Interfaces/ITryOn';
import { Nullable } from '../types';
export type WorldExtends = {
    min: BABYLON.Vector3;
    max: BABYLON.Vector3;
};
export type DelayedMaterials = {
    [id: string]: {
        name: string;
        file: string;
    };
};
export type OffloadedMaterial = {
    name: string;
    data: any;
};
export type OffloadedMaterials = {
    [id: string]: OffloadedMaterial;
};
export type UrlTexture = BABYLON.Texture | BABYLON.CubeTexture | BABYLON.HDRCubeTexture | BABYLON.ColorGradingTexture | BABYLON.EquiRectangularCubeTexture;
export declare class SceneHelper implements IDisposable {
    private _scene;
    private _engine;
    private _camera;
    private _canvas;
    private _hemiLight;
    private _pointLight;
    private _onPrePointerObservableObserver;
    private _isPointerDown;
    private _radiusScale;
    private _positionScale;
    private _limitLowerRadius;
    private _zoomEnabled;
    private _minZoomPerc;
    private _maxZoomPerc;
    private _cameraPivot;
    private _resizableCanvas3DGenerator;
    private readonly _defHemiLightID;
    private readonly _defPointLightID;
    private readonly _targetAnimationID;
    private readonly _radiusAnimationID;
    private readonly _alphaAnimationID;
    private readonly _betaAnimationID;
    private readonly _dummyMaterialID;
    private _loadingMaterials;
    get camera(): Nullable<BABYLON.Camera>;
    constructor(scene: BABYLON.Scene);
    private static checkAllMaterialTextureReady;
    static whenAllMaterialTexturesAreReady(material: BABYLON.Material): Promise<void>;
    static whenTextureIsReadyAsync(texture: BABYLON.BaseTexture): Promise<void>;
    static whenMeshMaterialIsReady(mesh: BABYLON.AbstractMesh): Promise<void>;
    static whenMaterialIsReadyForSubMeshAsync(material: BABYLON.Material, mesh: BABYLON.AbstractMesh, subMesh: BABYLON.SubMesh): Promise<void>;
    private static getMeshGeometry;
    private static checkMeshIsReady;
    static checkAllMeshesAreReady(meshes: BABYLON.AbstractMesh[]): boolean;
    static whenAllMeshesAreReadyAsync(meshes: BABYLON.AbstractMesh[]): Promise<void>;
    static whenAllVisibleMeshesAreReadyAsync(meshes: BABYLON.AbstractMesh[]): Promise<void>;
    static whenMeshIsReadyAsync(mesh: BABYLON.AbstractMesh): Promise<void>;
    static visibleMeshesRequireDelayedLoading(scene: BABYLON.Scene): boolean;
    static meshRequiresDelayedLoading(mesh: BABYLON.AbstractMesh): boolean;
    materialRequiresDelayedLoading(materialID: string): boolean;
    private init;
    dispose(): void;
    switchFullScreen(parent: any): void;
    private quitFullscreen;
    private launchFullscreen;
    getMeshHierarchySize(mesh: BABYLON.AbstractMesh): BABYLON.Vector3;
    getMeshHierarchyCenter(mesh: BABYLON.AbstractMesh): BABYLON.Vector3;
    getSceneBoundingInfo(): Nullable<BABYLON.BoundingInfo>;
    userIsMoving(): boolean;
    cameraIsMoving(): boolean;
    cameraLimitsReached(): boolean;
    restoreCameraState(): void;
    isTextureWithUrl(texture: BABYLON.BaseTexture): texture is UrlTexture;
    getTextureUrl(texture: Nullable<BABYLON.BaseTexture>): Nullable<string>;
    private isEditControl;
    isRealMesh(mesh: BABYLON.AbstractMesh): boolean;
    meshFineTuningSettings(mesh: BABYLON.AbstractMesh): Nullable<TryOnFineTuningSettings>;
    meshHasParent(meshID: string, parentID: string): boolean;
    countSceneMeshes(): number;
    sceneHasRealMeshes(): boolean;
    getSceneMeshes(): BABYLON.AbstractMesh[];
    getSceneMeshesByName(name: string): BABYLON.AbstractMesh[];
    isVisibleMesh(mesh: BABYLON.AbstractMesh): boolean;
    getVisibleMeshes(): BABYLON.AbstractMesh[];
    getInvisibleMeshes(): BABYLON.AbstractMesh[];
    getSubMesh(mesh: BABYLON.AbstractMesh, submeshIdx: number): Nullable<BABYLON.SubMesh>;
    getMeshHierarchy(parentID: string): BABYLON.AbstractMesh[];
    getTryOnMeshHierarchy(parentID: string): BABYLON.AbstractMesh[];
    isCanvasMesh(mesh: BABYLON.AbstractMesh): boolean;
    isAREnabledForMesh(mesh: BABYLON.AbstractMesh): boolean;
    isTryOnEnabledForMesh(mesh: BABYLON.AbstractMesh): boolean;
    getMeshesForAR(): BABYLON.AbstractMesh[];
    checkMaterialsForAR(): boolean;
    getMeshesMaterials(meshes: BABYLON.AbstractMesh[]): BABYLON.Material[];
    getMeshMaterials(mesh: BABYLON.AbstractMesh): BABYLON.Material[];
    getHiddenMeshTotalVertices(): number;
    getTotalVertices(predicate?: (mesh: any) => boolean): number;
    getHiddenMeshTotalIndices(): number;
    getTotalIndices(predicate?: (mesh: any) => boolean): number;
    getAllMaterials(): BABYLON.Material[];
    getMeshesUsingMaterial(materialID: string): BABYLON.AbstractMesh[];
    isMeshUsingMaterial(mesh: BABYLON.AbstractMesh, materialID: string): boolean;
    getAllUnusedMaterials(): BABYLON.Material[];
    getSceneScreenshotAsync(width: number, height: number): Promise<string>;
    containsPBRMaterials(): boolean;
    getMeshesForTryOn(): BABYLON.AbstractMesh[];
    setupLights(): void;
    getDefaultHemisphericLight(): Nullable<BABYLON.HemisphericLight>;
    getDefaultPointLight(): Nullable<BABYLON.PointLight>;
    isDefaultLight(light: BABYLON.Light): boolean;
    setupCamera(): void;
    setCameraRadiusParameters(radius: number): void;
    removeCameraLimits(): void;
    getWorldExtends(): Nullable<WorldExtends>;
    getCameraWorldExtends(): Nullable<WorldExtends>;
    setupCameraLimits(worldExtends?: WorldExtends): void;
    adjustCamera(currentPluginName?: string, keepAlpha?: boolean, keepBeta?: boolean, animate?: boolean): void;
    normalizeAngleOfView(alpha: number, beta: number): {
        alpha: number;
        beta: number;
    };
    computeCameraAngleOfView(target: BABYLON.Vector3, position: BABYLON.Vector3): {
        alpha: number;
        beta: number;
    };
    moveCamera(endTarget: BABYLON.Vector3, endPosition: BABYLON.Vector3): void;
    animateCamera(endTarget: BABYLON.Vector3, endPosition: BABYLON.Vector3, seconds: number, callback?: () => void): void;
    wrapPi(angle: number): number;
    wrap2Pi(angle: number): number;
    zoomIn(): void;
    zoomOut(): void;
    zoom(perc: number): void;
    moveCameraToFinalParameters(alpha: number, beta: number, radius: number, target: BABYLON.Vector3): void;
    animateCameraToFinalParamters(endAlpha: number, endBeta: number, endRadius: number, endTarget: BABYLON.Vector3, seconds: number, callback?: () => void): void;
    private getFrustumSlope;
    calculateCameraRadius(worldExtends?: WorldExtends): number;
    private calculateLowerRadiusFromModelBoundingSphere;
    getWorldCenter(worldExtends?: WorldExtends): Nullable<BABYLON.Vector3>;
    getCameraWorldCenter(worldExtends?: WorldExtends): Nullable<BABYLON.Vector3>;
    getCameraRadius(worldExtends?: WorldExtends): Nullable<number>;
    setCameraLimitLowerRadius(limitLowerRadius: boolean, adjustCamera?: boolean): void;
    setCameraPositionScale(positionScale: number, adjustCamera?: boolean): void;
    getCameraPivot(): Nullable<BABYLON.AbstractMesh>;
    setCameraPivot(mesh: Nullable<BABYLON.AbstractMesh>): void;
    setZoomEnabled(enabled: boolean): void;
    setMinZoomPerc(minZoomPerc: number | undefined | null): void;
    setMaxZoomPerc(maxZoomPerc: number | undefined | null): void;
    setCameraAlphaLimits(lower: number | undefined | null, upper: number | undefined | null): void;
    setCameraLowerAlphaLimit(angle: number | undefined | null): void;
    setCameraUpperAlphaLimit(angle: number | undefined | null): void;
    setCameraLowerBetaLimit(angle: number | undefined | null): void;
    setCameraUpperBetaLimit(angle: number | undefined | null): void;
    setCameraBetaLimits(lower: number | undefined | null, upper: number | undefined | null): void;
    zoomOnMesh(mesh: BABYLON.AbstractMesh): void;
    takeScreenshotAsync(width: number, height: number): Promise<string>;
    takeContentScreenshotAsync(width: number, height: number): Promise<string>;
    takeMaterialScreenshotAsync(materialID: string, width: number, height: number): Promise<string>;
    getScenePBRMaterials(): BABYLON.PBRBaseMaterial[];
    resetPBRMaterialsImageProcessingConfiguration(): void;
    private adjustPBRMaterialImageProcessingConfiguration;
    animateMeshToFinalParameters(mesh: BABYLON.AbstractMesh, p: BABYLON.Vector3, rE: BABYLON.Vector3, rQ: BABYLON.Quaternion, s: BABYLON.Vector3, seconds?: number, callback?: () => void): void;
    getMaterialsUsingTexture(texture: BABYLON.BaseTexture): BABYLON.Material[];
    private getTextureMaterialsMap;
    getTexturesForMaterial(material: BABYLON.Material): BABYLON.BaseTexture[];
    getTexturesExclusivelyForMaterial(material: BABYLON.Material): BABYLON.BaseTexture[];
    getStandardMaterialTextures(material: BABYLON.StandardMaterial): BABYLON.BaseTexture[];
    getPBRBaseSimpleMaterialTextures(material: BABYLON.PBRBaseSimpleMaterial): BABYLON.BaseTexture[];
    getPBRMaterialTextures(material: BABYLON.PBRMaterial): BABYLON.BaseTexture[];
    getPBRMetallicRoughnessMaterialTextures(material: BABYLON.PBRMetallicRoughnessMaterial): BABYLON.BaseTexture[];
    getPBRSpecularGlossinessMaterialTextures(material: BABYLON.PBRSpecularGlossinessMaterial): BABYLON.BaseTexture[];
    getNewPBRMaterialTextures(material: Zakeke.PBRMaterial): BABYLON.BaseTexture[];
    createMeshesFromSubMeshes(mesh: BABYLON.AbstractMesh): void;
    private createMeshFromSubMesh;
    getNextIncrementalName(name: string): string;
    createBox(parent: Nullable<BABYLON.AbstractMesh>, name?: string): BABYLON.Mesh;
    createBoundingBox(mesh: Nullable<BABYLON.AbstractMesh>, name?: string): BABYLON.Mesh;
    createSphere(parent: Nullable<BABYLON.AbstractMesh>, name?: string): BABYLON.Mesh;
    createPlane(parent: Nullable<BABYLON.AbstractMesh>, name?: string): BABYLON.Mesh;
    createDisc(parent: Nullable<BABYLON.AbstractMesh>, name?: string): BABYLON.Mesh;
    createCylinder(parent: Nullable<BABYLON.AbstractMesh>, name?: string): BABYLON.Mesh;
    createTorus(parent: Nullable<BABYLON.AbstractMesh>, name?: string): BABYLON.Mesh;
    createKnot(parent: Nullable<BABYLON.AbstractMesh>, name?: string): BABYLON.Mesh;
    createRibbon(parent: Nullable<BABYLON.AbstractMesh>, name?: string): BABYLON.Mesh;
    createRoundedCubeAsync(parent: Nullable<BABYLON.AbstractMesh>, name: string, onProgress?: (event: BABYLON.ISceneLoaderProgressEvent) => void): Promise<BABYLON.AbstractMesh[]>;
    createRoundedCylinderAsync(parent: Nullable<BABYLON.AbstractMesh>, name: string, onProgress?: (event: BABYLON.ISceneLoaderProgressEvent) => void): Promise<BABYLON.AbstractMesh[]>;
    createMatBallAsync(parent: Nullable<BABYLON.AbstractMesh>, name: string, onProgress?: (event: BABYLON.ISceneLoaderProgressEvent) => void): Promise<BABYLON.AbstractMesh[]>;
    createMaleHeadAsync(parent: Nullable<BABYLON.AbstractMesh>, name: string, onProgress?: (event: BABYLON.ISceneLoaderProgressEvent) => void): Promise<BABYLON.AbstractMesh[]>;
    createFemaleHeadAsync(parent: Nullable<BABYLON.AbstractMesh>, name: string, onProgress?: (event: BABYLON.ISceneLoaderProgressEvent) => void): Promise<BABYLON.AbstractMesh[]>;
    createPokemonBallAsync(parent: Nullable<BABYLON.AbstractMesh>, name: string, onProgress?: (event: BABYLON.ISceneLoaderProgressEvent) => void): Promise<BABYLON.AbstractMesh[]>;
    createShaderBallAsync(parent: Nullable<BABYLON.AbstractMesh>, name: string, onProgress?: (event: BABYLON.ISceneLoaderProgressEvent) => void): Promise<BABYLON.AbstractMesh[]>;
    createBootsAsync(parent: Nullable<BABYLON.AbstractMesh>, name: string, onProgress?: (event: BABYLON.ISceneLoaderProgressEvent) => void): Promise<BABYLON.AbstractMesh[]>;
    createSuzanneAsync(parent: Nullable<BABYLON.AbstractMesh>, name: string, onProgress?: (event: BABYLON.ISceneLoaderProgressEvent) => void): Promise<BABYLON.AbstractMesh[]>;
    createStepPyramidAsync(parent: Nullable<BABYLON.AbstractMesh>, name: string, onProgress?: (event: BABYLON.ISceneLoaderProgressEvent) => void): Promise<BABYLON.AbstractMesh[]>;
    createTeapotAsync(parent: Nullable<BABYLON.AbstractMesh>, name: string, onProgress?: (event: BABYLON.ISceneLoaderProgressEvent) => void): Promise<BABYLON.AbstractMesh[]>;
    createAlloyWheelAsync(parent: Nullable<BABYLON.AbstractMesh>, name: string, onProgress?: (event: BABYLON.ISceneLoaderProgressEvent) => void): Promise<BABYLON.AbstractMesh[]>;
    createTryonReferenceGlassesFrameAsync(parent: Nullable<BABYLON.AbstractMesh>, name: string, onProgress?: (event: BABYLON.ISceneLoaderProgressEvent) => void): Promise<BABYLON.AbstractMesh[]>;
    createTryOnReferenceModelsAsync(parent: Nullable<BABYLON.AbstractMesh>, name: string, filename: string, onProgress?: (event: BABYLON.ISceneLoaderProgressEvent) => void): Promise<BABYLON.AbstractMesh[]>;
    private importPrimitiveShapeAsync;
    private replaceTransformNodeWithMesh;
    importMeshesFromUrlAsync(url: string, parent: Nullable<BABYLON.AbstractMesh>, onProgress?: (event: BABYLON.ISceneLoaderProgressEvent) => void): Promise<BABYLON.AbstractMesh[]>;
    setupShaderMaterialsCameraPosition(): void;
    private setupShaderMaterialCameraPosition;
    getSceneCmScalingFactor(): Nullable<number>;
    exportSceneToUsdzAsync(sceneName: Nullable<string>, sceneRootUrl: Nullable<string>, sceneID?: string, sceneCode?: string, arScale?: boolean): Promise<string>;
    exportMeshToUsdzAsync(sceneRootUrl: any, mesh: any, arScale?: boolean): Promise<string>;
    exportSceneToRemoteGlTFAsync(sceneName: Nullable<string>, sceneRootUrl: Nullable<string>, sceneID?: string, sceneCode?: string, arScale?: boolean): Promise<string>;
    exportMeshToRemoteGlTFAsync(sceneRootUrl: Nullable<string>, mesh: BABYLON.AbstractMesh, arScale?: boolean): Promise<string>;
    exportSceneToRemoteGLBAsync(sceneName: Nullable<string>, sceneRootUrl: Nullable<string>, sceneID?: string, sceneCode?: string, arScale?: boolean): Promise<string>;
    exportMeshToRemoteGLBAsync(sceneRootUrl: Nullable<string>, mesh: BABYLON.AbstractMesh, arScale?: boolean): Promise<string>;
    exportSceneToARMultiformatAsync(sceneName: Nullable<string>, sceneRootUrl: Nullable<string>, formats?: string[], arScale?: boolean): Promise<{
        format: string;
        arFileUrl: string;
    }[]>;
    exportMeshToARMultiformatAsync(sceneRootUrl: Nullable<string>, mesh: BABYLON.AbstractMesh, formats?: string[], arScale?: boolean): Promise<{
        format: string;
        arFileUrl: string;
    }[]>;
    private getGltfBlobForARExport;
    exportMeshToGLBBlob(sceneRootUrl: Nullable<string>, meshID: string): Promise<Blob | null>;
    exportMeshesToARAsync(filePrefix: string, sceneRootUrl: Nullable<string>, meshes: BABYLON.AbstractMesh[], sceneID?: string, sceneCode?: string, fileFormat?: 'usdz' | 'glTF' | 'glb', arScale?: boolean): Promise<string>;
    exportMeshesToARMultiformatAsync(filePrefix: string, sceneRootUrl: Nullable<string>, meshes: BABYLON.AbstractMesh[], formats?: string[], arScale?: boolean): Promise<{
        format: string;
        arFileUrl: string;
    }[]>;
    exportSceneToLocalGlTFBlobsAsync(): Promise<(string | Blob)[]>;
    exportSceneToLocalGlTFUrlsAsync(): Promise<string[]>;
    downloadSceneLocalGltfAsync(): Promise<void>;
    exportSceneToLocalGLBBlobAsync(): Promise<string | Blob | null>;
    exportSceneToLocalGLBBase64Async(): Promise<Nullable<string>>;
    exportSceneToLocalGLBUrlAsync(): Promise<Nullable<string>>;
    downloadSceneLocalGLBAsync(): Promise<void>;
    private getSceneLocalGLBBlobInfoAsync;
    exportSceneToLocalUSDZBlobAsync(): Promise<string | Blob | null>;
    exportSceneToLocalUSDZBase64Async(): Promise<Nullable<string>>;
    exportSceneToLocalUSDZUrlAsync(): Promise<Nullable<string>>;
    downloadSceneLocalUSDZAsync(): Promise<void>;
    private getSceneLocalUSDZBlobInfoAsync;
    private getSceneToGltfExportOptions;
    private getGltfFileUrl;
    private getUsdzFileUrl;
    exportSceneToBabylon(): string;
    exportVisibleMeshesToBabylon(): string;
    downloadImageFromBase64(base64: string, name: string, mimetype: string): void;
    private getStandardMaterialTextureType;
    private getPBRMetallicRoughnessMaterialTextureType;
    private getPBRSpecularGlossinessMaterialTextureType;
    private getPBRMaterialTextureType;
    private getZakekePBRMaterialTextureType;
    getMaterialTextureType(material: BABYLON.Material, texture: BABYLON.BaseTexture): Nullable<string>;
    getMaterialTexture(material: BABYLON.Material, type: string): Nullable<BABYLON.BaseTexture>;
    applyTexture(texture: Nullable<BABYLON.BaseTexture>, material: BABYLON.Material, type: string): void;
    applyTextureOnSerializedMaterial(serializedTexture: any, serializedMaterial: any, textureType: string, materialType: string): void;
    getSerializedMaterialTexture(serializedMaterial: any, textureType: string, materialType: string): any;
    private getMaterialTypeName;
    exportMeshToBabylon(mesh: BABYLON.AbstractMesh): Promise<string>;
    exportMeshesToBabylon(meshes: BABYLON.AbstractMesh[]): Promise<string>;
    exportMeshesForTyOnToBabylon(): Promise<string>;
    private downloadBlob;
    downloadMeshBabylonAsync(mesh: BABYLON.AbstractMesh): Promise<void>;
    downloadMeshesBabylonAsync(meshes: BABYLON.AbstractMesh[]): Promise<void>;
    loadAllDelayedMaterialsAsync(rootUrl: string, progressCallback?: (txt: number, totalTxt: number) => Promise<void>): Promise<BABYLON.Material[]>;
    loadDelayedMaterialsAsync(rootUrl: string, materialIDs: string[]): Promise<BABYLON.Material[]>;
    loadDelayedMaterialAsync(rootUrl: string, materialID: string): Promise<Nullable<BABYLON.Material>>;
    loadMaterialsAsync(rootUrl: string, delayedMaterials: DelayedMaterials, progressCallback?: (txt: number, totalTxt: number) => Promise<void>): Promise<BABYLON.Material[]>;
    private loadMaterialInternalAsync;
    showMesh(meshID: string): void;
    hideMesh(meshID: string): void;
    showHideMesh(meshID: string, show: boolean): void;
    changeMaterialColor(material: BABYLON.Material, propertyName: string, nextColor: BABYLON.Color3): void;
    applyMaterialByName(name: string, mesh: BABYLON.AbstractMesh): void;
    applyMaterial(material: BABYLON.Material, mesh: BABYLON.AbstractMesh): void;
    applyMaterialToSubMeshByName(name: string, mesh: BABYLON.AbstractMesh, subMesh: BABYLON.SubMesh): void;
    applyMaterialToSubMesh(material: BABYLON.Material, mesh: Nullable<BABYLON.AbstractMesh>, subMesh: BABYLON.SubMesh): void;
    getSubMeshMaterial(mesh: Nullable<BABYLON.AbstractMesh>, subMesh: BABYLON.SubMesh): Nullable<BABYLON.Material>;
    prefetchTexturesFormMeshAsync(mesh: BABYLON.AbstractMesh): Promise<void>;
    prefetchTexturesForMaterialAsync(material: BABYLON.Material): Promise<void>;
    checkDelayState(mesh: BABYLON.AbstractMesh): void;
    createEnvelopeMesh(mesh: BABYLON.Mesh): Nullable<BABYLON.AbstractMesh>;
    expandMesh(mesh: BABYLON.Mesh, delta: number): void;
    cloneMesh(id: string, duplicateGeometry?: boolean, updatableGeometry?: boolean): Nullable<BABYLON.AbstractMesh>;
    private duplicateGeometry;
    getSceneMaterialMetadata(materialID: string): any;
    getOrCreateSceneMaterialMetadata(materialID: string): any;
    removeSceneMaterialMetadata(materialID: string): void;
    offloadAllUnusedMaterials(): void;
    offloadMaterial(materialID: string): void;
    getOffloadedMaterialInfo(material: any): OffloadedMaterial;
    loadAllOffloadedMaterials(rootUrl: string): BABYLON.Material[];
    loadOffloadedMaterialsByIDs(rootUrl: string, materialIDs: string[]): BABYLON.Material[];
    loadOffloadedMaterial(rootUrl: string, materialID: string): Nullable<BABYLON.Material>;
    loadOffloadedMaterials(rootUrl: string, offloadedMaterials: OffloadedMaterials): BABYLON.Material[];
    private loadOffloadedMaterialInternal;
    loadAllOffloadedMaterialsAsync(rootUrl: string): Promise<BABYLON.Material[]>;
    loadOffloadedMaterialsByIDsAsync(rootUrl: string, materialIDs: string[]): Promise<BABYLON.Material[]>;
    loadOffloadedMaterialAsync(rootUrl: string, materialID: string): Promise<Nullable<BABYLON.Material>>;
    loadOffloadedMaterialsAsync(rootUrl: string, offloadedMaterials: OffloadedMaterials): Promise<BABYLON.Material[]>;
    private loadOffloadedMaterialInternalAsync;
    loadTextureFiles(rootUrl: string, textureUrls: string[]): void;
    private getOrLoadMaterialAsync;
    getOrCreateDummyMaterial(): BABYLON.Material;
    isDummyMaterial(material: BABYLON.Material): boolean;
    meshHasDummyMaterial(mesh: BABYLON.AbstractMesh, recursive: boolean): boolean;
    getMeshDelayedMaterialIDs(mesh: BABYLON.AbstractMesh): string[];
    getMeshOffloadedMaterialIDs(mesh: BABYLON.AbstractMesh): string[];
    setDummyMaterialToInvisibleMeshes(): void;
    setMeshDummyMaterial(mesh: BABYLON.AbstractMesh, recursive: boolean): void;
    unsetAllDummyMaterials(): void;
    unsetAllDummyMaterialsAsync(rootUrl: string): Promise<void>;
    unsetMeshDummyMaterial(mesh: BABYLON.AbstractMesh, recursive: boolean): void;
    unsetMeshDummyMaterialAsync(mesh: BABYLON.AbstractMesh, rootUrl: string, recursive: boolean): Promise<void>;
    reloadAllLoadingErrorTexturesAsync(rootUrl: string): Promise<void>;
    reloadMaterialLoadingErrorTexturesAsync(rootUrl: string, material: BABYLON.Material): Promise<void>;
    reloadLoadingErrorTextureAsync(rootUrl: string, texture: BABYLON.BaseTexture): Promise<void>;
    isTextureLoadingError(texture: BABYLON.BaseTexture): boolean;
    materialHasLoadingErrorTextues(material: BABYLON.Material): boolean;
    getMaterialDynamicTextures(material: BABYLON.Material): BABYLON.BaseTexture[];
    exportTextureToBase64Async(babylonTexture: BABYLON.BaseTexture, mimeType?: string, invertY?: boolean): Promise<Nullable<string>>;
    private createBase64FromCanvasAsync;
    private getPixelsFromTexture;
    comparePBRMaterials(mat1: BABYLON.PBRMaterial, mat2: BABYLON.PBRMaterial): void;
    private compareAnisotropy;
    private compareBRDF;
    private compareClearCoat;
    private compareDetailMap;
    private comparePrePassConfiguration;
    private compareSheen;
    private compareSubSurface;
    private compareCameraCurve;
    private compareImageProcessingConfiguration;
    private compareTexture;
    /**
     * Clear the scene and generate a canvas mesh
     * @param meshID The mesh ID to use, must be passed from the scene editor to update correctly the MeshSide
     * @param width The width of the canvas
     * @param height The height of the canvas
     * @param depth The depth of the canvas
     * @param borderRadius The border radius of the canvas
     * @returns The id of the generated mesh
     */
    private _loadedMeshes;
    private _isLoading;
    showResizableCanvas(width: number, height: number, depth: number, borderRadius: number, type: 'colored' | 'mirrored', borderColor: string, columns: number, rows: number): Promise<BABYLON.AbstractMesh[] | null | undefined>;
    /**
     * Remove all meshes from the scene
     */
    clearResizableMeshes(): void;
    private _lastVisibilityStates;
    switchMode(mode: 'upload' | 'resizable'): void;
    rotate(angle: number, axis: BABYLON.Vector3, animate: boolean): Promise<void>;
}