@colijnit/homedecorator 255.1.1

package/app/core/service/homedecorator.service.d.ts

@@ -0,0 +1,14 @@
+import { HomedecoratorSettingsService } from './homedecorator-settings.service';
+import { HomedecoratorConnectorService } from './homedecorator-connector.service';
+import { HomedecoratorSettings } from '../model/homedecorator-settings';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class HomedecoratorService {
+    private _settingsService;
+    private _connectorService;
+    loaded: BehaviorSubject<boolean>;
+    constructor(_settingsService: HomedecoratorSettingsService, _connectorService: HomedecoratorConnectorService);
+    init(settings: HomedecoratorSettings, forceReload?: boolean): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HomedecoratorService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HomedecoratorService>;
+}

package/app/core/service/integration.service.d.ts

@@ -0,0 +1,16 @@
+import { OnDestroy } from '@angular/core';
+import { MessageBusService } from './message-bus.service';
+import { HomedecoratorAppEventService } from './homedecorator-app-event.service';
+import * as i0 from "@angular/core";
+export declare class IntegrationService implements OnDestroy {
+    private _messageBus;
+    private _appEventService;
+    private _subs;
+    private _enabled;
+    constructor(_messageBus: MessageBusService, _appEventService: HomedecoratorAppEventService);
+    ngOnDestroy(): void;
+    private _handleMessage;
+    private _postTheMessage;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IntegrationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<IntegrationService>;
+}

package/app/core/service/item-serialization.service.d.ts

@@ -0,0 +1,78 @@
+import { Item } from '../../plugins/core3d/items/item';
+import { Skin } from '../../plugins/core3d/model/skin';
+import { Furniture } from '../../plugins/core3d/items/furniture';
+import * as i0 from "@angular/core";
+export declare class ItemSerializationService {
+    constructor();
+    itemToObject(item: Item): {};
+    furnitureToObject(furniture: Furniture): {
+        item_name: any;
+        item_description: any;
+        item_type: any;
+        item_id: any;
+        item_identifier: any;
+        item_goodId: any;
+        item_goodType: any;
+        locked: any;
+        item_schema: any;
+        item_assetPath: any;
+        model_url: any;
+        configurable: any;
+        ione: any;
+        elementConfiguration: any;
+        xpos: any;
+        ypos: any;
+        zpos: any;
+        scalable: any;
+        scalePercentage: number;
+        onWall: any;
+        rotation: any;
+        fixed: any;
+        center_pivot: any;
+        elevation: any;
+        elevationFixed: any;
+        elevationAdjustable: any;
+        decos: any;
+        selections: any;
+        externalSettings: any;
+        conversionGTMSend: any;
+        conversionSubmittedPrice: any;
+    } | {
+        item_name: any;
+        item_type: any;
+        locked: any;
+        xpos: any;
+        ypos: any;
+        zpos: any;
+        rotation: any;
+        height: any;
+        width: any;
+        depth: any;
+        elevation: any;
+        canElevate: any;
+        skin: Skin;
+        fixed: any;
+    } | {
+        item_name: any;
+        item_type: any;
+        locked: any;
+        xpos: any;
+        ypos: any;
+        zpos: any;
+        rotation: any;
+        height: any;
+        radius: any;
+        elevation: any;
+        canElevate: any;
+        skin: Skin;
+        fixed: any;
+    };
+    private _serializeItem;
+    private _serializeItemGroup;
+    private _buildCustomShapeRecord;
+    private _buildCustomCylinderRecord;
+    private _buildItemRecord;
+    private _prepareShapeSkin;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ItemSerializationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ItemSerializationService>;
+}

package/app/core/service/json-utils.service.d.ts

@@ -0,0 +1,7 @@
+import * as i0 from "@angular/core";
+export declare class JsonUtilsService {
+    readJsonFile(filePath: string, includeBaseUrl?: boolean): Promise<any>;
+    private _includeBaseUrl;
+    static ɵfac: i0.ɵɵFactoryDeclaration<JsonUtilsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<JsonUtilsService>;
+}

