@colijnit/configurator 261.1.0 → 261.1.1

package/lib/services/google-translate.service.d.ts

@@ -0,0 +1,26 @@
+import { OnDestroy } from '@angular/core';
+import { SettingsService } from './settings.service';
+import { ConfiguratorConnectorService } from './configurator-connector.service';
+import * as i0 from "@angular/core";
+export declare class GoogleTranslation {
+    label: string;
+    translation: string;
+    language: string;
+    constructor(label: string, translation: string, language: string);
+}
+export declare class GoogleTranslateService implements OnDestroy {
+    private _settingsService;
+    private _connectorService;
+    private _clientLanguage;
+    private _defaultLanguage;
+    private _translations;
+    private _initialized;
+    private _initializedSubject;
+    private _connectionSubject;
+    protected googleApiEnabled: boolean;
+    constructor(_settingsService: SettingsService, _connectorService: ConfiguratorConnectorService);
+    ngOnDestroy(): void;
+    getTranslation(input: string): Promise<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GoogleTranslateService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<GoogleTranslateService>;
+}

package/lib/services/icon-cache.service.d.ts

@@ -0,0 +1,21 @@
+import { DomSanitizer, SafeHtml } from '@angular/platform-browser';
+import { IconEnum } from '../enum/icon.enum';
+import * as i0 from "@angular/core";
+export declare class IconCacheService {
+    private _sanitizer;
+    /**
+     * All the icons as a large JSON object, from the all-icons.json file.
+     * The object has property keys that are the icon names, and property values with the data string of the actual svg icon.
+     */
+    get iconCache(): {
+        [iconName: string]: SafeHtml;
+    };
+    private _iconCache;
+    private _allIcons;
+    constructor(_sanitizer: DomSanitizer);
+    getIcon(iconName: string): SafeHtml;
+    getIconAsBase64(iconName: IconEnum): SafeHtml;
+    setIconCache(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IconCacheService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<IconCacheService>;
+}

package/lib/services/intersection.service.d.ts

@@ -0,0 +1,11 @@
+import { Intersection, Object3D, Vector3 } from 'three';
+import { CameraService } from './camera.service';
+import * as i0 from "@angular/core";
+export declare class IntersectionService {
+    private _cameraService;
+    constructor(_cameraService: CameraService);
+    getIntersections(mouseVector: Vector3, planeObjects: Object3D[], options?: any): Intersection[];
+    removeIf(array: any, func: any): any[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<IntersectionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<IntersectionService>;
+}

package/lib/services/item.service.d.ts

@@ -0,0 +1,18 @@
+import { OnDestroy } from '@angular/core';
+import { Object3D, Vector3 } from 'three';
+import { SceneService } from './scene.service';
+import * as i0 from "@angular/core";
+export declare class ItemService implements OnDestroy {
+    private _sceneService;
+    get sceneItems(): Object3D[];
+    private _sceneItems;
+    constructor(_sceneService: SceneService);
+    ngOnDestroy(): void;
+    addItem(item: Object3D, replace?: boolean): void;
+    removeAllItems(): void;
+    removeItem(obj: any): void;
+    objectDimensions(object: Object3D): Vector3;
+    glassMaterialCheck(item: Object3D): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ItemService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ItemService>;
+}

package/lib/services/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/lib/services/light-creation.service.d.ts

@@ -0,0 +1,9 @@
+import { Light, LightShadow } from 'three';
+import * as i0 from "@angular/core";
+export declare class LightCreateService extends Light {
+    light: Light;
+    constructor();
+    createNewLight(lightType: string): Light<LightShadow>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LightCreateService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LightCreateService>;
+}

package/lib/services/light-presets.service.d.ts

@@ -0,0 +1,34 @@
+import { OnDestroy } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { LightsService } from './lights.service';
+import { SceneService } from './scene.service';
+import { LightPreset } from '../model/light-preset';
+import { BundleInitializerService } from './bundle-initialzer.service';
+import { ScreenSizeAnalysisService } from './screen-size-analysis.service';
+import { SettingsService } from './settings.service';
+import * as i0 from "@angular/core";
+export declare class LightPresetsService implements OnDestroy {
+    private _lightsService;
+    private _appService;
+    private _sceneService;
+    private _screenSizeAnalysis;
+    private _settingsService;
+    set activeLightPreset(value: LightPreset);
+    get activeLightPreset(): LightPreset;
+    loadedLightPresets: LightPreset[];
+    presetLoaded: BehaviorSubject<boolean>;
+    private _activeLightPreset;
+    private _lightPresetsLoaded;
+    private _subs;
+    private _lightsMap;
+    constructor(_lightsService: LightsService, _appService: BundleInitializerService, _sceneService: SceneService, _screenSizeAnalysis: ScreenSizeAnalysisService, _settingsService: SettingsService);
+    init(): void;
+    ngOnDestroy(): void;
+    loadLightPreset(lightPreset: LightPreset): Promise<void>;
+    prepareLoadLightPreset(standalone?: boolean): Promise<void>;
+    private _prepareLoadLightPreset;
+    private _createLightFromProperties;
+    private _setObjectProperties;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LightPresetsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LightPresetsService>;
+}

package/lib/services/lights.service.d.ts

@@ -0,0 +1,34 @@
+import { OnDestroy } from '@angular/core';
+import { Light } from 'three';
+import { Subject } from 'rxjs';
+import { SceneService } from './scene.service';
+import { ConfigurationService } from './configuration.service';
+import { BundleInitializerService } from './bundle-initialzer.service';
+import { FloorPlaneService } from './floor-plane.service';
+import * as i0 from "@angular/core";
+export declare class LightsService implements OnDestroy {
+    private _sceneService;
+    private _bundleInitializerService;
+    private _configurationService;
+    private _floorPlanService;
+    lights: Light[];
+    onLightAdded: Subject<{
+        light: Light;
+        index: number;
+    }>;
+    private _subs;
+    constructor(_sceneService: SceneService, _bundleInitializerService: BundleInitializerService, _configurationService: ConfigurationService, _floorPlanService: FloorPlaneService);
+    ngOnDestroy(): void;
+    init(): void;
+    createLight<T extends Light>(modelClass: any): void;
+    addLight(light: Light): void;
+    removeAllLights(): void;
+    initiateLightPreset(): void;
+    updateAllOffsets(): void;
+    updateOffsets(light: Light): void;
+    private _addLight;
+    private _removeLight;
+    private _updateShadowCamera;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LightsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LightsService>;
+}

package/lib/services/load-furniture-base.service.d.ts

@@ -0,0 +1,37 @@
+import { OnDestroy } from '@angular/core';
+import { Article } from '@colijnit/configuratorapi/build/model/article';
+import { BehaviorSubject } from 'rxjs';
+import { Object3D } from 'three';
+import { SwitchBuildFurnitureService } from './switch-build-furniture.service';
+import { ThreedselectorService } from './threedselector.service';
+import { SettingsService } from './settings.service';
+import { ConfiguratorConnectorService } from './configurator-connector.service';
+import { ConfigurationResultObject } from '../model/configuration-result-object';
+import { ItemType } from '../enum/item-type.enum';
+import * as i0 from "@angular/core";
+export declare abstract class LoadFurnitureBaseService implements OnDestroy {
+    protected configuratorConnectorService: ConfiguratorConnectorService;
+    protected threedSelectorService: ThreedselectorService;
+    protected buildFurnitureService: SwitchBuildFurnitureService;
+    protected settingsService: SettingsService;
+    private readonly _fullObjectCache;
+    set article(value: Article);
+    get article(): Article;
+    articleLoaded: BehaviorSubject<Article>;
+    private _subs;
+    private _article;
+    protected constructor(configuratorConnectorService: ConfiguratorConnectorService, threedSelectorService: ThreedselectorService, buildFurnitureService: SwitchBuildFurnitureService, settingsService: SettingsService);
+    ngOnDestroy(): void;
+    abstract loadFurniture(furnitureData: ConfigurationResultObject, shouldCopyInstance: boolean, looseOriginalConfiguration: boolean, standAlone: boolean, fromScratch: boolean, fromPreset: boolean, loadFromProject: boolean): Promise<ConfigurationResultObject>;
+    loadArticle(sku: string): Promise<Article>;
+    extendConfigurationBuildResult(article: Article, result: ConfigurationResultObject): ConfigurationResultObject;
+    getFull3DObject(sku: string, assetUrl: string, prepareProgress?: boolean): Promise<Object3D>;
+    protected tryLoadArticle(sku: string, result: ConfigurationResultObject, initConnector: boolean): Promise<void>;
+    private _cleanUp;
+    protected needs3DModel(type: ItemType): boolean;
+    initFull3DObject(configurationResultObject: ConfigurationResultObject): Promise<void>;
+    protected getAssetPathFromMetadata(metadata: ConfigurationResultObject): string;
+    private _getAssetPathFromModelUrlAndSchema;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LoadFurnitureBaseService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LoadFurnitureBaseService>;
+}

package/lib/services/load-furniture-without-scene.service.d.ts

@@ -0,0 +1,9 @@
+import { OnDestroy } from '@angular/core';
+import { LoadFurnitureBaseService } from './load-furniture-base.service';
+import { ConfigurationResultObject } from '../model/configuration-result-object';
+import * as i0 from "@angular/core";
+export declare class LoadFurnitureWithoutSceneService extends LoadFurnitureBaseService implements OnDestroy {
+    loadFurniture(furnitureData: ConfigurationResultObject, shouldCopyInstance?: boolean, looseOriginalConfiguration?: boolean, standAlone?: boolean, fromScratch?: boolean, fromPreset?: boolean, loadFromProject?: boolean): Promise<ConfigurationResultObject>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LoadFurnitureWithoutSceneService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LoadFurnitureWithoutSceneService>;
+}

package/lib/services/load-furniture.service.d.ts

@@ -0,0 +1,9 @@
+import { OnDestroy } from '@angular/core';
+import { LoadFurnitureBaseService } from './load-furniture-base.service';
+import { ConfigurationResultObject } from '../model/configuration-result-object';
+import * as i0 from "@angular/core";
+export declare class LoadFurnitureService extends LoadFurnitureBaseService implements OnDestroy {
+    loadFurniture(furnitureData: ConfigurationResultObject, shouldCopyInstance?: boolean, looseOriginalConfiguration?: boolean, standAlone?: boolean, fromScratch?: boolean, fromPreset?: boolean, loadFromProject?: boolean): Promise<ConfigurationResultObject>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LoadFurnitureService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LoadFurnitureService>;
+}

package/lib/services/loader.service.d.ts

@@ -0,0 +1,11 @@
+import * as i0 from "@angular/core";
+export declare class LoaderService {
+    private _hideLoaderTimeout;
+    private readonly _hideLoaderTimerTimeout;
+    set showLoader(value: boolean);
+    get showLoader(): boolean;
+    private _showLoader;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<LoaderService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LoaderService>;
+}

package/lib/services/locator.service.d.ts

@@ -0,0 +1,7 @@
+import { Injector } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class ServiceLocator {
+    static injector: Injector;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ServiceLocator, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ServiceLocator>;
+}

package/lib/services/message-board.service.d.ts

@@ -0,0 +1,18 @@
+import { Mesh, Scene } from 'three';
+import { SettingsService } from './settings.service';
+import { FontService } from './font.service';
+import * as i0 from "@angular/core";
+export declare class MessageBoardService {
+    private _settingsService;
+    private _fontService;
+    scene: Scene;
+    board: Mesh;
+    messages: Mesh[];
+    private _font;
+    constructor(_settingsService: SettingsService, _fontService: FontService);
+    init(scene: Scene): Promise<void>;
+    addMessage(message: string): void;
+    private _createMessageBoard;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MessageBoardService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MessageBoardService>;
+}

package/lib/services/post-processing.service.d.ts

@@ -0,0 +1,74 @@
+import { OnDestroy } from '@angular/core';
+import { PerspectiveCamera, Scene, WebGLRenderer } from 'three';
+import { SettingsService } from './settings.service';
+import { AppEventService } from './app-event.service';
+import { ConfigurationService } from './configuration.service';
+import { ScreenSizeAnalysisService } from './screen-size-analysis.service';
+import * as i0 from "@angular/core";
+export declare class PostProcessingService implements OnDestroy {
+    private _configurationService;
+    private _settingsService;
+    private _appEventService;
+    private _screenSizeAnalysis;
+    private _aoEnabled;
+    private _aaEnabled;
+    private _vignetteEnabled;
+    private _vignetteOffset;
+    private _vignetteDarkness;
+    private _composer;
+    private _n8aoPass;
+    private _renderPass;
+    private _outputPass;
+    private _fxaaPass;
+    private _smaaPass;
+    private _ssaaPass;
+    private _taaRenderPass;
+    private _vignettePass;
+    private _outlinePass;
+    private _scene;
+    private _renderer;
+    private _camera;
+    private _blendShader;
+    private _width;
+    private _height;
+    private _outlinePassAsError;
+    private _hideOutlineTimer;
+    private _hideOutlineTimeout;
+    private _standalone;
+    private _cameraMoved;
+    private _postProcessingGui;
+    private _subs;
+    private _aoDefaultOptions;
+    private _aoOptions;
+    private _aaDefaultOptions;
+    private _aaOptions;
+    private _vignetteDefaultOptions;
+    private _vignetteOptions;
+    aoEnabled: boolean;
+    aaEnabled: boolean;
+    vignetteEnabled: boolean;
+    constructor(_configurationService: ConfigurationService, _settingsService: SettingsService, _appEventService: AppEventService, _screenSizeAnalysis: ScreenSizeAnalysisService);
+    ngOnDestroy(): void;
+    init(renderer: WebGLRenderer, scene: Scene, camera: PerspectiveCamera, width: number, height: number, standalone: boolean): void;
+    setSize(width: number, height: number, force?: boolean): void;
+    render(): void;
+    cameraMovementChanged(): void;
+    showGui(): void;
+    hideGui(): void;
+    forceRenderCanvas(): void;
+    private _loadSetting;
+    private _showErrorOutline;
+    private _showOutline;
+    private _hideOutline;
+    private _updateAASize;
+    private _initComposer;
+    private _cleanUp;
+    private _applyAoProps;
+    private _createGuiTaaPass;
+    private _showHideGui;
+    private _createGui;
+    private _setErrorGlowSettings;
+    private _setSelectionGlowSettings;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PostProcessingService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PostProcessingService>;
+}

package/lib/services/product-configurator.service.d.ts

@@ -0,0 +1,11 @@
+import { EventEmitter } from '@angular/core';
+import { Answer } from '@colijnit/configuratorapi/build/model/answer';
+import { SelectorStructure } from '@colijnit/configuratorapi/build/model/selector-structure.bo';
+import * as i0 from "@angular/core";
+export declare class ProductConfiguratorService {
+    showChange: EventEmitter<boolean>;
+    answerChosen: EventEmitter<Answer>;
+    selectSelection: EventEmitter<SelectorStructure>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProductConfiguratorService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ProductConfiguratorService>;
+}

package/lib/services/progress.service.d.ts

@@ -0,0 +1,9 @@
+import * as i0 from "@angular/core";
+export declare class ProgressService {
+    private _progressPercent;
+    get progress(): number;
+    set progress(value: number);
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProgressService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ProgressService>;
+}

package/lib/services/scene-event.service.d.ts

@@ -0,0 +1,72 @@
+import { OnDestroy } from '@angular/core';
+import { Mesh, Object3D } from 'three';
+import { CameraService } from './camera.service';
+import { SceneService } from './scene.service';
+import { ConfiguratorConnectorService } from './configurator-connector.service';
+import { IntersectionService } from './intersection.service';
+import { FloorPlaneService } from './floor-plane.service';
+import { ItemService } from './item.service';
+import { AppEventService } from './app-event.service';
+import * as i0 from "@angular/core";
+export declare class SceneEventService implements OnDestroy {
+    private _sceneService;
+    private _cameraService;
+    private _connectorService;
+    private _intersectionService;
+    private _floorPlaneService;
+    private _itemService;
+    private _appEventService;
+    readonly intersectOffsetForWalls = 20;
+    readonly longTouchDuration = 600;
+    rotateNoDrag: boolean;
+    private _element;
+    private _controls;
+    private _camera;
+    private _mousePosition;
+    private _oldMousePosition;
+    private _rotationStartPoint;
+    private _intersectedObject;
+    private _intersectedMesh;
+    private _mouseoverObject;
+    private _selectedObject;
+    private _prevSelectedObject;
+    private _defaultCursorStyle;
+    private _inDragOver;
+    private _mouseDown;
+    private _mouseMoved;
+    private _rotateMouseOver;
+    private _groupingMode;
+    private _state;
+    private _intersectedWall;
+    private _intersectedFloor;
+    private _subs;
+    private _cameraMoveSub;
+    private _debouncedSaveState;
+    private _touchStart;
+    private _touchEnd;
+    private _touchCancel;
+    private _touchMove;
+    constructor(_sceneService: SceneService, _cameraService: CameraService, _connectorService: ConfiguratorConnectorService, _intersectionService: IntersectionService, _floorPlaneService: FloorPlaneService, _itemService: ItemService, _appEventService: AppEventService);
+    ngOnDestroy(): void;
+    init(element: HTMLElement): void;
+    setExploreMode(on?: boolean): void;
+    setSelectedObject(object: Object3D, mesh?: Object3D | Mesh): void;
+    setUnselectedObject(): void;
+    private _updateIntersections;
+    private _clearIntersectedObject;
+    private _setMousePositionFromTouchEvent;
+    private _touchStartEvent;
+    private _touchEndEvent;
+    private _touchMoveEvent;
+    private _mouseUpEvent;
+    private _mouseMoveEvent;
+    private _leftMouseDownEvent;
+    private _getIntersections;
+    private _setIntersectedObject;
+    private _isMouseEventAllowed;
+    private _mouseToVec3;
+    private _markSceneToUpdate;
+    private _setCursorStyle;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SceneEventService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SceneEventService>;
+}

package/lib/services/scene-options.service.d.ts

@@ -0,0 +1,11 @@
+import { BehaviorSubject, Subject } from 'rxjs';
+import { SceneOptionButtonInterface } from '../interfaces/scene-option-button.interface';
+import * as i0 from "@angular/core";
+export declare class SceneOptionsService {
+    sceneOptionButtonAdded: BehaviorSubject<SceneOptionButtonInterface>;
+    sceneOptionButtonUpdated: Subject<SceneOptionButtonInterface>;
+    addSceneOptionButton(button: SceneOptionButtonInterface): void;
+    updateSceneOptionButton(button: SceneOptionButtonInterface): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SceneOptionsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SceneOptionsService>;
+}

package/lib/services/scene.service.d.ts

@@ -0,0 +1,71 @@
+import { OnDestroy } from '@angular/core';
+import { Mesh, Object3D, Scene, Vector2, Vector3, WebGLRenderer } from 'three';
+import { BehaviorSubject, Subject } from 'rxjs';
+import { WebGLPathTracer } from 'three-gpu-pathtracer';
+import { SettingsService } from './settings.service';
+import { CameraService } from './camera.service';
+import { XrService } from './xr.service';
+import { VrService } from './vr.service';
+import { ArService } from './ar.service';
+import { PostProcessingService } from './post-processing.service';
+import { ViewModeService } from './view-mode.service';
+import * as i0 from "@angular/core";
+export declare class SceneService implements OnDestroy {
+    private _cameraService;
+    private _xrService;
+    private _vrService;
+    private _arService;
+    private _settingsService;
+    private _postProcessing;
+    private _viewModeService;
+    set needsRender(value: boolean);
+    get needsRender(): boolean;
+    scene: Scene;
+    renderer: WebGLRenderer;
+    pathTracer: WebGLPathTracer;
+    standAlone: boolean;
+    onBeforeRender: Subject<{
+        renderer: WebGLRenderer;
+        scene: Scene;
+    }>;
+    onAfterRender: Subject<{
+        renderer: WebGLRenderer;
+        scene: Scene;
+    }>;
+    sceneInitialized: BehaviorSubject<boolean>;
+    renderingThroughPostProcessingPipeline: boolean;
+    webGL2Available: boolean;
+    domElement: HTMLElement;
+    private _needsRender;
+    private _arMode;
+    private _subs;
+    private _maxRenderSamples;
+    private _numberOfSamplesRendered;
+    constructor(_cameraService: CameraService, _xrService: XrService, _vrService: VrService, _arService: ArService, _settingsService: SettingsService, _postProcessing: PostProcessingService, _viewModeService: ViewModeService);
+    ngOnDestroy(): void;
+    getScene(): Scene;
+    set arMode(value: boolean);
+    get arMode(): boolean;
+    takeScreenshot(): string;
+    init(element: HTMLElement): Promise<void>;
+    getSceneCanvasImage(): string;
+    addObject(obj: Object3D, forceRender?: boolean): void;
+    removeObject(obj: Object3D | Mesh, forceRender?: boolean, cleanUp?: boolean): void;
+    updatePathTracer(): void;
+    positionInSceneToScreen(pos: Vector3): Vector2;
+    rendererPropsChange(): void;
+    private _initScene;
+    private _initCamera;
+    private _initPostProcessing;
+    private _initPathTracer;
+    private _initRenderer;
+    private _resizeRendererToDisplaySize;
+    private _updateWindowSize;
+    private _checkCanvasResize;
+    private _render;
+    private _animate;
+    private _pauseAnimation;
+    private _setSceneBackground;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SceneService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SceneService>;
+}

package/lib/services/screen-size-analysis.service.d.ts

@@ -0,0 +1,32 @@
+import { OnDestroy, OnInit } from '@angular/core';
+import { EventManager } from '@angular/platform-browser';
+import { Observable } from 'rxjs';
+import { ScreenSizeInfo } from '../interfaces/screen-size-info';
+import { NavigatorType } from '../enum/navigator-type.enum';
+import { DeviceDetectorService } from 'ngx-device-detector';
+import * as i0 from "@angular/core";
+export declare const minimalScreenWidthByDeviceType: {
+    desktop: number;
+    tablet: number;
+    phone: number;
+};
+export declare class ScreenSizeAnalysisService implements OnDestroy, OnInit {
+    private _eventManager;
+    private _deviceDetectorService;
+    private _onResizeSubject;
+    get screenSizeChanged(): Observable<ScreenSizeInfo>;
+    get isMobileDevice(): boolean;
+    constructor(_eventManager: EventManager, _deviceDetectorService: DeviceDetectorService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    getScreenSizeInfo(window: Window): ScreenSizeInfo;
+    isIphoneOrIpad(): boolean;
+    isSafari(): boolean;
+    navigatorType(): NavigatorType;
+    private _getCurrentScreenSize;
+    private _initOnResizeObservable;
+    private _getDeviceSizeType;
+    private _checkImageBitmapDisable;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScreenSizeAnalysisService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ScreenSizeAnalysisService>;
+}

package/lib/services/settings.service.d.ts

@@ -0,0 +1,24 @@
+import { BehaviorSubject, Subject } from 'rxjs';
+import { ConfiguratorSettings } from '../model/configurator-settings';
+import { JsonUtilsService } from './json-utils.service';
+import { DictionaryService } from './dictionary.service';
+import { Setting } from '../model/settings';
+import * as i0 from "@angular/core";
+export declare class SettingsService {
+    private _jsonUtilsService;
+    private _dictionaryService;
+    set settings(value: ConfiguratorSettings);
+    get settings(): ConfiguratorSettings;
+    settingsLoaded: BehaviorSubject<boolean>;
+    lightSettingsLoaded: BehaviorSubject<Setting[]>;
+    settingsChanged: Subject<void>;
+    private _settings;
+    constructor(_jsonUtilsService: JsonUtilsService, _dictionaryService: DictionaryService);
+    createSettingsFromObject(obj: any): void;
+    initializeSettings(settings?: ConfiguratorSettings): Promise<void>;
+    initialize(settings: ConfiguratorSettings): Promise<void>;
+    checkAdditionalParameters(): Promise<void>;
+    private _checkUrlParameters;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SettingsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SettingsService>;
+}

package/lib/services/switch-build-furniture.service.d.ts

@@ -0,0 +1,21 @@
+import { OnDestroy } from '@angular/core';
+import { BuildFurnitureService } from './build-furniture.service';
+import { BuildFurnitureWithoutSceneService } from './build-furniture-without-scene.service';
+import { BuildFurnitureBaseService } from './build-furniture-base.service';
+import { SettingsService } from './settings.service';
+import { ConfiguratorConnectorService } from './configurator-connector.service';
+import * as i0 from "@angular/core";
+export declare class SwitchBuildFurnitureService implements OnDestroy {
+    private _buildFurnitureService;
+    private _buildFurnitureWithoutSceneService;
+    private _settingsService;
+    private _configuratorService;
+    currentActiveService: BuildFurnitureBaseService;
+    private _standAlone;
+    private _controllerInitSub;
+    private _standAloneInstance;
+    constructor(_buildFurnitureService: BuildFurnitureService, _buildFurnitureWithoutSceneService: BuildFurnitureWithoutSceneService, _settingsService: SettingsService, _configuratorService: ConfiguratorConnectorService);
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SwitchBuildFurnitureService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SwitchBuildFurnitureService>;
+}

package/lib/services/switch-load-furniture.service.d.ts

@@ -0,0 +1,21 @@
+import { LoadFurnitureWithoutSceneService } from './load-furniture-without-scene.service';
+import { LoadFurnitureService } from './load-furniture.service';
+import { OnDestroy } from '@angular/core';
+import { LoadFurnitureBaseService } from './load-furniture-base.service';
+import { SettingsService } from './settings.service';
+import { ConfiguratorConnectorService } from './configurator-connector.service';
+import * as i0 from "@angular/core";
+export declare class SwitchLoadFurnitureService implements OnDestroy {
+    private _loadFurnitureService;
+    private _loadFurnitureWithoutSceneService;
+    private _settingsService;
+    private _iOne;
+    currentActiveService: LoadFurnitureBaseService;
+    private _standAlone;
+    private _controllerInitSub;
+    private _standAloneInstance;
+    constructor(_loadFurnitureService: LoadFurnitureService, _loadFurnitureWithoutSceneService: LoadFurnitureWithoutSceneService, _settingsService: SettingsService, _iOne: ConfiguratorConnectorService);
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SwitchLoadFurnitureService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SwitchLoadFurnitureService>;
+}

package/lib/services/threedselector.service.d.ts

@@ -0,0 +1,17 @@
+import { VariationCacheService } from './variation-cache.service';
+import * as THREE from 'three';
+import { UtilsService } from './utils.service';
+import { VariationSettings } from '../model/variation-settings';
+import { SettingsService } from './settings.service';
+import * as i0 from "@angular/core";
+export declare class ThreedselectorService {
+    private _variationCacheService;
+    private _settingsService;
+    private _utilsService;
+    private _threedUtils;
+    constructor(_variationCacheService: VariationCacheService, _settingsService: SettingsService, _utilsService: UtilsService);
+    downloadAssetsAndReturn(fileName: string, assetPath: string, prepareProgress?: boolean): Promise<THREE.Object3D>;
+    loadVariation(id: string): Promise<VariationSettings>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ThreedselectorService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ThreedselectorService>;
+}