zakeke-configurator-react 0.1.370 → 0.1.372

package/dist/declarations/3D/src/Components/SceneHelper.d.ts

@@ -1,352 +1,352 @@
-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>;
-}
+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>;
+}