package/app/core/service/message-bus.service.d.ts

@@ -0,0 +1,21 @@
+import { Subscription } from 'rxjs';
+import { MessagesWithoutPayload } from '../interface/message-without-payload.interface';
+import { MessagesWithPayload } from '../interface/message-with-payload.interface';
+import * as i0 from "@angular/core";
+declare type PayloadlessMessageTypes = keyof MessagesWithoutPayload;
+declare type PayloadMessageTypes = keyof MessagesWithPayload;
+interface PayloadMessage<T extends PayloadMessageTypes> {
+    type: T;
+    payload: MessagesWithPayload[T];
+}
+export declare class MessageBusService {
+    private emitters;
+    constructor();
+    emit<T extends PayloadlessMessageTypes>(type: T): void;
+    emit<T extends PayloadMessageTypes>(type: T, payload: PayloadMessage<T>['payload']): void;
+    subscribe<T extends PayloadlessMessageTypes>(messageType: T, observer: () => any): Subscription;
+    subscribe<T extends PayloadMessageTypes>(messageType: T, observer: (payload: PayloadMessage<T>['payload']) => any): Subscription;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MessageBusService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MessageBusService>;
+}
+export {};

package/app/core/service/permanent-store.service.d.ts

@@ -0,0 +1,37 @@
+import { Observable, Subject } from 'rxjs';
+import { OnDestroy } from '@angular/core';
+import { HttpClient } from '@angular/common/http';
+import { EnvironmentService } from './environment.service';
+import { MessageBusService } from './message-bus.service';
+import { HomedecoratorSettingsService } from './homedecorator-settings.service';
+import * as i0 from "@angular/core";
+export declare class PermanentStoreService implements OnDestroy {
+    private _http;
+    private _configuration;
+    private _settingsService;
+    private _httpHeaders;
+    private _code;
+    private _originalProjectCode;
+    private _registerFormID;
+    private _isLoading;
+    private _subs;
+    readonly maxSchemaSize = 16770000;
+    showLocalSave: boolean;
+    codeSet: Subject<string>;
+    static randomNumericChar(): string;
+    constructor(messageService: MessageBusService, _http: HttpClient, _configuration: EnvironmentService, _settingsService: HomedecoratorSettingsService);
+    ngOnDestroy(): void;
+    set code(value: string);
+    get code(): string;
+    private queryCode;
+    load(code: string): Observable<string>;
+    private create;
+    private update;
+    save(json: string, forceNewCode?: boolean): Observable<string>;
+    get registerFormID(): number;
+    set registerFormID(value: number);
+    updateRegisterForm(furniture: any): Promise<void>;
+    private _getFurniture;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PermanentStoreService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PermanentStoreService>;
+}

package/app/core/service/presets.service.d.ts

@@ -0,0 +1,50 @@
+import { OnDestroy } from '@angular/core';
+import { Subject } from 'rxjs';
+import { PluginInterface } from '../../plugins/plugin-interface';
+import { AppStateService, StateValue } from './app-state.service';
+import { PermanentStoreService } from './permanent-store.service';
+import { JsonUtilsService } from './json-utils.service';
+import { MessageBusService } from './message-bus.service';
+import { HomedecoratorSettingsService } from './homedecorator-settings.service';
+import { ConfigurationService } from './configuration.service';
+import { LocalStorageService } from '../../service/local-storage.service';
+import { ProgressService } from './progress.service';
+import { SceneService } from '../../plugins/core3d/service/scene.service';
+import * as i0 from "@angular/core";
+export declare class PresetsService implements OnDestroy {
+    private _appStateService;
+    private _permanentStoreService;
+    private _jsonUtils;
+    private _messageService;
+    private _settingsService;
+    private _configurationService;
+    private _storageService;
+    private _progressService;
+    private _sceneService;
+    isLoading: boolean;
+    beforeLoad: Subject<any>;
+    afterLoad: Subject<any>;
+    plugins: Array<PluginInterface>;
+    assetPath: string;
+    stateCreated: Subject<void>;
+    private _subs;
+    constructor(_appStateService: AppStateService, _permanentStoreService: PermanentStoreService, _jsonUtils: JsonUtilsService, _messageService: MessageBusService, _settingsService: HomedecoratorSettingsService, _configurationService: ConfigurationService, _storageService: LocalStorageService, _progressService: ProgressService, _sceneService: SceneService);
+    ngOnDestroy(): void;
+    register(plugin: PluginInterface): void;
+    reopenState(model: string): void;
+    createState(): StateValue;
+    private _loadSavedRoomFromPreset;
+    private _loadSavedRoomFromCloud;
+    private _clear;
+    private _loadRoomPlan;
+    private _applyState;
+    private _applyStateAndKeepCameraPosition;
+    private _parseModel;
+    private _apply;
+    private _reScaleModel;
+    private _scaleDimensionsAndPositions;
+    private _scaleTextures;
+    private _fixTexture;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PresetsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PresetsService>;
+}

