import { EnvironmentManager } from '../Components/Environment/EnvironmentManager';
import { EditingMode, EnvironmentMode } from '../Enumerations';
import { IDisposable } from '../Interfaces/IDisposable';
import { ISceneEditor } from '../Interfaces/ISceneEditor';
import { FineTuningProviderData, TryOnFineTuningSettings, TryOnProvider, TryOnSettings, TryOnSettingsType, TryOnType } from '../Interfaces/ITryOn';
import { LightSelectedEventArgs, LightSelectedEventHandler } from '../Layers/LightsLayer';
import { Nullable } from '../types';
import { SceneViewer } from './SceneViewer';
export declare class MaterialGroup {
    groupName: string;
    materials: BABYLON.Material[];
    guid: string;
    constructor(groupName: string);
}
export type SceneEditorOptions = {
    showGround?: boolean;
    showHighlight?: boolean;
    highlightColor?: string;
    editorBackgroundColor?: string;
    highlightOver?: boolean;
    highlightOverColor?: string;
};
export type FileObjectData = {
    fileObjectID?: number | null | undefined;
    fileLength?: number | null | undefined;
    url?: string | null | undefined;
};
export type SceneSourceTextureInfo = {
    textureID?: string;
    fileObjectID?: number | null | undefined;
    fileLength?: number | null | undefined;
    url?: string;
};
export type SceneSourceInfo = {
    sourceID?: string;
    fileObjectID?: number | null | undefined;
    fileLength?: number | null | undefined;
    url?: string;
    rootUrl?: string;
    sceneFileName?: string;
    textureFiles: SceneSourceTextureInfo[];
};
export type SceneTextureInfo = {
    sceneID?: string;
    textureID?: string;
    materialID?: string;
    fileObjectID?: number | null | undefined;
    fileLength?: number | null | undefined;
    url?: string;
};
export type SceneMaterialPhotoInfo = {
    sceneID?: string;
    photoID?: string;
    materialID?: string;
    fileObjectID?: number | null | undefined;
    fileLength?: number | null | undefined;
    url?: string;
};
export declare enum SourceTaskStatus {
    uploading = 0,
    progress = 1,
    checking = 2,
    success = 3,
    completed_success = 4,
    completed_error = 5
}
export type SceneSourceTask = {
    taskID?: number;
    sourceID?: string;
    status?: SourceTaskStatus;
    message?: string;
    downloadProgress?: number;
    uploadProgress?: number;
    sceneSourceInfo: SceneSourceInfo;
};
export type MeshSelectedEventArgs = {
    id: string;
    name: string;
    scenePointerX: number;
    scenePointerY: number;
    screenPointerX: number;
    screenPointerY: number;
};
export type UploadSceneFileInfo = {
    sceneID: string;
    fileObjectID?: number | null | undefined;
    fileLength?: number | null | undefined;
    url: string;
    rootUrl: string;
    sceneFileName: string;
    manifestFileObjectID?: number | null | undefined;
    manifestFileLength?: number | null | undefined;
    manifestFileUrl?: string | null | undefined;
    incrementalsFileObjectID?: number | null | undefined;
    incrementalsFileLength?: number | null | undefined;
    incrementalsFileUrl?: string | null | undefined;
};
export type ProvidersTypesMapping = {
    list: {
        [key: string]: number;
    };
};
export type MaterialType = 'Standard' | 'PBRMetallicRoughness' | 'PBRSpecularGlossiness' | 'PBR' | 'NewPBR';
export type LightType = 'Point' | 'Directional' | 'Spot' | 'Hemispheric';
export type ObjectSizeType = 'width' | 'height' | 'depth';
export type PreUpdateEventHandler = () => void;
export type PostUpdateEventHandler = () => void;
export type MeshSelectedEventHandler = (evt: MeshSelectedEventArgs) => void;
export type SelectionChangedEventHandler = () => void;
export type SceneCreatedEventHandler = () => void;
export type CameraLocationCreatedEventHandler = (evt: Zakeke.SceneCameraLocation) => void;
export type SceneSourceTaskSuccessEventHandler = (evt: BABYLON.AbstractMesh[]) => void;
export type SceneSourceTaskErrorEventHandler = (evt?: number) => void;
export type SceneSourceTaskCheckEventHandler = () => void;
export type MeshesUpdateEventHandler = (evt: BABYLON.AbstractMesh[]) => void;
export type MaterialsUpdateEventHandler = (evt: MaterialGroup[]) => void;
export type LightsUpdateEventHandler = (evt: BABYLON.Light[]) => void;
export type CameraLocationsUpdateEventHandler = (evt: Zakeke.SceneCameraLocation[]) => void;
export type MeshLocationCreatedEventHandler = (evt: Zakeke.SceneMeshLocation) => void;
export type MeshLocationsUpdateEventHandler = (evt: Zakeke.SceneMeshLocation[]) => void;
export type ArTaskSuccessEventHandler = () => void;
export type ArTaskErrorEventHandler = () => void;
export type ArTasksCheckEventHandler = () => void;
export type TryOnTaskUpdateFineTuningSettingsEventHandler = (evt: TryOnFineTuningSettings) => void;
export type TryOnTaskCloseFineTuningEventHandler = () => void;
export declare class SceneEditor extends SceneViewer implements ISceneEditor, IDisposable {
    private _dracoEnabled;
    private _dracoEncodingSpeed;
    private _dracoDecodingSpeed;
    private _envMode;
    private _selectOnPick;
    private _showBoundingBox;
    private _editorBackgroundColor;
    private _showGround;
    private _ground;
    private _showLights;
    private _lightsLayer;
    private _showAxes;
    private _axesLayer;
    private _showFineTuning;
    private _fineTuningModelLoaded;
    private _showHighlight;
    private _highlightOver;
    private _highlightOverColor;
    private _editingMode;
    private _manipulatedNode;
    private _oldManipulatedNode;
    private _EditControl;
    private _editControl;
    private _editControlVisible;
    private _shiftPressed;
    private _ctrlPressed;
    private _realMeshVisibility;
    private _sceneSourceTasks;
    private _isLoadingSourceFiles;
    private _preUpdateListeners;
    private _postUpdateListeners;
    private _meshSelectedListeners;
    private _selectionChangedListeners;
    private _lightSelectedListeners;
    private _sceneCreatedListeners;
    private _cameraLocationCreatedListeners;
    private _sceneSourceTaskSuccessListeners;
    private _sceneSourceTaskErrorListeners;
    private _sceneSourceTasksCheckListeners;
    private _meshesUpdateListeners;
    private _materialsUpdateListeners;
    private _lightsUpdateListeners;
    private _cameraLocationsUpdateListeners;
    private _meshLocationCreatedListeners;
    private _meshLocationsUpdateListeners;
    private _arTaskSuccessListeners;
    private _arTaskErrorListeners;
    private _arTasksCheckListeners;
    private _tryOnFineTuningSettingListeners;
    private _tryOnFineTuningCloseListeners;
    private _providersTypesMapping;
    private _pickedProvider;
    private _providerData;
    private _sessionTryOnEnabled;
    private _tryOnInfoLoading;
    private _initialMeshMaterials;
    private _initialSubMeshMaterials;
    private _lastMeshMaterials;
    private _lastSubMeshMaterials;
    private _meshOver;
    private _incrementalFilesMaker?;
    private _sceneToBlobs?;
    private _showMeasurements;
    private _modelMeasurements;
    private static readonly EmptyGroupName;
    get realMeshVisibility(): {
        [meshID: string]: boolean;
    };
    get environmentManager(): Nullable<EnvironmentManager>;
    get envMode(): EnvironmentMode;
    get sceneSourceTasks(): SceneSourceTask[];
    set envMode(value: EnvironmentMode);
    get selectOnPick(): boolean;
    set seletOnPick(value: boolean);
    get showBoundingBox(): boolean;
    set showBoundingBox(value: boolean);
    get editorBackgroundColor(): string;
    set editorBackgroundColor(value: string);
    get showGround(): boolean;
    set showGround(value: boolean);
    get showLights(): boolean;
    set showLights(value: boolean);
    get showAxes(): boolean;
    set showAxes(value: boolean);
    get showFineTuning(): boolean;
    set showFineTuning(value: boolean);
    set fineTuningModelLoaded(value: boolean);
    get fineTuningModelLoaded(): boolean;
    get sessionTryOnEnabled(): boolean;
    set sessionTryOnEnabled(value: boolean);
    get tryOnInfoLoading(): boolean;
    set tryOnInfoLoading(value: boolean);
    get showHighlight(): boolean;
    set showHighlight(value: boolean);
    get highlightOver(): boolean;
    set highlightOver(value: boolean);
    get highlightOverColor(): string;
    set highlightOverColor(value: string);
    get editingMode(): EditingMode;
    set editingMode(value: EditingMode);
    get editControlVisible(): boolean;
    set editControlVisible(value: boolean);
    get providersTypesMapping(): ProvidersTypesMapping;
    set providersTypesMapping(value: ProvidersTypesMapping);
    get selectedProvider(): TryOnProvider;
    get selectedProviderFineTuningData(): FineTuningProviderData;
    get modelMeasurements(): BABYLON.Vector3;
    set modelMeasurements(value: BABYLON.Vector3);
    get showMeasurements(): boolean;
    fireHideMeasurementsEvent(): void;
    fireShowMeasurementsEvent(): void;
    protected constructor(options?: SceneEditorOptions);
    static createSceneEditorAsync(options?: SceneEditorOptions): Promise<SceneEditor>;
    protected createCanvas(): HTMLCanvasElement;
    protected deleteComponents(): void;
    dispose(): void;
    protected createEngine(): void;
    createEmptySceneAsync(): Promise<void>;
    protected setupSceneAsync(): Promise<void>;
    render(): void;
    private deleteHighlightLayer;
    protected setupAntialiasPostProcesses(): void;
    protected canEnableAntialiasing(): boolean;
    protected setupHighlightLayerIntensity(): void;
    protected setupAxes(): void;
    getMatchSameNameTextures(): boolean;
    setMatchSameNameTextures(value: boolean): void;
    getAREnabled(): boolean;
    setAREnabled(value: boolean): void;
    getAROnTheFly(): boolean;
    setAROnTheFly(value: boolean): void;
    setARAnchor(value: 'wall' | 'floor' | null): void;
    getTryOnEnabled(): boolean;
    setTryOnEnabled(value: boolean): void;
    setTryOnSelectedType(value: TryOnType): void;
    getForceDracoCompression(): boolean;
    setForceDracoCompression(value: boolean): void;
    setProvider(provider: TryOnProvider): void;
    setProviderFineTuningData(data: FineTuningProviderData): void;
    resetProviderFineTuningData(): void;
    getTryOnSelectedType(): TryOnType | null;
    getTryOnSetting(key: TryOnSettingsType): boolean;
    setTryOnSetting(key: TryOnSettingsType, value: any): void;
    setTryOnTypeSettings(settings: TryOnSettings): void;
    setTryOnDefaultTypeSettings(): void;
    getUseDelayedMaterialLoading(): boolean;
    setUseDelayedMaterialLoading(value: boolean): void;
    getUseDelayedTextureLoading(): boolean;
    setUseDelayedTextureLoading(value: boolean): void;
    getGlowEnabled(): boolean;
    setGlowEnabled(enabled: boolean): void;
    getGlowIntensity(): number;
    setGlowIntensity(intensity: number): void;
    getGlowBlurSize(): number;
    setGlowBlurSize(blurSize: number): void;
    getInfoPointsEnabled(): boolean;
    setInfoPointsEnabled(value: boolean): void;
    getInfoPointsBorderColor(): string;
    setInfoPointsBorderColor(value: string): void;
    getInfoPointsInnerPointColor(): string;
    setInfoPointsInnerPointColor(value: string): void;
    getInfoPointsColor(): string;
    setInfoPointsColor(value: string): void;
    getInfoPointsHighlightColor(): string;
    setInfoPointsHighlightColor(value: string): void;
    enableGlowForMesh(mesh: BABYLON.AbstractMesh): void;
    disableGlowForMesh(mesh: BABYLON.AbstractMesh): void;
    enableARForMesh(mesh: BABYLON.AbstractMesh): void;
    disableARForMesh(mesh: BABYLON.AbstractMesh): void;
    disableTryOnForMesh(mesh: BABYLON.AbstractMesh): void;
    enableTryOnForMesh(mesh: BABYLON.AbstractMesh): void;
    enableInfoPointsForMesh(mesh: BABYLON.AbstractMesh): void;
    disableInfoPointsForMesh(mesh: BABYLON.AbstractMesh): void;
    enableForcedInfoPointsVisibilityOnMesh(mesh: BABYLON.AbstractMesh): void;
    disableForcedInfoPointsVisibilityOnMesh(mesh: BABYLON.AbstractMesh): void;
    setEditorBackgroundColor(hexColor: string): void;
    setViewerBackgroundAlpha(alpha: number): void;
    setViewerBackgroundColor(hexColor: string): void;
    setViewerEnvironmentSizeAuto(sizeAuto: boolean): void;
    setViewerEnvironmentMainColor(hexColor: string): void;
    setViewerSkyboxCreateSkybox(createSkybox: boolean): void;
    setViewerSkyboxSize(size: number): void;
    setViewerSkyboxBlur(blur: number): void;
    setViewerSkyboxTexture(url: string, extensions?: string[], files?: string[]): void;
    removeViewerSkyboxTexture(): void;
    setViewerSkyboxColor(hexColor: string): void;
    setViewerGroundCreateGround(createGround: boolean): void;
    setViewerGroundSize(size: number): void;
    setViewerGroundTexture(url: string): void;
    removeViewerGroundTexture(): void;
    setViewerGroundColor(hexColor: string): void;
    setViewerGroundOpacity(opacity: number): void;
    setViewerGroundEnableShadow(enableShadow: boolean): void;
    setViewerGroundShadowLevel(shadowLevel: number): void;
    setViewerGroundEnableMirror(enableMirror: boolean): void;
    setViewerGroundMirrorBlur(mirrorBlur: number): void;
    setViewerCameraAutoRotate(autoRotate: boolean): void;
    setViewerCameraContrast(contrast: number): void;
    setViewerCameraExposure(exposure: number): void;
    setViewerCameraUpperAlphaLimit(alphaLimit: number): void;
    setViewerCameraLowerAlphaLimit(alphaLimit: number): void;
    setViewerCameraLowerBetaLimit(betaLimit: number | null): void;
    setViewerCameraUpperBetaLimit(betaLimit: number): void;
    setViewerCameraToneMappingEnabled(toneMappingEnabled: boolean): void;
    resetEditorEnvironment(): void;
    protected resetEditorBackground(): void;
    protected resetEditorCamera(): void;
    protected preSceneContentScreenshot(): void;
    protected postSceneContentScreenshot(): void;
    protected preSceneMaterialScreenshot(): void;
    protected postSceneMaterialScreenshot(): void;
    sceneReadyForSave(): boolean;
    isCurrentCameraPivot(meshID: string): boolean | null;
    getCurrentCameraPivotID(): Nullable<string>;
    setCameraPivot(meshID: string | null | undefined): void;
    private getBlobFromEmbeddedTextureAsync;
    private uploadEmbeddedTexturesAsync;
    protected useIncrementalLoading(): boolean;
    updateSceneModel(onSuccess: () => void, onError?: (reason: string) => void, onProgress?: (perc: number, type?: string) => void, options?: {
        forceDraco?: boolean;
    }): void;
    private onUploadScenFileSuccess;
    private uploadSceneFile;
    private getSceneFileBlobsAsync;
    getSceneJson(): string;
    private resetCameraRotationLimits;
    private setCameraRotationLimits;
    private adjustSceneForSerialization;
    private extractTextureNameAndUrl;
    private removeDisabledFresnelParameters;
    private uploadSceneIncrementalFiles;
    private getSceneIncrementalFilesAsync;
    setNewSceneModelAsync(zkModel: MPlaza.Model, zkScene: Zakeke.Scene): Promise<void>;
    getSceneConfig(): Zakeke.SceneConfig | null;
    protected preSceneFileLoading(): void;
    protected postSceneFileLoading(): void;
    removeAllVTOReferenceMeshes(meshes: BABYLON.AbstractMesh[]): BABYLON.Mesh[];
    hideAllVTOFiles(meshes: BABYLON.AbstractMesh[]): void;
    loadSceneSourceFiles(files?: File[] | string, onSuccess?: (task: SceneSourceTask) => void, onError?: (reason: string) => void): void;
    private checkSceneSourceTasks;
    private updateSceneModelFromSourceTask;
    private loadMeshesFromRemoteFiles;
    private loadMeshesFromRemoteFiles_OLD;
    isRealMesh(mesh: BABYLON.AbstractMesh): boolean;
    onMeshChanged(evt: {
        mesh: BABYLON.AbstractMesh;
    }): void;
    onSubMeshChanged(evt: {
        mesh: BABYLON.AbstractMesh;
        subMesh: BABYLON.SubMesh;
    }): void;
    onMaterialChanged(evt: {
        material: BABYLON.Material;
    }): void;
    onLightChanged(evt: {
        light: BABYLON.Light;
    }): void;
    getSceneMeshesByName(name: string): BABYLON.AbstractMesh[];
    getSceneMeshes(): BABYLON.AbstractMesh[];
    getMeshesUsingMaterial(materialID: string): BABYLON.AbstractMesh[];
    getMeshesMaterials(meshes: BABYLON.AbstractMesh[]): BABYLON.Material[];
    getMeshMaterials(mesh: BABYLON.AbstractMesh): BABYLON.Material[];
    getAllMaterials(): BABYLON.Material[];
    getGroupedMaterials(): MaterialGroup[];
    setMaterialsGroup(materialIDs: string[], groupName: string, fireEvent?: boolean): void;
    setMaterialGroup(materialID: string, groupName: string, fireEvent?: boolean): void;
    getMaterialGroup(materialID: string): string;
    removeMaterialGroup(materialID: string): void;
    getMaterialsByGroup(groupName: string | undefined | null): BABYLON.Material[];
    getGroupCenter(parent: BABYLON.AbstractMesh): Nullable<BABYLON.Vector3>;
    getGroupBoundingInfo(parent: BABYLON.AbstractMesh): BABYLON.BoundingInfo;
    showHideBoundingBox(show: any): void;
    updateBoundingBox(): void;
    deleteBoundingBox(): void;
    setCameraPositionScale(scale: number): void;
    setCameraLimitLowerRadius(limit: boolean): void;
    setCameraZoomEnabled(enabled: boolean): void;
    setCameraUseMinZoomPercentage(value: boolean): void;
    setCameraMinZoomPercentage(value: number): void;
    setCameraUseMaxZoomPercentage(value: boolean): void;
    setCameraMaxZoomPercentage(value: number): void;
    lockCameraAlphaAngle(): void;
    unlockCameraAlphaAngle(): void;
    lockCameraBetaAngle(): void;
    unlockCameraBetaAngle(): void;
    setCameraLowerAlphaLimit(): void;
    unsetCameraLowerAlphaLimit(): void;
    setCameraUpperAlphaLimit(): void;
    unsetCameraUpperAlphaLimit(): void;
    setCameraLowerBetaLimit(): void;
    unsetCameraLowerBetaLimit(): void;
    setCameraUpperBetaLimit(): void;
    unsetCameraUpperBetaLimit(): void;
    selectMesh(id: string): void;
    unselectMesh(id: string): void;
    unselectAllMeshes(): void;
    selectUnselectMesh(id: string, select: boolean): void;
    selectSingleMesh(mesh: BABYLON.AbstractMesh): void;
    unselectSingleMesh(mesh: any): void;
    isMeshSelected(mesh: BABYLON.AbstractMesh): boolean;
    showMesh(meshID: string): void;
    hideMesh(meshID: string): void;
    showHideMesh(meshID: string, show: boolean, notifyChanges?: boolean): void;
    setTemporaryExclusivelyVisible(meshID: string): void;
    resetRealVisibility(): void;
    changeMaterialColor(material: BABYLON.Material, propertyName: string, nextColor: BABYLON.Color3): void;
    renameMesh(id: string, name: string): void;
    protected firePreUpdateEvent(): void;
    addPreUpdateListener(listenerFunction: PreUpdateEventHandler): void;
    removePreUpdateListener(listenerFunction: PreUpdateEventHandler): void;
    protected firePostUpdateEvent(): void;
    addPostUpdateListener(listenerFunction: PostUpdateEventHandler): void;
    removePostUpdateListener(listenerFunction: PreUpdateEventHandler): void;
    protected fireMeshSelectedEvent(e: MeshSelectedEventArgs): void;
    addMeshSelectedListener(listenerFunction: MeshSelectedEventHandler): void;
    protected fireSelectionChangedEvent(): void;
    addSelectionChangedListener(listenerFunction: SelectionChangedEventHandler): void;
    protected fireLightSelectedEvent(e: LightSelectedEventArgs): void;
    addLightSelectedListener(listenerFunction: LightSelectedEventHandler): void;
    protected fireSceneCreatedEvent(): void;
    addSceneCreatedListener(listenerFunction: SceneCreatedEventHandler): void;
    protected fireCameraLocationCreatedEvent(e: Zakeke.SceneCameraLocation): void;
    addCameraLocationCreatedListener(listenerFunction: CameraLocationCreatedEventHandler): void;
    protected fireCameraLocationsUpdateEvent(locations?: Zakeke.SceneCameraLocation[]): void;
    addCameraLocationsUpdateListener(listenerFunction: CameraLocationsUpdateEventHandler): void;
    protected fireSceneSourceTaskSuccessEvent(meshes: BABYLON.AbstractMesh[]): void;
    addSceneSourceTaskSuccessListener(listenerFunction: SceneSourceTaskSuccessEventHandler): void;
    protected fireSceneSourceTaskErrorEvent(taskID?: number): void;
    addSceneSourceTaskErrorListener(listenerFunction: SceneSourceTaskErrorEventHandler): void;
    removeSceneSourceTaskErrorListener(listenerFunction: SceneSourceTaskErrorEventHandler): void;
    protected fireSceneSourceTaskCheckEvent(): void;
    addSceneSourceTaskCheckListener(listenerFunction: SceneSourceTaskCheckEventHandler): void;
    protected fireMeshesUpdateEvent(meshes?: BABYLON.AbstractMesh[]): void;
    addMeshesUpdateListener(listenerFunction: MeshesUpdateEventHandler): void;
    protected fireMaterialsUpdateEvent(materials?: MaterialGroup[]): void;
    addMaterialsUpdateListener(listenerFunction: MaterialsUpdateEventHandler): void;
    protected fireLightsUpdateEvent(lights?: BABYLON.Light[]): void;
    addLightsUpdateListener(listernerFunction: LightsUpdateEventHandler): void;
    protected fireMeshLocationCreatedEvent(location: Zakeke.SceneMeshLocation): void;
    addMeshLocationCreatedListener(listenerFunction: MeshLocationCreatedEventHandler): void;
    protected fireMeshLocationsUpdateEvent(locations?: Zakeke.SceneMeshLocation[]): void;
    addMeshLocatonsUpdateListener(listenerFunction: MeshLocationsUpdateEventHandler): void;
    protected fireArTaskSuccessEvent(): void;
    addArTaskSuccessListener(listenerFunction: ArTaskSuccessEventHandler): void;
    protected fireArTaskErrorEvent(): void;
    addArTaskErrorListener(listenerFunction: ArTaskErrorEventHandler): void;
    protected fireArTaskCheckEvent(): void;
    addArTaskCheckListener(listenerFunction: ArTasksCheckEventHandler): void;
    fireFineTuningSettingEvent(settings: TryOnFineTuningSettings): void;
    addFineTuningSettingListener(listenerFunction: TryOnTaskUpdateFineTuningSettingsEventHandler): number;
    removeFineTuningSettingListener(listenerIndex: number): void;
    removeAllFineTuningSettingListeners(): void;
    fireFineTuningCloseEvent(): void;
    addFineTuningCloseListener(listenerFunction: TryOnTaskCloseFineTuningEventHandler): void;
    clearListeners(): void;
    protected onPointerDown(evt: PointerEvent, pickInfo: BABYLON.PickingInfo): void;
    protected onPointerMove(evt: BABYLON.IPointerEvent, pickInfo: BABYLON.PickingInfo): void;
    getSubMesh(mesh: BABYLON.AbstractMesh, submeshIdx: number): Nullable<BABYLON.SubMesh>;
    getLightByID(id: string): Nullable<BABYLON.Light>;
    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;
    resetMeshMaterial(mesh: BABYLON.AbstractMesh, initial: boolean): void;
    resetSubMeshMaterial(mesh: BABYLON.AbstractMesh, subMesh: BABYLON.SubMesh, initial: boolean): void;
    getExtension(name: string): string | undefined;
    loadMobileTextureFilesAsync(filesToLoad: File[], material: Nullable<BABYLON.Material>, type: string, noMipMap: boolean): Promise<void>;
    getDAMMainMesh(): BABYLON.Mesh | undefined;
    loadMobileTextureFiles(filesToLoad: File[], material: Nullable<BABYLON.Material>, type: string, noMipMap: boolean, onSuccess?: () => void, onError?: (reason: any) => void): void;
    loadTextureFilesAsync(filesToLoad: File[], material: Nullable<BABYLON.Material>, type: string, noMipMap: boolean): Promise<void>;
    loadTextureFiles(filesToLoad: File[], material: Nullable<BABYLON.Material>, type: string, noMipMap: boolean, onSuccess?: () => void, onError?: (reason: any) => void): void;
    getRecursiveBoundingBox(mesh: BABYLON.AbstractMesh): BABYLON.BoundingBox;
    calculateRecursiveBoundingBox(mesh: BABYLON.AbstractMesh): void;
    calculateBoundingBox(meshes: BABYLON.AbstractMesh[]): number;
    checkMeshHiddenByMeshes(meshes: BABYLON.AbstractMesh[], referenceMesh: BABYLON.AbstractMesh[], maxThreshold: number, minThreshold: number): number;
    uploadTextureFileAsync(fileToLoad: File, material: Nullable<BABYLON.Material>): Promise<Nullable<Zakeke.SceneTexture>>;
    uploadTextureFiles(filesToLoad: File[], material: Nullable<BABYLON.Material>, type: string, onSuccess?: (zkSceneTextures: Zakeke.SceneTexture[]) => void, onError?: (reason: any) => void, resize?: boolean): void;
    protected getTexturesUploadUrl(materialID: string): string;
    removeAllMaterialPhotos(material: BABYLON.Material): void;
    removeMaterialPhotoAtIndex(material: BABYLON.Material, index: number): void;
    loadMaterialPhotoFiles(filesToLoad: File[], material: BABYLON.Material, onSuccess?: () => void, onError?: (reason: any) => void): void;
    uploadMaterialPhotoFiles(filesToLoad: File[], material: BABYLON.Material, onSuccess?: (zkSceneMaterialPhotos: Zakeke.SceneMaterialPhoto[]) => void, onError?: (reason: any) => void): void;
    protected getMaterialPhotosUploadUrl(materialID: string): string;
    protected canLoadCubemap(material: Nullable<BABYLON.Material>, type: string): boolean;
    setEnvironmentTexture(url: string, type: string, extensions?: string[], files?: string[], onLoad?: () => void): void;
    removeSceneEnvironmentTexture(): void;
    setSceneEnvironmentTextureRotationY(rotationY: number): void;
    private setTextureImage;
    private setCubeTextureImages;
    private setMobileTextureImage;
    private setMobileCubeTextureImages;
    private getCubeTextureInfo;
    isTextureUsed(texture: BABYLON.BaseTexture): boolean;
    changeTextureInvertYAsync(material: BABYLON.Material, type: string, invertY: boolean): Promise<void>;
    applyTextureByName(name: string, material: BABYLON.Material, type: string): void;
    applyTexture(texture: Nullable<BABYLON.BaseTexture>, material: BABYLON.Material, type: string): void;
    getMaterialTexture(material: BABYLON.Material, type: string): Nullable<BABYLON.BaseTexture>;
    removeMaterialTexture(material: BABYLON.Material, type: string): void;
    removeMaterialMobileTexture(material: BABYLON.Material, type: string): void;
    /**
     * Create a group of meshes
     * @param parentId Id of the parent node of the group
     * @param name Name of the group
     * @param children Array of meshes to be included in the group
     */
    createGroup(parentId: Nullable<string>, name: string, children?: BABYLON.AbstractMesh[]): Nullable<BABYLON.Mesh>;
    deleteMesh(meshID: string, removeMaterials: boolean): {
        meshIDs: string[];
        materialIDs: string[];
    };
    deleteAllMeshes(): void;
    deleteDuplicatedMeshesWithDifferentParent(parentID: string, removeMaterials: boolean): {
        meshIDs: string[];
        materialIDs: string[];
    };
    deleteDuplicatedChildMeshes(parentID: string, removeMaterials: boolean): {
        meshIDs: string[];
        materialIDs: string[];
    };
    deleteMaterial(materialID: string): void;
    private deleteMaterialInternal;
    deleteAllMaterials(): void;
    renameMaterial(id: string, name: string): void;
    cloneMesh(id: string): Nullable<BABYLON.AbstractMesh>;
    duplicateMesh(id: string, updatable?: boolean): Nullable<BABYLON.AbstractMesh>;
    cloneMaterial(id: string, newId?: string, newName?: string): Nullable<BABYLON.Material>;
    createMaterial(name?: string, type?: MaterialType, group?: string): Nullable<BABYLON.Material>;
    changeMeshParent(meshID: string, newParentID: string): void;
    removeMeshParent(meshID: any): void;
    protected setManipulatedNode(node: Nullable<BABYLON.AbstractMesh>): void;
    importLibraryMaterial(zkMaterial: Zakeke.Material): void;
    getTexturesForMaterial(material: BABYLON.Material): BABYLON.BaseTexture[];
    getStandardMaterialTextures(material: BABYLON.StandardMaterial): BABYLON.BaseTexture[];
    getPBRBaseSimpleMaterialTextures(material: BABYLON.PBRBaseSimpleMaterial): BABYLON.BaseTexture[];
    getPBRMaterialTextures(material: BABYLON.PBRMaterial): BABYLON.BaseTexture[];
    getNewPBRMaterialTextures(material: Zakeke.PBRMaterial): BABYLON.BaseTexture[];
    getPBRMetallicRoughnessMaterialTextures(material: BABYLON.PBRMetallicRoughnessMaterial): BABYLON.BaseTexture[];
    getPBRSpecularGlossinessMaterialTextures(material: BABYLON.PBRSpecularGlossinessMaterial): BABYLON.BaseTexture[];
    removeCameraLocation(cameraLocation: Zakeke.SceneCameraLocation): void;
    saveCameraLocation(name: string): void;
    clearCameraLocations(): void;
    getAllCameraLocations(): Zakeke.SceneCameraLocation[];
    saveMeshLocation(name: string): void;
    saveExplodedMeshLocation(): void;
    saveCollapsedMeshLocation(): void;
    protected onBeforeSaveMeshLocation(): void;
    protected onAfterSaveMeshLocation(): void;
    clearMeshLocations(): void;
    getAllMeshLocations(): Zakeke.SceneMeshLocation[];
    makeLibraryMaterial(id: string, name: string): Promise<void>;
    private getMaterialScreenShotForLibrary;
    private createLibraryMaterial;
    lightsLayer_onLightSelected(event: LightSelectedEventArgs): void;
    isDefaultLight(light: BABYLON.Light): boolean;
    createLight(name?: string, type?: LightType): Nullable<BABYLON.Light>;
    cloneLight(id: string, newId?: string, newName?: string): Nullable<BABYLON.Light>;
    renameLight(id: string, name: string): void;
    deleteLight(id: string): void;
    getAllLights(): BABYLON.Light[];
    canShowLights(): boolean;
    showHideLights(show: boolean): void;
    canShowGround(): boolean;
    removeGround(): void;
    refreshGround(): void;
    showHideGround(show: boolean): void;
    canShowAxes(): boolean;
    showHideAxes(show: boolean): void;
    showHideHighlight(show: boolean): void;
    setHighlightOver(highlight: boolean): void;
    highlightMesh(mesh: Nullable<BABYLON.AbstractMesh>, highlight: boolean): void;
    highlightMeshOver(highlight: boolean): void;
    showHideEditControl(show: boolean): void;
    setEditingMode(mode: EditingMode): void;
    undoEditing(): void;
    redoEditing(): void;
    setEnvironmentMode(newMode: EnvironmentMode): void;
    refreshEnvironment(): void;
    zoomOnMesh(mesh: BABYLON.AbstractMesh): void;
    moveCameraToMeshPosition(mesh: BABYLON.AbstractMesh): void;
    exportMeshToOBJ(meshID: string): void;
    exportMeshGeometryToJson(meshID: string): void;
    enableDisableARForMesh(meshID: string, value: boolean): void;
    isAREnabledForMesh(meshID: string): any;
    enableDisableTryOnForMesh(meshID: string, value: boolean): void;
    isTryOnEnabledForMesh(meshID: string): any;
    splitSubMeshes(meshID: string): void;
    flipMeshFaces(meshID: string): void;
    convertSceneToScreenPoint(sceneX: number, sceneY: number): Nullable<{
        X: number;
        Y: number;
    }>;
    saveTextAsFile(text: string, filename: string): void;
    saveBytesAsFile(data: ArrayBuffer, filename: string): void;
    saveBlobAsFile(blob: Blob, filename: string, mimetype: string): void;
    private downloadFile;
    exportDracoEncodedToFile(meshID: string): void;
    getDracoEncodedGeometry(originalMesh: BABYLON.AbstractMesh): Nullable<ArrayBuffer>;
    createCustomMesh(): Nullable<BABYLON.Mesh>;
    createBox(parentID: Nullable<string>, name: string): Nullable<BABYLON.AbstractMesh>;
    getSceneBoundingBox(): Nullable<BABYLON.AbstractMesh>;
    getOrCreateSceneBoundingBox(visible?: boolean): Nullable<BABYLON.AbstractMesh>;
    createSceneBoundingBox(visible?: boolean): Nullable<BABYLON.AbstractMesh>;
    createBoundingBox(meshID: Nullable<string>, name?: string, visible?: boolean): BABYLON.Mesh | null;
    createSphere(parentID: Nullable<string>, name?: string): Nullable<BABYLON.AbstractMesh>;
    createPlane(parentID: Nullable<string>, name?: string): Nullable<BABYLON.AbstractMesh>;
    createDisc(parentID: Nullable<string>, name?: string): Nullable<BABYLON.AbstractMesh>;
    createCylinder(parentID: Nullable<string>, name?: string): Nullable<BABYLON.AbstractMesh>;
    createTorus(parentID: Nullable<string>, name?: string): Nullable<BABYLON.AbstractMesh>;
    createKnot(parentID: Nullable<string>, name?: string): Nullable<BABYLON.AbstractMesh>;
    createRibbon(parentID: Nullable<string>, name?: string): Nullable<BABYLON.AbstractMesh>;
    createRoundedCubeAsync(parentID: Nullable<string>, name: string): Promise<BABYLON.AbstractMesh[]>;
    createRoundedCylinderAsync(parentID: Nullable<string>, name: string): Promise<BABYLON.AbstractMesh[]>;
    createMatBallAsync(parentID: Nullable<string>, name: string): Promise<BABYLON.AbstractMesh[]>;
    createMaleHeadAsync(parentID: Nullable<string>, name: string): Promise<BABYLON.AbstractMesh[]>;
    createFemaleHeadAsync(parentID: Nullable<string>, name: string): Promise<BABYLON.AbstractMesh[]>;
    createPokemonBallAsync(parentID: Nullable<string>, name: string): Promise<BABYLON.AbstractMesh[]>;
    createShaderBallAsync(parentID: Nullable<string>, name: string): Promise<BABYLON.AbstractMesh[]>;
    createBootsAsync(parentID: Nullable<string>, name: string): Promise<BABYLON.AbstractMesh[]>;
    createSuzanneAsync(parentID: Nullable<string>, name: string): Promise<BABYLON.AbstractMesh[]>;
    createStepPyramidAsync(parentID: Nullable<string>, name: string): Promise<BABYLON.AbstractMesh[]>;
    createTeapotAsync(parentID: Nullable<string>, name: string): Promise<BABYLON.AbstractMesh[]>;
    createAlloyWheelAsync(parentID: Nullable<string>, name: string): Promise<BABYLON.AbstractMesh[]>;
    createTryonReferenceGlassesFrameAsync(parentID: Nullable<string>, name: string): Promise<BABYLON.AbstractMesh[]>;
    createTryOnReferenceModelsAsync(parentID: Nullable<string>, name: string, filename: string): Promise<BABYLON.AbstractMesh[]>;
    importMeshesFromUrlAsync(parentID: Nullable<string>, url: string): Promise<BABYLON.AbstractMesh[]>;
    connectMeshToModelSideAsync(meshID: string, submeshID: number, sideID: number): Promise<void>;
    clearMeshDesignManagers(): void;
    getMeshDesignMananger(mesh: BABYLON.Mesh, subMesh: Nullable<BABYLON.SubMesh>): Nullable<import("..").MeshDesignManager>;
    translateDesignView(mesh: BABYLON.AbstractMesh, submesh: Nullable<BABYLON.SubMesh>, dx: number, dy: number): void;
    rotateDesignView(mesh: BABYLON.AbstractMesh, submesh: Nullable<BABYLON.SubMesh>, angle: number, centerX: number, centerY: number): void;
    scaleDesignView(mesh: BABYLON.AbstractMesh, submesh: Nullable<BABYLON.SubMesh>, hor: number, ver: number, centerX: number, centerY: number): void;
    setDesignViewTextureUVChannelAsync(mesh: BABYLON.AbstractMesh, submesh: Nullable<BABYLON.SubMesh>, uvChannel: number): Promise<void>;
    setDesignViewFormFactorAsync(mesh: BABYLON.AbstractMesh, submesh: Nullable<BABYLON.SubMesh>, percWidth: number, percHeight: number): Promise<void>;
    setSceneSizeCm(size: number | null, sizeType: ObjectSizeType): void;
    getSceneWidthCm(): Nullable<number>;
    getSceneHeightCm(): Nullable<number>;
    getSceneDepthCm(): Nullable<number>;
    setMeshSizeCm(meshId: string, size: number | null, sizeType: ObjectSizeType): void;
    getMeshWidthCm(meshID: string): Nullable<number>;
    getMeshHeightCm(meshID: string): Nullable<number>;
    getMeshDepthCm(meshID: string): Nullable<number>;
    getMaterialsPreviewsAsync(materialIDs: string[], width?: number, height?: number, crop?: boolean, createBlobs?: boolean): Promise<(Blob | string)[]>;
    getAllMaterialsPreviewsAsync(width?: number, height?: number, crop?: boolean, createBlobs?: boolean): Promise<(Blob | string)[]>;
    downloadMaterialsPreviewsAsync(materialIDs: string[], width?: number, height?: number, crop?: boolean): Promise<void>;
    downloadAllMaterialsPreviewsAsync(width?: number, height?: number, crop?: boolean): Promise<void>;
    createEnvelopeMesh(meshID: string): Nullable<BABYLON.AbstractMesh>;
    expandMesh(meshID: string, delta: number): void;
    enableDisableMeshFacetData(meshID: string, enable: boolean): void;
    enableDisableDepthSortFacets(meshID: string, enable: boolean): void;
}