package/app/core/service/progress.service.d.ts

@@ -0,0 +1,17 @@
+import { HomedecoratorSettingsService } from './homedecorator-settings.service';
+import { FileService } from './file.service';
+import * as i0 from "@angular/core";
+export declare class ProgressService {
+    private _settingsService;
+    private _fileService;
+    private _progressPerDownload;
+    total: number;
+    get progress(): number;
+    constructor(_settingsService: HomedecoratorSettingsService, _fileService: FileService);
+    prepareDownloads(furniture: any[]): Promise<void>;
+    finishDownloads(): void;
+    setLoaded(url: string, number: number): void;
+    private _reset;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProgressService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ProgressService>;
+}

package/app/core/service/ral.service.d.ts

@@ -0,0 +1,17 @@
+import { RALColor } from '../model/ral-color';
+import { JsonUtilsService } from './json-utils.service';
+import * as i0 from "@angular/core";
+export declare class RalService {
+    private jsonUtils;
+    ralColors: RALColor[];
+    constructor(jsonUtils: JsonUtilsService);
+    private initialize;
+    getContrastColor(colorString: string): string;
+    private initColor;
+    getGroups(): Promise<number[]>;
+    groupColors(group: number): RALColor[];
+    firstFromGroups(): Promise<RALColor[]>;
+    colorGroup(value: number): Promise<number>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RalService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RalService>;
+}

package/app/core/service/skip-button-info.service.d.ts

@@ -0,0 +1,19 @@
+import { HomedecoratorConnectorAdapterService } from './homedecorator-connector-adapter.service';
+import * as i0 from "@angular/core";
+export declare class SkipButtonInfoService {
+    private _connector;
+    private _text;
+    private _imageBody;
+    get text(): string;
+    set text(value: string);
+    get imageBody(): string;
+    set imageBody(value: string);
+    constructor(_connector: HomedecoratorConnectorAdapterService);
+    getSkipButtonImageAndText(goodId?: number): Promise<{
+        text: any;
+        imageBody: any;
+    }>;
+    private _returnResult;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkipButtonInfoService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SkipButtonInfoService>;
+}

package/app/core/service/toast.service.d.ts

@@ -0,0 +1,12 @@
+import { Subject } from 'rxjs';
+import { Toast } from '../model/toast';
+import { HomedecoratorDictionaryService } from './homedecorator-dictionary.service';
+import * as i0 from "@angular/core";
+export declare class ToastService {
+    private _dictionaryService;
+    showToastSub: Subject<Toast>;
+    constructor(_dictionaryService: HomedecoratorDictionaryService);
+    showToast(toast: Toast): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToastService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ToastService>;
+}

package/app/core/service/utils.service.d.ts

@@ -0,0 +1,68 @@
+import { ChangeDetectorRef, OnDestroy } from '@angular/core';
+import { Object3D } from 'three';
+import { KTX2Loader } from 'three/examples/jsm/loaders/KTX2Loader';
+import { MatDialog } from '@angular/material/dialog';
+import { HomedecoratorSettingsService } from './homedecorator-settings.service';
+import { JsonUtilsService } from './json-utils.service';
+import { ProgressService } from './progress.service';
+import { ItemService } from '../../plugins/core3d/service/item.service';
+import { SceneService } from '../../plugins/core3d/service/scene.service';
+import { ApiServiceModule } from './3dm-api';
+import { CameraService } from '../../plugins/core3d/service/camera.service';
+import * as i0 from "@angular/core";
+export declare class UtilsService implements OnDestroy {
+    apiServiceModule: ApiServiceModule;
+    private _settingsService;
+    private _jsonUtilsService;
+    private _progressService;
+    private _itemsService;
+    private _sceneService;
+    private _dialog;
+    private _cameraService;
+    clips: any;
+    private _objectCache;
+    private _subs;
+    private _ktx2Loader;
+    private _usdzExporter;
+    private _gltfExporter;
+    constructor(apiServiceModule: ApiServiceModule, _settingsService: HomedecoratorSettingsService, _jsonUtilsService: JsonUtilsService, _progressService: ProgressService, _itemsService: ItemService, _sceneService: SceneService, _dialog: MatDialog, _cameraService: CameraService);
+    ngOnDestroy(): void;
+    readFileAsText(file: File): Promise<string>;
+    /**
+     * Returns a new function that is a throttled version of given function func. Enforces that there is a always minimum amount of time
+     * between two subsequent calls of the function. Tail calls are always executed. In-between calls are lost and not executed.
+     *
+     * @param func The function to return as a throttled version
+     * @param throttleMs Number of milliseconds for throttle: the minimum time between any two subsequent function calls of function
+     * @param [thisArg] Optionally supply the this context of the caller
+     * @returns The given function, with the above-mentioned time constraints
+     */
+    getAsThrottledFunction(func: any, throttleMs?: number, thisArg?: any): any;
+    loadJsonModel(filePath: string): Promise<any>;
+    loadJsonObjectModel(filePath: string): Promise<any>;
+    private _absPosition;
+    loadObjModel(filePath: string, mtlUrl?: string): Promise<any>;
+    loadGlbModel(file: string, relativePath?: boolean, cleanUp?: boolean): Promise<Object3D>;
+    loadGlbFromFile(file: ArrayBuffer): Promise<Object3D>;
+    loadGlbRoom(file: string): Promise<Object3D>;
+    saveRoomAsGlb(): Promise<void>;
+    prepRoomForRender(standalone: boolean, renderParameters: any): Promise<void>;
+    private _createGLBForAPI;
+    private _sendFileToApi;
+    loadGlbSource(file: string): Promise<Object3D>;
+    showExportDialog(object: Object3D): void;
+    textureFromUrl(url: string): Promise<any>;
+    forceChangeDetection(cd: ChangeDetectorRef, component: any, propName: string): void;
+    getKTX2Loader(): KTX2Loader;
+    private _download3DModelAsGLB;
+    private _download3DModelAsUSDZ;
+    private _downloadFile;
+    private _loadGroup;
+    private _cleanedUpObjects;
+    private _addGroupChildrenToObject;
+    private _iterateChildren;
+    private _includeBaseUrl;
+    private _clearCache;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UtilsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UtilsService>;
+}

package/app/core/service/view-mode.service.d.ts

@@ -0,0 +1,27 @@
+import { BehaviorSubject } from 'rxjs';
+import { Euler, Vector2, Vector3 } from 'three';
+import { ViewMode } from '../enum/view-mode.enum';
+import * as i0 from "@angular/core";
+export declare class ViewModeService {
+    viewModeChanged: BehaviorSubject<ViewMode>;
+    room3DUpdated: BehaviorSubject<boolean>;
+    private _viewMode;
+    viewSize: Vector3;
+    viewCenter: Vector3;
+    private _viewCorner;
+    private _walkThroughCameraStartPoint;
+    set viewMode(value: ViewMode);
+    get viewMode(): ViewMode;
+    get viewCorner(): Vector2;
+    set viewCorner(value: Vector2);
+    get walkThroughCameraStartPoint(): [Vector3, Euler];
+    set walkThroughCameraStartPoint(value: [Vector3, Euler]);
+    setViewMode(viewSize: Vector3, viewCenter: Vector3, mode: ViewMode): void;
+    is2dViewActive(): boolean;
+    is3dViewActive(): boolean;
+    isWalkThroughViewActive(): boolean;
+    isVRViewActive(): boolean;
+    isTopViewActive(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ViewModeService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ViewModeService>;
+}

package/app/core/service/web-worker.service.d.ts

@@ -0,0 +1,18 @@
+import { OnDestroy } from '@angular/core';
+import { WebWorkerType } from '../workers/enum/web-worker-type.enum';
+import { WebWorkerMessage } from '../workers/enum/web-worker-message.enum';
+import * as i0 from "@angular/core";
+export declare class WebWorkerService implements OnDestroy {
+    private _webWorkers;
+    private _loadedWebWorkers;
+    constructor();
+    ngOnDestroy(): void;
+    webWorkersSupported(): boolean;
+    postMessage(webWorkerType: WebWorkerType, message: {
+        messageType: WebWorkerMessage;
+        messageData?: any;
+    }): Promise<MessageEvent>;
+    initWorkers(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WebWorkerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<WebWorkerService>;
+}

package/app/core/utils/clone-utils.d.ts

@@ -0,0 +1,5 @@
+import { Mesh, Object3D } from 'three';
+export declare class CloneUtils {
+    static CleanCloneObject(obj: any): Object3D | Mesh;
+    private static CloneDefaultProps;
+}

package/app/core/utils/color.utils.d.ts

@@ -0,0 +1,7 @@
+export declare class ColorUtils {
+    static HexToRgb(hex: string): {
+        r: number;
+        g: number;
+        b: number;
+    };
+}

package/app/core/utils/file.utils.d.ts

@@ -0,0 +1,36 @@
+export declare class FileUtils {
+    private static _cachedTextureUploads;
+    static StripMimeStringFromDataUri(dataUri: string): string;
+    static GetMimeStringFromDataUri(dataUri: string): string;
+    /**
+     * Deprecated
+     */
+    static FileExists(url: string, assetPath?: string): boolean;
+    static CheckModelConversion(url: string, assetPath: string): any;
+    static SaveTextureImage(metaData: any, fileName: string, assetPath: string): any;
+    static SaveGLBFile(data: Blob, assetPath: string): Promise<any>;
+    static ConvertStringToArrayBuffer(stringData: string): Uint8Array;
+    static ConvertByteArrayToString(byteArray: number[]): string;
+    static StringContainsDataUri(str: string): boolean;
+    /**
+     * There is some discrepancy regarding locations of h3d objects
+     * Therefor we need to (temporarily?!) fix the content url
+     * Also we need to change some additionals
+     */
+    static FixUrl(assetUrl: string): string;
+    static FixGlbUrl(assetUrl: string): string;
+    static MimeTypeFromFilename(fileName: string): string;
+    /**
+     * Downloads the given file to the users default download location.
+     * @param fileName With or without extension
+     * @param content File content as a string
+     * @param [mimeType = 'text/plain']
+     */
+    static DownloadFile(fileName: string, content: string, mimeType?: string): void;
+    static ReadAsText(file: File): Promise<string>;
+    static GetExtensionFromDataUri(dataUri: string): string;
+    static CreateDownloadFileNameFromBase64(dataUri: string): string;
+    static DownloadFromDataUri(dataUri: string, fileName: string): void;
+    static DocumentBodyToDataUri(documentBody: string, mimeType: string): string;
+    private static FixUnityUrl;
+}

package/app/core/utils/function/is-empty.function.d.ts

@@ -0,0 +1 @@
+export declare function isEmpty(value: any): boolean;

package/app/core/utils/function/is-nill.function.d.ts

@@ -0,0 +1 @@
+export declare function isNill(value: any): boolean;

package/app/core/utils/material.utils.d.ts

@@ -0,0 +1,33 @@
+import * as THREE from 'three';
+import { MeshStandardMaterial, Vector2 } from 'three';
+import { Texture } from '../model/texture';
+export declare class MaterialUtils {
+    static readonly canvasRatio = 4;
+    static readonly defaultWindow: THREE.MeshPhongMaterial;
+    static MAX_DIMENSION: number;
+    private static assetPath;
+    private static imgElement;
+    static imageCache: Map<string, HTMLImageElement>;
+    static textureCache: Map<string, THREE.Texture>;
+    static SetAssetPath(path: string): void;
+    static ClearCaches(): void;
+    static FromUrl(url: string, stretch: boolean, tileSize: number, repeatX?: number, repeatY?: number, dimensions?: THREE.Vector2, tileRotation?: number): Promise<THREE.Texture>;
+    static RotatedCanvasTexture(texture: Texture, textureURL: string, dimensions: THREE.Vector2, adjustScale: boolean, repeatX?: number, repeatY?: number): Promise<THREE.Texture>;
+    static CustomTileMapTexture(texture: Texture, dimensions: THREE.Vector2): Promise<THREE.Texture>;
+    static FromImage(texture: Texture): Promise<THREE.Texture>;
+    static ReadAndResizePhotoAsDataURL(file: File): Promise<HTMLImageElement>;
+    static LoadImageCached(src: string, resize?: boolean): Promise<HTMLImageElement>;
+    static GetMaterialMaps(material: MeshStandardMaterial, texture: Texture, dimensions?: Vector2): Promise<void>;
+    static loadMaterializeMaps(material: MeshStandardMaterial, texture: Texture): Promise<void>;
+    static GetCanvasFromImageTexture(img: HTMLImageElement, texture?: Texture, shift?: boolean, flip?: boolean): HTMLCanvasElement;
+    static FromFlippedImage(texture: Texture, dimensions: THREE.Vector2): Promise<THREE.Texture>;
+    private static CreateShiftedDataUrl;
+    private static CustomTileTexture;
+    private static RotatedImageTexture;
+    private static CreateTileDataUrl;
+    private static CreateTileMap;
+    private static CreateTileFromTexture;
+    private static ReadFileAsDataURL;
+    private static TextureSourceModified;
+    private static CreateImageElementFromSource;
+}

package/app/core/utils/object.utils.d.ts

@@ -0,0 +1,14 @@
+import { BufferGeometry, Color, Group, Material, Object3D, Scene, Vector3 } from 'three';
+import { Selection } from '@colijnit/configuratorapi/build/model/selection';
+import { Item } from '../../plugins/core3d/items/item';
+export declare class ObjectUtils {
+    static CreateArrow(name: string, color: Color | number | string, length: number, direction: Vector3, headLength: number, headWidth: number, doubleArrow?: boolean): Group;
+    static UpdateArrowLength(arrow: Group, length: number, direction: Vector3, headLength: number, headWidth: number, doubleArrow?: boolean): Group;
+    static GetParentItem(element: any): Item;
+    static GetDefaultMaterial(object: Object3D): Material;
+    static SameMaterial(first: Material, second: Material): boolean;
+    static GetChanges(firstItems: Object3D[], secondItems: Object3D[]): any;
+    static GetSelectionFromSelectedObject(object: any): Selection;
+    static UpdateUvs(geo: BufferGeometry): void;
+    static LoadHDRI(path: string, scene: Scene): Promise<void>;
+}

package/app/core/utils/relative-position.utils.d.ts

@@ -0,0 +1,12 @@
+import * as THREE from 'three';
+export declare class RelativePositionUtils {
+    static appOffsetTop: number;
+    static appOffsetLeft: number;
+    static SetApplicationOffset(element: any): void;
+    static GetClientMousePosition(event: MouseEvent | DragEvent): THREE.Vector2;
+    static GetClientTouchPosition(event: TouchEvent, canvas: any): THREE.Vector2;
+    static GetElementRect(element: any, handleAppOffset?: boolean): DOMRect;
+    private static GetElementOffset;
+    private static GetParentLeftOffset;
+    private static GetParentTopOffset;
+}

package/app/core/utils/variation-utils.d.ts

@@ -0,0 +1,12 @@
+import { VariationSettings } from '../../plugins/threedselector/threedselector/model/variation-settings';
+export declare class VariationUtils {
+    private static MaterialCache;
+    static LoadVariation(assetPath: string, url: string, fileName: string, includeVariationFolder?: boolean): Promise<VariationSettings>;
+    static GetVariationSettingsFromFile(id: string, compressedFile: any): Promise<VariationSettings>;
+    private static CreateSettingsBasedOnIndex;
+    private static CreateSettingsBasedOnFileName;
+    private static LoadFileContentFromZip;
+    private static FileIsImage;
+    private static GetBase64FileType;
+    private static GetZipContent;
+}

package/app/core/workers/enum/web-worker-message.enum.d.ts

@@ -0,0 +1,4 @@
+export declare enum WebWorkerMessage {
+    WriteCurrentSaveDataToIndexedDB = "WriteCurrentSaveDataToIndexedDB",
+    GetRecoverySaveDataFromIndexedDB = "GetRecoverySaveDataFromIndexedDB"
+}

package/app/core/workers/enum/web-worker-type.enum.d.ts

@@ -0,0 +1,3 @@
+export declare enum WebWorkerType {
+    IndexedDB = 0
+}

package/app/development/components/selected-child-material-texture.component.d.ts

@@ -0,0 +1,58 @@
+import { ElementRef, EventEmitter } from '@angular/core';
+import { Mapping, PixelFormat, Texture, TextureDataType, TextureFilter, Wrapping } from 'three';
+import { ColorSpace, CubeTextureMapping } from 'three/src/constants';
+import { HomedecoratorIconCacheService } from '../../core/service/homedecorator-icon-cache.service';
+import { SceneService } from '../../plugins/core3d/service/scene.service';
+import { IconEnum } from '../../core/enum/icon.enum';
+import * as i0 from "@angular/core";
+export declare class SelectedChildMaterialTextureComponent {
+    iconService: HomedecoratorIconCacheService;
+    private _sceneService;
+    readonly icon: typeof IconEnum;
+    input: ElementRef;
+    set map(value: Texture);
+    get map(): Texture;
+    title: string;
+    mapChange: EventEmitter<Texture>;
+    mappingList: {
+        id: Mapping | CubeTextureMapping;
+        description: string;
+    }[];
+    textureFilterList: {
+        id: TextureFilter;
+        description: string;
+    }[];
+    textureEncodingList: {
+        id: ColorSpace;
+        description: string;
+    }[];
+    pixelFormatList: {
+        id: PixelFormat;
+        description: string;
+    }[];
+    typeList: {
+        id: TextureDataType;
+        description: string;
+    }[];
+    wrappingList: {
+        id: Wrapping;
+        description: string;
+    }[];
+    showContent: boolean;
+    viewImageSrc: string;
+    showZoomImage: boolean;
+    private _map;
+    private _loadedImage;
+    constructor(iconService: HomedecoratorIconCacheService, _sceneService: SceneService);
+    showLargeImage(): void;
+    hideZoomImage(event: MouseEvent): void;
+    uploadImage(map: string): void;
+    render(): void;
+    changeFlip(value: boolean): void;
+    handleFileChange(event: any): Promise<void>;
+    deleteMap(): void;
+    private _reloadImage;
+    private _loadTexture;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SelectedChildMaterialTextureComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SelectedChildMaterialTextureComponent, "development-selected-child-material-texture", never, { "map": "map"; "title": "title"; }, { "mapChange": "mapChange"; }, never, never>;
+}