@colijnit/configurator 262.1.3 → 262.1.5

package/index.d.ts

@@ -1,37 +1,37 @@
 import * as i0 from '@angular/core';
-import { OnDestroy, OnInit, EventEmitter, PipeTransform, TemplateRef, ElementRef, QueryList, AfterViewInit, ChangeDetectorRef, OnChanges, SimpleChanges } from '@angular/core';
+import { OnDestroy, EventEmitter, OnInit, TemplateRef, ViewContainerRef, ElementRef, QueryList, AfterViewInit, ChangeDetectorRef, OnChanges, SimpleChanges } from '@angular/core';
 import * as THREE from 'three';
-import { Object3D, Material, Vector3, Euler, Color, Side, PerspectiveCamera, Scene, Mesh, WebGLRenderer, Camera, Vector2, Light, Intersection } from 'three';
-import { SafeHtml, EventManager, DomSanitizer, SafeStyle } from '@angular/platform-browser';
+import { Object3D, Material, Vector3, Euler, Scene, Mesh, PerspectiveCamera, WebGLRenderer, Camera, Vector2, Box3 } from 'three';
+import { SafeHtml, DomSanitizer, SafeStyle } from '@angular/platform-browser';
 import { DecoNode } from '@colijnit/configuratorapi/build/model/deco-node';
 import { Selection } from '@colijnit/configuratorapi/build/model/selection';
-import { BehaviorSubject, Subject, Observable, Subscription } from 'rxjs';
+import { BehaviorSubject, Subject, Subscription } from 'rxjs';
 import { Answer } from '@colijnit/configuratorapi/build/model/answer';
 import { Article } from '@colijnit/configuratorapi/build/model/article';
+import { SelectorWithOptions } from '@colijnit/configuratorapi/build/model/selector-with-options';
 import { GetArticlesForCatalogRequest } from '@colijnit/configuratorapi/build/model/get-articles-for-catalog';
-import { QuestionAndAnswers } from '@colijnit/configuratorapi/build/model/question-and-answers';
-import { Options } from '@colijnit/ioneconnector/build/model/options';
-import { DataServiceResponseData } from '@colijnit/ioneconnector/build/model/data-service-response-data';
-import { LoginResponse } from '@colijnit/ioneconnector/build/model/login-response';
-import { TableName } from '@colijnit/mainapi/build/enum/table-name.enum';
 import { SelectorStructure } from '@colijnit/configuratorapi/build/model/selector-structure.bo';
-import { InternalParam } from '@colijnit/mainapi/build/enum/internal-param.enum';
-import { ConfiguratorStatisticsEnvironment } from '@colijnit/configuratorapi/build/model/configurator-statistics-environment';
-import { SelectorWithOptions } from '@colijnit/configuratorapi/build/model/selector-with-options';
+import { DataServiceResponseData } from '@colijnit/ioneconnector/build/model/data-service-response-data';
+import { QuestionAndAnswers } from '@colijnit/configuratorapi/build/model/question-and-answers';
 import { AnswerPrice } from '@colijnit/configuratorapi/build/model/answer-price';
 import { Question } from '@colijnit/configuratorapi/build/model/question';
 import { ArticleText } from '@colijnit/configuratorapi/build/model/article-text.bo';
 import { SkipButtonInfo } from '@colijnit/configuratorapi/build/model/skip-button-info';
+import { InternalParam } from '@colijnit/mainapi/build/enum/internal-param.enum';
+import { ConfiguratorStatisticsEnvironment } from '@colijnit/configuratorapi/build/model/configurator-statistics-environment';
+import * as i2 from '@colijnit/utilities';
+import { UtilitiesConnectorService, TextureInterface as TextureInterface$1, PostProcessingService, JsonUtilsService, LightsService, TranslationService } from '@colijnit/utilities';
+import { VariationHelper } from '@colijnit/configuratorcore';
 import { WebGLPathTracer } from 'three-gpu-pathtracer';
+import { Group } from '@tweenjs/tween.js';
 import { Font } from 'three/examples/jsm/loaders/FontLoader.js';
-import { DeviceDetectorService } from 'ngx-device-detector';
-import { ColorSpace } from 'three/src/constants.js';
 import * as i3 from '@angular/common';
 import * as i3$1 from '@colijnit/corecomponents_v12';
 import * as i7 from '@angular/forms';
-import { Color as Color$1 } from '@colijnit/configuratorapi/build/model/color';
-import { Tag } from '@colijnit/configuratorapi/build/model/tag';
+import { Overlay } from '@angular/cdk/overlay';
 import * as i4 from '@angular/cdk/clipboard';
+import { Color } from '@colijnit/configuratorapi/build/model/color';
+import { Tag } from '@colijnit/configuratorapi/build/model/tag';
 import * as i3$2 from '@angular/material/icon';
 import * as i4$1 from '@angular/material/button';
 import { ConfigurationDisplayOption } from '@colijnit/configuratorapi/build/enum/refcode/configuration-display-option.enum';
@@ -122,13 +122,17 @@ declare enum PresetDialogMode {
     LOAD = 1
 }
 
-declare class AppEventService {
+declare class ConfiguratorEventService {
+    skuSet: BehaviorSubject<string>;
+    instanceIdSet: BehaviorSubject<string>;
     instanceSet: BehaviorSubject<string>;
     answerCountReceived: BehaviorSubject<number>;
-    readyToRender: BehaviorSubject<boolean>;
+    buildStarted: BehaviorSubject<boolean>;
     buildFinished: BehaviorSubject<ConfigurationResultObject>;
+    addedToScene: BehaviorSubject<ConfigurationResultObject>;
     configurationTemplateChange: BehaviorSubject<ConfigurationTemplate>;
     articleNotFound: BehaviorSubject<ConfigurationResultObject>;
+    selectionWithAnswersChanged: BehaviorSubject<SelectorWithOptions[]>;
     glbCreated: Subject<string>;
     showOutline: Subject<any>;
     showErrorOutline: Subject<any>;
@@ -144,8 +148,13 @@ declare class AppEventService {
     onObjectSelected: Subject<IntersectedObjects>;
     onObjectUnSelected: Subject<boolean>;
     changeConfigurationPresetDialogMode: Subject<PresetDialogMode>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<AppEventService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<AppEventService>;
+    onCanvasImageReceived: Subject<string>;
+    onThumbnailReceived: Subject<string>;
+    renderImageChanged: BehaviorSubject<string>;
+    renderImageError: BehaviorSubject<string>;
+    startBuildFromPresetId: Subject<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfiguratorEventService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ConfiguratorEventService>;
 }
 
 declare class ArParameters {
@@ -227,6 +236,8 @@ declare class SettingOptions {
     maxVisibleTiles: number;
     maxVisibleSmallTiles: number;
     groupedShowAllBtn: boolean;
+    showSavePresetButton?: boolean;
+    showLoadPresetButton?: boolean;
 }
 
 declare class RenderParameters {
@@ -325,162 +336,25 @@ declare class ConfiguratorSettings {
     infoPublicationCode?: number;
 }
 
-declare class JsonUtilsService {
-    readJsonFile(filePath: string, includeBaseUrl?: boolean): Promise<any>;
-    private _includeBaseUrl;
-    static ɵfac: i0.ɵɵFactoryDeclaration<JsonUtilsService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<JsonUtilsService>;
-}
-
-declare class DictionaryService {
-    private _jsonUtilsService;
-    private readonly _placeholder;
-    private _client;
-    private _language;
-    private _dictionary;
-    constructor(_jsonUtilsService: JsonUtilsService);
-    get(key: string, upperCaseFirst?: boolean, ...replacementTexts: string[]): string;
-    setDictionary(path: string, client: string, languageCode: string, additionalTranslationFile?: any): Promise<void>;
-    private _getDictionaryData;
-    static ɵfac: i0.ɵɵFactoryDeclaration<DictionaryService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<DictionaryService>;
-}
-
-declare enum NavigatorType {
-    IOsSafari = "IOsSafari",
-    Browser = "Browser"
-}
-
-interface AoOptions {
-    aoSamples: number;
-    denoiseSamples: number;
-    denoiseRadius: number;
-    aoRadius: number;
-    distanceFalloff: number;
-    screenSpaceRadius: boolean;
-    halfRes: boolean;
-    depthAwareUpsampling: boolean;
-    transparencyAware: boolean;
-    intensity: number;
-    renderMode: string;
-    color: string;
-    colorMultiply: boolean;
-    stencil: boolean;
-    accumulate: boolean;
-    gammaCorrection: boolean;
-}
-
-interface AaOptions {
-    sampleLevel: number;
-    unbiased: boolean;
-}
-
-interface VignetteOptions {
-    vignetteOffset: number;
-    vignetteDarkness: number;
-}
-
-interface PostProcessingSetting {
-    aoEnabled: boolean;
-    aoOptions: AoOptions;
-    aaEnabled: boolean;
-    aaOptions: AaOptions;
-    vignetteEnabled: boolean;
-    vignetteOptions: VignetteOptions;
-}
-
-interface SettingInterface {
-    default: boolean;
-    standalone: boolean;
-    navigatorType: NavigatorType;
-    postprocessing: PostProcessingSetting;
-}
-
-declare class Setting {
-    navigatorType: NavigatorType;
-    default: boolean;
-    standalone: boolean;
-    postProcessing: PostProcessingSetting;
-    static CreateModelFromInterface(modelInterface: SettingInterface): Setting;
-}
-
-declare class SettingsService {
-    private _jsonUtilsService;
-    private _dictionaryService;
+declare class ConfiguratorSettingsService {
     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>;
-}
-
-declare class ConfiguratorService {
-    readonly showLoader: Subject<boolean>;
-    readonly connectionReset: Subject<void>;
-    loginResponse: LoginResponse;
-    private _configuratorApi;
-    private _mainApi;
-    private _articleApi;
-    private _boFactory;
-    private _publicationCodeForUserRole;
-    constructor();
-    initApi(options: Options): void;
-    cleanUp(): void;
-    initConnector(options: Options, forceReload?: boolean, mainUrl?: string, mainSchema?: string, mainVersion?: string): Promise<boolean>;
-    initNodeInstance(goodId: number, showLoader: boolean): Promise<DataServiceResponseData>;
-    changeConnection(instanceId: string, oldConnection: string, newConnection: string, showLoader: boolean): Promise<DataServiceResponseData>;
-    setInstanceToConfigure(id: string, showLoader?: boolean): Promise<DataServiceResponseData>;
-    getGoodIdFromSku(sku: string, showLoader?: boolean): Promise<DataServiceResponseData>;
-    getArticleQuickSel(goodId: number, showLoader?: boolean): Promise<DataServiceResponseData>;
-    getSelections(showLoader?: boolean, publicationCode?: number): Promise<DataServiceResponseData>;
-    getDecos(showLoader?: boolean): Promise<DataServiceResponseData>;
-    getQuestionAndAnswers(showLoader?: boolean, publicationCode?: number): Promise<QuestionAndAnswers>;
-    getSingleImage(nodeId: number | string, publication: number, includeMimetype: boolean, thumb: boolean, showLoader: boolean): Promise<DataServiceResponseData>;
-    selectSelection(selection: Selection, forceBackToNode?: boolean, after?: boolean, connector?: string): Promise<DataServiceResponseData>;
-    selectAnswer(answer: Answer, showLoader?: boolean, input?: string): Promise<DataServiceResponseData>;
-    selectAnswerBySelection(selection: Selection, userInput?: string): Promise<DataServiceResponseData>;
-    navigateTo(chosenOption: SelectorStructure, showLoader?: boolean): Promise<DataServiceResponseData>;
-    cancelAnswer(getAnswersAndQuestion?: boolean): Promise<DataServiceResponseData>;
-    deleteSelection(selection: Selection): Promise<DataServiceResponseData>;
-    replaceSelection(selection: Selection): Promise<DataServiceResponseData>;
-    getSelectionsAsync(): Promise<DataServiceResponseData>;
-    getQuestionAndAnswersAsync(): Promise<QuestionAndAnswers>;
-    getAnswerTexts(goodId: number, showLoader?: boolean): Promise<DataServiceResponseData>;
-    getAnswersPrices(): Promise<DataServiceResponseData>;
-    getSkipButtonImageAndText(goodId: number, showLoader?: boolean): Promise<DataServiceResponseData>;
-    getInternalParameterValue(parameter: InternalParam): Promise<DataServiceResponseData>;
-    getDecosAsync(): Promise<DataServiceResponseData>;
-    getSelectorStructure(showLoader?: boolean): Promise<DataServiceResponseData>;
-    getPublicationCodeBasedOnLogin(): number;
-    getImage(key: number | string, publication: number, thumb: boolean, tableName?: TableName): Promise<DataServiceResponseData>;
-    copyInstance(instanceId: string, shouldSaveCurrentInstanceId: boolean, showLoader?: boolean): Promise<DataServiceResponseData>;
-    saveConfigurations(showLoader?: boolean): Promise<boolean>;
-    storePreset(instanceId: string, showLoader?: boolean): Promise<DataServiceResponseData>;
-    initForPreset(presetId: string, goodId: number, showLoader?: boolean): Promise<DataServiceResponseData>;
-    googleTranslateEnabled(): Promise<boolean>;
-    getDefaultLanguage(upId: number): Promise<string>;
-    getGoogleTranslation(sourceLang: string, targetLang: string, list: string[]): Promise<string>;
-    getImageForSelectorStructure(option: SelectorStructure, publication: number, thumbNail?: boolean, showLoader?: boolean): Promise<string>;
-    getJsonConfiguredArticles(goodId: number, goodType: string, quantity: number, externalSource?: boolean, showLoader?: boolean, instanceId?: string, configuratorStatistics?: ConfiguratorStatisticsEnvironment): Promise<string>;
-    private _getPublicationCodeForRole;
-    static ɵfac: i0.ɵɵFactoryDeclaration<ConfiguratorService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<ConfiguratorService>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfiguratorSettingsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ConfiguratorSettingsService>;
 }
 
 declare class ConfiguratorConnectorService implements OnDestroy {
-    private _configuratorService;
     private _appEventService;
     private _settingsService;
     private _loaderService;
+    private _utilitiesConnectorService;
     get article(): Article;
     set article(value: Article);
     get sku(): string;
@@ -521,11 +395,15 @@ declare class ConfiguratorConnectorService implements OnDestroy {
     private _initializing;
     private _initialized;
     private _boFactory;
-    constructor(_configuratorService: ConfiguratorService, _appEventService: AppEventService, _settingsService: SettingsService, _loaderService: LoaderService);
+    private _configuratorService;
+    constructor(_appEventService: ConfiguratorEventService, _settingsService: ConfiguratorSettingsService, _loaderService: LoaderService, _utilitiesConnectorService: UtilitiesConnectorService);
     ngOnDestroy(): void;
+    cleanUp(): void;
+    init(settings?: ConfiguratorSettings): Promise<void>;
     initConnection(forceReload?: boolean, mainUrl?: string, mainSchema?: string, mainVersion?: string): Promise<void>;
     onShowLoaderChange(showLoader: boolean): void;
     onConnectionReset(): void;
+    getSingleImage(nodeId: number | string, publication: number, includeMimetype: boolean, thumb: boolean, showLoader: boolean): Promise<DataServiceResponseData>;
     getGoodIdFromSku(sku: string, showLoader?: boolean): Promise<number>;
     setSelections(selections: Selection[]): void;
     setDecoNodes(value: DecoNode[]): void;
@@ -562,9 +440,6 @@ declare class ConfiguratorConnectorService implements OnDestroy {
     saveConfigurations(): Promise<void>;
     storePreset(instanceId: string, showLoader?: boolean): Promise<DataServiceResponseData>;
     initForPreset(presetId: string, goodId: number, showLoader?: boolean): Promise<DataServiceResponseData>;
-    getDefaultLanguage(upId: number): Promise<string>;
-    googleTranslateEnabled(): Promise<boolean>;
-    getGoogleTranslation(sourceLang: string, targetLang: string, list: string[]): Promise<string>;
     getImageForAnswer(selectedOption: SelectorStructure, showLoader?: boolean): Promise<void>;
     addToCart(goodId: number, goodType: string, quantity: number, instanceId: string, externalSource: boolean): Promise<string>;
     getJsonConfiguredArticles(goodId: number, goodType: string, quantity: number, externalSource?: boolean, showLoader?: boolean, instanceId?: string, configuratorStatistics?: ConfiguratorStatisticsEnvironment): Promise<any>;
@@ -597,89 +472,6 @@ declare class ConfiguratorConnectorService implements OnDestroy {
     static ɵprov: i0.ɵɵInjectableDeclaration<ConfiguratorConnectorService>;
 }
 
-declare class AppInitializerService {
-    private _settingsService;
-    private _configuratorConnectorService;
-    appInitialized: BehaviorSubject<boolean>;
-    constructor(_settingsService: SettingsService, _configuratorConnectorService: ConfiguratorConnectorService);
-    initializeApp(settings?: ConfiguratorSettings): Promise<void>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<AppInitializerService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<AppInitializerService>;
-}
-
-declare class VariationSettingsSettings {
-    repeatx: number;
-    repeaty: number;
-    roughness: number;
-    metalness: number;
-}
-declare class VariationSettings {
-    id: string;
-    settings: VariationSettingsSettings;
-    texture: string;
-    textureFilename: string;
-    normal: string;
-    normalFilename: string;
-    ao: string;
-    aoFilename: string;
-    metalness: string;
-    metalnessFilename: string;
-    roughness: string;
-    roughnessFilename: string;
-    orm: string;
-    ormFilename: string;
-    displacement: string;
-    displacementValue: number;
-    displacementFilename: string;
-    sheen: number;
-    sheenColor: Color;
-    sheenColorMap: string;
-    sheenColorMapFilename: string;
-    sheenRoughness: number;
-    sheenRoughnessMap: string;
-    sheenRoughnessMapFilename: string;
-    transmissionMap: string;
-    transmissionMapFilename: string;
-    emissive: string;
-    emissiveFilename: string;
-    emissiveIntensity: number;
-    emissiveValue: Color;
-    opacity: number;
-    transparent: boolean;
-    envMap: string;
-    envMapFilename: string;
-    envMapIntensity: number;
-    reflectivity: number;
-    side: Side;
-    transmission: number;
-    ior: number;
-    thickness: number;
-    specularIntensity: number;
-    loading: boolean;
-    loaded: Subject<VariationSettings>;
-    material: any;
-    copyFrom(settings: VariationSettings): void;
-}
-
-declare class VariationCacheService implements OnDestroy {
-    private _settingsService;
-    private _configuratorService;
-    private _variations;
-    private _subs;
-    constructor(_settingsService: SettingsService, _configuratorService: ConfiguratorConnectorService);
-    ngOnDestroy(): void;
-    get(id: string): VariationSettings;
-    set(variations: VariationSettings): void;
-    preloadVariations(schema: string, decoNodes: DecoNode[], articleAssetPath?: string): void;
-    preloadVariationsAsync(schema: string, decoNodes: DecoNode[] | Answer[] | SelectorStructure[], articleAssetPath?: string): Promise<void>;
-    loadVariation(fileName: string): Promise<VariationSettings>;
-    private _waitForVariationToLoad;
-    private _createSettingsForFileName;
-    private _needsMaterials;
-    static ɵfac: i0.ɵɵFactoryDeclaration<VariationCacheService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<VariationCacheService>;
-}
-
 declare class ProgressService {
     private _progressPercent;
     get progress(): number;
@@ -689,97 +481,326 @@ declare class ProgressService {
     static ɵprov: i0.ɵɵInjectableDeclaration<ProgressService>;
 }
 
-declare class CameraService implements OnDestroy {
-    private _settingsService;
-    readonly panSpeed: number;
-    readonly rotateBy: number;
-    readonly moveBy: number;
-    readonly cameraDefaultHeight: number;
-    readonly targetDefaultOffset: number;
-    readonly exploreDistanceFromCorner: number;
-    camera: PerspectiveCamera;
-    controls: any;
-    cameraMovementChanged: Subject<void>;
-    private _cameraLocked;
-    private _element;
-    private _viewSize;
-    private _viewCenter;
-    private _exploreTargetDistance;
-    private _realAspectRatio;
-    private _aspectRatio;
-    private _viewMode;
+declare class UtilsService implements OnDestroy {
+    private _progressService;
+    clips: any;
+    private _objectCache;
     private _subs;
-    get cameraLocked(): boolean;
-    set realAspectRatio(value: number);
-    constructor(_settingsService: SettingsService);
+    constructor(_progressService: ProgressService);
     ngOnDestroy(): void;
-    init(element: HTMLElement): void;
-    cameraZoomIn(): void;
-    cameraZoomOut(): void;
-    lockCamera(): void;
-    unlockCamera(): void;
-    disableRotate(): void;
-    disableRotateHorizontal(): void;
-    disablePan(): void;
-    disableZoom(): void;
-    moveCameraToFitObject(object: any, offset?: number): Promise<void>;
-    private _getCameraOffset;
-    private _controlsUpdate;
-    static ɵfac: i0.ɵɵFactoryDeclaration<CameraService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<CameraService>;
+    createCanvasImage(objects: Object3D[], thumbnail?: boolean): string;
+    loadObjModel(filePath: string, mtlUrl?: string): Promise<any>;
+    downloadUSDZforARIOS(object: Object3D): Promise<void>;
+    private _addGroupChildrenToObject;
+    private _handleUpdateProgressBar;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UtilsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UtilsService>;
 }
 
-declare enum XrMode {
-    ArMode = "Ar Mode",
-    VrMode = "Vr Mode"
+declare abstract class BuildFurnitureBaseService implements OnDestroy {
+    protected configuratorConnectorService: ConfiguratorConnectorService;
+    protected appEventService: ConfiguratorEventService;
+    protected settingsService: ConfiguratorSettingsService;
+    protected utilsService: UtilsService;
+    get useNodeIdToLink(): boolean;
+    get currentCustomFloorGroup(): Object3D;
+    set currentCustomFloorGroup(item: Object3D);
+    get selections(): Selection[];
+    set scene(scene: Scene);
+    get scene(): Scene;
+    defaultPosition: Vector3;
+    defaultRotation: Euler;
+    baseElementNodeId: number;
+    articleAssetPath: string;
+    startPosition: Vector3;
+    full3DObjectToUse: Object3D;
+    isMouseOverObject: boolean;
+    activeConnector: any;
+    answerSelected: Subject<ConfigurationResultObject>;
+    arPlacementUpdate: Subject<boolean>;
+    showElementToolbar: boolean;
+    private _useNodeIdToLink;
+    private _activeChildElement;
+    private _adjustables;
+    private _addables;
+    private _currentCustomFloorGroup;
+    private _genericSelection;
+    private _answerSelected;
+    private _selectionsSelected;
+    private _scene;
+    protected subs: Subscription[];
+    protected placedAddables: any[];
+    protected placedAdjustables: any[];
+    protected variationHelper: VariationHelper;
+    constructor(configuratorConnectorService: ConfiguratorConnectorService, appEventService: ConfiguratorEventService, settingsService: ConfiguratorSettingsService, utilsService: UtilsService);
+    ngOnDestroy(): void;
+    abstract build(result: ConfigurationResultObject): Promise<ConfigurationResultObject>;
+    abstract createSimple3DModel(result: ConfigurationResultObject): ConfigurationResultObject;
+    abstract startToBuildFromConfigurator(data: ConfigurationResultObject): Promise<ConfigurationResultObject>;
+    abstract prepareSelectionsAndDecos(result: ConfigurationResultObject): Promise<ConfigurationResultObject>;
+    abstract createNonConfigurableFloor(result: ConfigurationResultObject): Promise<ConfigurationResultObject>;
+    abstract startToBuild(result?: ConfigurationResultObject, shouldCopyInstance?: boolean, looseOriginalConfiguration?: boolean, standAlone?: boolean, firstBuild?: boolean, fromPreset?: boolean, loadFromProject?: boolean): Promise<ConfigurationResultObject>;
+    emptyAnswerSelected(): void;
+    emptySelectionsSelected(): void;
+    getOptionsFromSelection(baseSelection: Selection): Selection[];
+    cancelConfiguringCurrentInstance(): void;
+    cancelAnswer(data: ConfigurationResultObject, rebuild?: boolean, getAnswers?: boolean): Promise<void>;
+    selectSelection(selection: Selection, data: ConfigurationResultObject, forceBackToNode?: boolean, after?: boolean, connector?: string): Promise<void>;
+    deleteSelection(selection: Selection, data: ConfigurationResultObject): Promise<void>;
+    replaceSelection(selection: Selection, data: ConfigurationResultObject): Promise<void>;
+    selectAnswer(answer: Answer, input: string, data: ConfigurationResultObject): Promise<void>;
+    selectSelectionAsAnswer(chosenOption: SelectorStructure, data: ConfigurationResultObject): Promise<void>;
+    linkSelectionsAndDecos(): void;
+    prepareTheSelections(instanceId?: string): void;
+    preloadMaterials(schema: string): void;
+    cleanUp(): void;
+    protected prepareInstanceForBuild(shouldCopyInstance: boolean, loadFromProject: boolean, looseOriginalConfiguration: boolean, result: ConfigurationResultObject): Promise<ConfigurationResultObject>;
+    protected getSelectionsAndDecos(): Promise<void>;
+    protected handlePrepareSelectionsDecos(result: ConfigurationResultObject): Promise<ConfigurationResultObject>;
+    protected normalizeMesh(mesh: Mesh): void;
+    protected setInstanceToConfigure(result: ConfigurationResultObject): Promise<ConfigurationResultObject>;
+    protected getSelectionsAndDecosFromMetadata(result: ConfigurationResultObject): void;
+    protected selectionPublished(selection: Selection): boolean;
+    protected cleanupBeforePresetLoad(): void;
+    protected handleAfterPresetLoad(): void;
+    protected cleanup(): void;
+    protected canConnectSelections(sel1: Selection, sel2: Selection): boolean;
+    protected handleAnswerSelected(answer: Answer): void;
+    protected handleSelectionSelected(chosenOption: SelectorStructure): void;
+    protected createConfigurableItem(itemName: string): Object3D;
+    protected cloneSelections(): Selection[];
+    protected updateBuildObject(newItem: Object3D, resultObject: ConfigurationResultObject): Promise<ConfigurationResultObject>;
+    protected saveElementConnector(element: Object3D, connector: string): void;
+    protected getIdentifierFromSelection(selection: Selection): string;
+    protected reset(): void;
+    protected getAdjustables(checkGameObject?: boolean, checkType?: boolean): Selection[];
+    protected getVariations(): any[];
+    protected loadVariations(item: Object3D, instanceId: string): Promise<void>;
+    protected preloadMaterial(answer: Answer): void;
+    protected preloadMaterialBySelection(answer: SelectorStructure): void;
+    protected buildFloor(result: any): Promise<void>;
+    downloadUDSZforARIOS(objects: Object3D[]): void;
+    private _setNeedMaterial;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BuildFurnitureBaseService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BuildFurnitureBaseService>;
 }
 
-declare class DebugService {
-    debugMessages: string[];
-    averageRenderTime: number;
-    lastTimestamp: number;
-    measurements: any[];
-    runTest: boolean;
-    addMessage(message: string): void;
-    measureRenderTime(): void;
-    resetMeasurements(): void;
-    startToggle(): void;
-    getAverageRenderTime(): number;
-    getFramesMeasuredAmount(): number;
-    static ɵfac: i0.ɵɵFactoryDeclaration<DebugService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<DebugService>;
+declare class BuildFurnitureService extends BuildFurnitureBaseService implements OnDestroy {
+    build(result: ConfigurationResultObject): Promise<ConfigurationResultObject>;
+    createNonConfigurableFloor(result: ConfigurationResultObject): Promise<ConfigurationResultObject>;
+    startToBuild(result?: ConfigurationResultObject, shouldCopyInstance?: boolean, looseOriginalConfiguration?: boolean, standAlone?: boolean, firstBuild?: boolean, fromPreset?: boolean, loadFromProject?: boolean): Promise<ConfigurationResultObject>;
+    createSimple3DModel(result: ConfigurationResultObject): ConfigurationResultObject;
+    startToBuildFromConfigurator(data: ConfigurationResultObject): Promise<ConfigurationResultObject>;
+    prepareSelectionsAndDecos(result: ConfigurationResultObject): Promise<ConfigurationResultObject>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BuildFurnitureService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BuildFurnitureService>;
 }
 
-declare class FontService {
-    hudFont: Font;
-    monospaceFont: Font;
-    constructor();
-    private _loadFont;
-    static ɵfac: i0.ɵɵFactoryDeclaration<FontService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<FontService>;
+declare class BuildFurnitureWithoutSceneService extends BuildFurnitureBaseService implements OnDestroy {
+    build(result: ConfigurationResultObject): Promise<ConfigurationResultObject>;
+    startToBuild(result?: ConfigurationResultObject, shouldCopyInstance?: boolean, looseOriginalConfiguration?: boolean, standAlone?: boolean, firstBuild?: boolean, fromPreset?: boolean, loadFromProject?: boolean): Promise<ConfigurationResultObject>;
+    startToBuildFromConfigurator(data: ConfigurationResultObject): Promise<ConfigurationResultObject>;
+    prepareSelectionsAndDecos(result: ConfigurationResultObject): Promise<ConfigurationResultObject>;
+    createSimple3DModel(result: ConfigurationResultObject, standAlone?: boolean): ConfigurationResultObject;
+    createNonConfigurableFloor(result: ConfigurationResultObject): Promise<ConfigurationResultObject>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BuildFurnitureWithoutSceneService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BuildFurnitureWithoutSceneService>;
 }
 
-declare class MessageBoardService {
+declare class SwitchBuildFurnitureService implements OnDestroy {
+    private _buildFurnitureService;
+    private _buildFurnitureWithoutSceneService;
     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>;
+    private _configuratorService;
+    currentActiveService: BuildFurnitureBaseService;
+    private _controllerInitSub;
+    private _standAloneInstance;
+    constructor(_buildFurnitureService: BuildFurnitureService, _buildFurnitureWithoutSceneService: BuildFurnitureWithoutSceneService, _settingsService: ConfiguratorSettingsService, _configuratorService: ConfiguratorConnectorService);
+    ngOnDestroy(): void;
+    cleanUp(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SwitchBuildFurnitureService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SwitchBuildFurnitureService>;
 }
 
-declare class XrService implements OnDestroy {
+declare class ThreedselectorService {
     private _settingsService;
-    private _debugService;
-    private _messageBoard;
-    gamepad: any;
-    axes: number[];
+    private _threedUtils;
+    constructor(_settingsService: ConfiguratorSettingsService);
+    downloadAssetsAndReturn(fileName: string, assetPath: string, prepareProgress?: boolean): Promise<THREE.Object3D>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ThreedselectorService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ThreedselectorService>;
+}
+
+declare enum ItemType {
+    Floor = 1,
+    Wall = 2,
+    InWall = 3,
+    InWallFloor = 7,
+    OnFloor = 8,
+    WallFloor = 9,
+    CustomFloorGroup = 10,
+    CustomShape = 11,
+    FloorGroup = 12,
+    ItemGroup = 13,
+    CustomCylinder = 14,
+    CustomCylinderWall = 15,
+    CustomShapeWall = 16,
+    CustomWall = 20,
+    CustomWallFloor = 21,
+    WallItemGroup = 22,
+    WallDecoration = 23,
+    WindowDecoration = 24,
+    FloorDecoration = 25
+}
+
+declare abstract class LoadFurnitureBaseService implements OnDestroy {
+    protected configuratorConnectorService: ConfiguratorConnectorService;
+    protected threedSelectorService: ThreedselectorService;
+    protected buildFurnitureService: SwitchBuildFurnitureService;
+    protected settingsService: ConfiguratorSettingsService;
+    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: ConfiguratorSettingsService);
+    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>;
+}
+
+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>;
+}
+
+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>;
+}
+
+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: ConfiguratorSettingsService, _iOne: ConfiguratorConnectorService);
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SwitchLoadFurnitureService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SwitchLoadFurnitureService>;
+}
+
+declare class ConfiguratorCameraService implements OnDestroy {
+    private _settingsService;
+    readonly panSpeed: number;
+    readonly rotateBy: number;
+    readonly moveBy: number;
+    readonly cameraDefaultHeight: number;
+    readonly targetDefaultOffset: number;
+    readonly exploreDistanceFromCorner: number;
+    camera: PerspectiveCamera;
+    controls: any;
+    cameraMovementChanged: Subject<void>;
+    addTweenGroup: Subject<Group>;
+    removeTweenGroup: Subject<Group>;
+    private _cameraLocked;
+    private _element;
+    private _viewSize;
+    private _viewCenter;
+    private _exploreTargetDistance;
+    private _realAspectRatio;
+    private _aspectRatio;
+    private _subs;
+    get cameraLocked(): boolean;
+    set realAspectRatio(value: number);
+    constructor(_settingsService: ConfiguratorSettingsService);
+    ngOnDestroy(): void;
+    init(element: HTMLElement): void;
+    cameraZoomIn(): void;
+    cameraZoomOut(): void;
+    lockCamera(): void;
+    unlockCamera(): void;
+    disableRotate(): void;
+    disableRotateHorizontal(): void;
+    disablePan(): void;
+    disableZoom(): void;
+    moveCameraToFitObject(object: any, offset?: number): Promise<void>;
+    private _getCameraOffset;
+    private _controlsUpdate;
+    private _addTweenGroup;
+    private _removeTweenGroup;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfiguratorCameraService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ConfiguratorCameraService>;
+}
+
+declare enum XrMode {
+    ArMode = "Ar Mode",
+    VrMode = "Vr Mode"
+}
+
+declare class DebugService {
+    debugMessages: string[];
+    averageRenderTime: number;
+    lastTimestamp: number;
+    measurements: any[];
+    runTest: boolean;
+    addMessage(message: string): void;
+    measureRenderTime(): void;
+    resetMeasurements(): void;
+    startToggle(): void;
+    getAverageRenderTime(): number;
+    getFramesMeasuredAmount(): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DebugService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DebugService>;
+}
+
+declare class FontService {
+    hudFont: Font;
+    monospaceFont: Font;
+    constructor();
+    private _loadFont;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FontService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FontService>;
+}
+
+declare class MessageBoardService {
+    private _settingsService;
+    private _fontService;
+    scene: Scene;
+    board: Mesh;
+    messages: Mesh[];
+    private _font;
+    constructor(_settingsService: ConfiguratorSettingsService, _fontService: FontService);
+    init(scene: Scene): Promise<void>;
+    addMessage(message: string): void;
+    private _createMessageBoard;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MessageBoardService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MessageBoardService>;
+}
+
+declare class ConfiguratorXrService implements OnDestroy {
+    private _settingsService;
+    private _debugService;
+    private _messageBoard;
+    gamepad: any;
+    axes: number[];
     touchpadIsPressed: boolean;
     triggerIsPressed: boolean;
     angularVelocity: THREE.Vector3;
@@ -801,7 +822,7 @@ declare class XrService implements OnDestroy {
     private _subs;
     private _cameraHeight;
     private _mode;
-    constructor(_settingsService: SettingsService, _debugService: DebugService, _messageBoard: MessageBoardService);
+    constructor(_settingsService: ConfiguratorSettingsService, _debugService: DebugService, _messageBoard: MessageBoardService);
     ngOnDestroy(): void;
     init(renderer: WebGLRenderer, scene: Scene, camera: Camera): Promise<void>;
     startAr(): void;
@@ -818,11 +839,11 @@ declare class XrService implements OnDestroy {
     private _findGamepad;
     private _createController;
     private _createMeshes;
-    static ɵfac: i0.ɵɵFactoryDeclaration<XrService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<XrService>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfiguratorXrService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ConfiguratorXrService>;
 }
 
-declare class VrService {
+declare class ConfiguratorVrService {
     private _scene;
     private _renderer;
     private _camera;
@@ -859,11 +880,11 @@ declare class VrService {
     private _isObjectFloor;
     private _getParentOfChild;
     private _updateObjectSelection;
-    static ɵfac: i0.ɵɵFactoryDeclaration<VrService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<VrService>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfiguratorVrService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ConfiguratorVrService>;
 }
 
-declare class ArService implements OnDestroy {
+declare class ConfiguratorArService implements OnDestroy {
     private _cameraService;
     private _settingsService;
     private _iOne;
@@ -913,7 +934,7 @@ declare class ArService implements OnDestroy {
     private _sunLight;
     private _positionIndicator;
     private _pointRepresentation;
-    constructor(_cameraService: CameraService, _settingsService: SettingsService, _iOne: ConfiguratorConnectorService);
+    constructor(_cameraService: ConfiguratorCameraService, _settingsService: ConfiguratorSettingsService, _iOne: ConfiguratorConnectorService);
     ngOnDestroy(): void;
     resetPlaneDetection(): Promise<void>;
     endSessionEvent(): void;
@@ -973,235 +994,41 @@ declare class ArService implements OnDestroy {
     private _updateMeshMaterials;
     private _removeMaterialShaders;
     private _checkingInterfaceInteraction;
-    static ɵfac: i0.ɵɵFactoryDeclaration<ArService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<ArService>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfiguratorArService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ConfiguratorArService>;
 }
 
-declare enum ConfigurationKey {
-    DimensioningUnit = "dimUnit",
-    DimensioningSquareUnit = "dimSqUnit",
-    AngleUnit = "angleUnit",
-    CmStep = "cmStep",
-    MStep = "mStep",
-    MmStep = "mmStep",
-    AngleLabelDistanceInCm = "angleLabelDistanceCm",
-    WallHeight = "wallHeight",
-    WallThickness = "wallThickness",
-    MaxWallHeight = "maxWallHeight",
-    MaxWallThickness = "maxWallThickness",
-    MaxWallLength = "maxWallLength",
-    MinWallLength = "minWallLength",
-    WallSnapping = "wallSnapping",
-    CornerSnapping = "cornerSnapping",
-    ShowObjectDistances = "showObjectDistances",
-    ShowObjectMeasurements = "showObjectMeasurements",
-    ShowDetailedWallMeasurements = "showDetailedWallMeasurements",
-    ShowWallItemMeasurements = "showWallItemMeasurements",
-    ShowWallMeasurements = "showWallMeasurements",
-    ShowCornerAngles = "showCornerAngles",
-    RotationSnappingEnabled = "RotationSnappingEnabled",
-    DisplayCustomShapeNames = "DisplayCustomShapeNames",
-    ShowWalkThroughCameraControls = "ShowWalkThroughCameraControls",
-    ShowInteriorLights = "ShowInteriorLights",
-    InteriorLightIntensity = "InteriorLightIntensity",
-    ShowLightingControls = "ShowLightingControls",
-    ShowLightplansDialog = "ShowLightplansDialog",
-    WalkThroughCameraFoV = "WalkThroughCameraFoV",
-    WalkThroughCameraAspectRatio = "WalkThroughCameraAspectRatio",
-    WalkThroughCameraFocus = "WalkThroughCameraFocus",
-    ShowPostProcessingSettings = "showPostProcessingSettings",
-    ShowWalls = "ShowWalls",
-    ShowCeiling = "ShowCeiling",
-    IsLimited = "IsLimited",
-    EnableTouch = "EnableTouch",
-    CameraFOV = "CameraFOV"
+declare enum ViewMode {
+    RoomPlan3D = "3D roomplan",
+    VR = "VR",
+    AR = "AR"
 }
 
-interface ConfigurationData {
-    [ConfigurationKey.DimensioningUnit]?: string;
-    [ConfigurationKey.DimensioningSquareUnit]?: string;
-    [ConfigurationKey.AngleUnit]?: string;
-    [ConfigurationKey.CmStep]?: number;
-    [ConfigurationKey.MStep]?: number;
-    [ConfigurationKey.MmStep]?: number;
-    [ConfigurationKey.AngleLabelDistanceInCm]?: number;
-    [ConfigurationKey.WallHeight]?: number;
-    [ConfigurationKey.WallThickness]?: number;
-    [ConfigurationKey.MaxWallHeight]?: number;
-    [ConfigurationKey.MaxWallThickness]?: number;
-    [ConfigurationKey.MaxWallLength]?: number;
-    [ConfigurationKey.MinWallLength]?: number;
-    [ConfigurationKey.WallSnapping]?: boolean;
-    [ConfigurationKey.CornerSnapping]?: boolean;
-    [ConfigurationKey.ShowObjectDistances]?: boolean;
-    [ConfigurationKey.ShowObjectMeasurements]?: boolean;
-    [ConfigurationKey.ShowDetailedWallMeasurements]?: boolean;
-    [ConfigurationKey.ShowWallItemMeasurements]?: boolean;
-    [ConfigurationKey.ShowWallMeasurements]?: boolean;
-    [ConfigurationKey.ShowCornerAngles]?: boolean;
-    [ConfigurationKey.RotationSnappingEnabled]?: boolean;
-    [ConfigurationKey.DisplayCustomShapeNames]?: boolean;
-    [ConfigurationKey.ShowInteriorLights]?: boolean;
-    [ConfigurationKey.InteriorLightIntensity]?: number;
-    [ConfigurationKey.ShowWalkThroughCameraControls]?: boolean;
-    [ConfigurationKey.ShowLightingControls]?: boolean;
-    [ConfigurationKey.ShowLightplansDialog]?: boolean;
-    [ConfigurationKey.WalkThroughCameraFoV]?: number;
-    [ConfigurationKey.WalkThroughCameraAspectRatio]?: number;
-    [ConfigurationKey.WalkThroughCameraFocus]?: number;
-    [ConfigurationKey.ShowPostProcessingSettings]?: boolean;
-    [ConfigurationKey.ShowWalls]?: boolean;
-    [ConfigurationKey.ShowCeiling]?: boolean;
-    [ConfigurationKey.IsLimited]?: boolean;
-    [ConfigurationKey.EnableTouch]?: boolean;
-    [ConfigurationKey.CameraFOV]?: number;
+declare class ViewModeService {
+    viewModeChanged: BehaviorSubject<ViewMode>;
+    private _viewMode;
+    viewSize: Vector3;
+    viewCenter: Vector3;
+    set viewMode(value: ViewMode);
+    get viewMode(): ViewMode;
+    setViewMode(viewSize: Vector3, viewCenter: Vector3, mode: ViewMode): void;
+    is3dViewActive(): boolean;
+    isVRViewActive(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ViewModeService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ViewModeService>;
 }
 
-declare class ConfigurationService {
-    private _data;
-    onChange: BehaviorSubject<{}>;
-    setValue<T extends ConfigurationKey>(key: T, value: ConfigurationData[T]): void;
-    getValue<T extends ConfigurationKey>(key: T): ConfigurationData[T];
-    get(): ConfigurationData;
-    set(data: ConfigurationData): void;
-    getDistanceStep(): number;
-    static ɵfac: i0.ɵɵFactoryDeclaration<ConfigurationService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<ConfigurationService>;
-}
-
-declare enum DeviceSizeType {
-    Desktop = "desktop",
-    Tablet = "tablet",
-    Phone = "phone"
-}
-
-interface ScreenSizeInfo {
-    width: number;
-    height: number;
-    deviceSizeType: DeviceSizeType;
-    isDesktopSize: boolean;
-    isTabletSize: boolean;
-    isPhoneSize: boolean;
-    isPortraitMode: boolean;
-}
-
-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>;
-}
-
-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>;
-}
-
-declare enum ViewMode {
-    RoomPlan3D = "3D roomplan",
-    VR = "VR",
-    AR = "AR"
-}
-
-declare class ViewModeService {
-    viewModeChanged: BehaviorSubject<ViewMode>;
-    private _viewMode;
-    viewSize: Vector3;
-    viewCenter: Vector3;
-    set viewMode(value: ViewMode);
-    get viewMode(): ViewMode;
-    setViewMode(viewSize: Vector3, viewCenter: Vector3, mode: ViewMode): void;
-    is3dViewActive(): boolean;
-    isVRViewActive(): boolean;
-    static ɵfac: i0.ɵɵFactoryDeclaration<ViewModeService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<ViewModeService>;
-}
-
-declare class SceneService implements OnDestroy {
+declare class ConfiguratorSceneService implements OnDestroy {
     private _cameraService;
     private _xrService;
     private _vrService;
     private _arService;
-    private _settingsService;
-    private _postProcessing;
+    private _configuratorSettingsService;
+    private _postProcessingService;
     private _viewModeService;
+    private _jsonUtilsService;
+    private _lightsService;
+    private _buildFurnitureService;
     set needsRender(value: boolean);
     get needsRender(): boolean;
     scene: Scene;
@@ -1220,12 +1047,18 @@ declare class SceneService implements OnDestroy {
     renderingThroughPostProcessingPipeline: boolean;
     webGL2Available: boolean;
     domElement: HTMLElement;
+    floorTexturesLoaded: BehaviorSubject<TextureInterface$1[]>;
     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);
+    private _assetPath;
+    private _indexJsonFile;
+    private _lightPresetsJsonFile;
+    private _lightsLoaded;
+    private _groups;
+    constructor(_cameraService: ConfiguratorCameraService, _xrService: ConfiguratorXrService, _vrService: ConfiguratorVrService, _arService: ConfiguratorArService, _configuratorSettingsService: ConfiguratorSettingsService, _postProcessingService: PostProcessingService, _viewModeService: ViewModeService, _jsonUtilsService: JsonUtilsService, _lightsService: LightsService, _buildFurnitureService: SwitchBuildFurnitureService);
     ngOnDestroy(): void;
     getScene(): Scene;
     set arMode(value: boolean);
@@ -1238,9 +1071,12 @@ declare class SceneService implements OnDestroy {
     updatePathTracer(): void;
     positionInSceneToScreen(pos: Vector3): Vector2;
     rendererPropsChange(): void;
+    private _handleAddTweenGroup;
+    private _handleRemoveTweenGroup;
     private _initScene;
     private _initCamera;
     private _initPostProcessing;
+    private _initLightService;
     private _initPathTracer;
     private _initRenderer;
     private _resizeRendererToDisplaySize;
@@ -1249,292 +1085,198 @@ declare class SceneService implements OnDestroy {
     private _render;
     private _animate;
     private _pauseAnimation;
+    private _prepareScene;
     private _setSceneBackground;
-    static ɵfac: i0.ɵɵFactoryDeclaration<SceneService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<SceneService>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfiguratorSceneService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ConfiguratorSceneService>;
 }
 
-declare class ItemService implements OnDestroy {
+declare class ConfiguratorItemService implements OnDestroy {
     private _sceneService;
     get sceneItems(): Object3D[];
     private _sceneItems;
-    constructor(_sceneService: SceneService);
+    constructor(_sceneService: ConfiguratorSceneService);
     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>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfiguratorItemService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ConfiguratorItemService>;
 }
 
-declare class UtilsService implements OnDestroy {
-    private _settingsService;
-    private _progressService;
-    private _itemService;
-    clips: any;
-    private _objectCache;
-    private _subs;
-    constructor(_settingsService: SettingsService, _progressService: ProgressService, _itemService: ItemService);
-    ngOnDestroy(): void;
-    createCanvasImage(thumbnail?: boolean): string;
-    loadObjModel(filePath: string, mtlUrl?: string): Promise<any>;
-    downloadUSDZforARIOS(object: Object3D): Promise<void>;
-    private _addGroupChildrenToObject;
-    private _handleUpdateProgressBar;
-    static ɵfac: i0.ɵɵFactoryDeclaration<UtilsService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<UtilsService>;
+declare class RenderResponse {
+    result: string;
+    statusCode: number;
 }
 
-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>;
+declare enum BlenderRenderType {
+    Realtime = 0,
+    Raytrace = 1
 }
 
-declare class VariationService {
-    private _threedSelectorService;
-    loadedAsset: string;
-    private _lastKnownVariations;
-    constructor(_threedSelectorService: ThreedselectorService);
-    clearCache(): void;
-    loadPart(assetPath: string, parts: any[], instanceId: string, obj: Object3D, usePbr?: boolean): Promise<void>;
-    loadVariation(assetPath: string, parts: any[], instanceId: string, obj: Object3D, usePbr?: boolean): Promise<void>;
-    loadVariationFromLocalFile(id: string, file: any, obj: Object3D): Promise<void>;
-    loadVariationForMaterial(gameObject: string): Promise<any>;
-    loadVariationByAssetUrl(assetUrl: string): Promise<any>;
-    createVariationForMaterialPreview(compressedZip: Blob): Promise<any>;
-    private _applyMaterialPart;
-    private _applyVariations;
-    private _applyMaterial;
-    private _setMeshMaterialFromVariation;
-    private _setLastKnownVariations;
-    private _getLastKnownVariations;
-    private _getChildrenFilterByProp;
-    private _createVariationFromNode;
-    static ɵfac: i0.ɵɵFactoryDeclaration<VariationService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<VariationService>;
+declare class OptionalRenderSettings {
+    objectWidth: number;
+    objectHeight: number;
+    renderType: number | BlenderRenderType;
+    objectRotation: any;
+    margin: number;
+    cameraRotationX: number;
+    forceTransparency: boolean;
 }
 
-declare abstract class BuildFurnitureBaseService implements OnDestroy {
-    protected configuratorConnectorService: ConfiguratorConnectorService;
-    protected dictionaryService: DictionaryService;
-    protected appEventService: AppEventService;
-    protected settingsService: SettingsService;
-    protected variationService: VariationService;
-    protected variationCacheService: VariationCacheService;
-    protected utilsService: UtilsService;
-    protected itemService: ItemService;
-    get useNodeIdToLink(): boolean;
-    get currentCustomFloorGroup(): Object3D;
-    set currentCustomFloorGroup(item: Object3D);
-    get selections(): Selection[];
-    set scene(scene: Scene);
-    get scene(): Scene;
-    defaultPosition: Vector3;
-    defaultRotation: Euler;
-    baseElementNodeId: number;
-    articleAssetPath: string;
-    startPosition: Vector3;
-    full3DObjectToUse: Object3D;
-    isMouseOverObject: boolean;
-    activeConnector: any;
-    answerSelected: Subject<ConfigurationResultObject>;
-    arPlacementUpdate: Subject<boolean>;
-    showElementToolbar: boolean;
-    private _useNodeIdToLink;
-    private _activeChildElement;
-    private _placedAddables;
-    private _adjustables;
-    private _addables;
-    private _currentCustomFloorGroup;
-    private _genericSelection;
-    private _answerSelected;
-    private _selectionsSelected;
-    private _scene;
-    protected subs: Subscription[];
-    protected placedAdjustables: any[];
-    constructor(configuratorConnectorService: ConfiguratorConnectorService, dictionaryService: DictionaryService, appEventService: AppEventService, settingsService: SettingsService, variationService: VariationService, variationCacheService: VariationCacheService, utilsService: UtilsService, itemService: ItemService);
-    ngOnDestroy(): void;
-    abstract build(result: ConfigurationResultObject): Promise<ConfigurationResultObject>;
-    abstract createSimple3DModel(result: ConfigurationResultObject): ConfigurationResultObject;
-    abstract startToBuildFromConfigurator(data: ConfigurationResultObject): Promise<ConfigurationResultObject>;
-    abstract prepareSelectionsAndDecos(result: ConfigurationResultObject): Promise<ConfigurationResultObject>;
-    abstract createNonConfigurableFloor(result: ConfigurationResultObject): Promise<ConfigurationResultObject>;
-    abstract startToBuild(result?: ConfigurationResultObject, shouldCopyInstance?: boolean, looseOriginalConfiguration?: boolean, standAlone?: boolean, firstBuild?: boolean, fromPreset?: boolean, loadFromProject?: boolean): Promise<ConfigurationResultObject>;
-    emptyAnswerSelected(): void;
-    emptySelectionsSelected(): void;
-    getOptionsFromSelection(baseSelection: Selection): Selection[];
-    cancelConfiguringCurrentInstance(): void;
-    cancelAnswer(data: ConfigurationResultObject, rebuild?: boolean, getAnswers?: boolean): Promise<void>;
-    selectSelection(selection: Selection, data: ConfigurationResultObject, forceBackToNode?: boolean, after?: boolean, connector?: string): Promise<void>;
-    deleteSelection(selection: Selection, data: ConfigurationResultObject): Promise<void>;
-    replaceSelection(selection: Selection, data: ConfigurationResultObject): Promise<void>;
-    selectAnswer(answer: Answer, input: string, data: ConfigurationResultObject): Promise<void>;
-    selectSelectionAsAnswer(chosenOption: SelectorStructure, data: ConfigurationResultObject): Promise<void>;
-    linkSelectionsAndDecos(): void;
-    prepareTheSelections(instanceId?: string): void;
-    preloadMaterials(schema: string): void;
-    protected prepareInstanceForBuild(shouldCopyInstance: boolean, loadFromProject: boolean, looseOriginalConfiguration: boolean, result: ConfigurationResultObject): Promise<ConfigurationResultObject>;
-    protected getSelectionsAndDecos(): Promise<void>;
-    protected handlePrepareSelectionsDecos(result: ConfigurationResultObject): Promise<ConfigurationResultObject>;
-    protected normalizeMesh(mesh: Mesh): void;
-    protected setInstanceToConfigure(result: ConfigurationResultObject): Promise<ConfigurationResultObject>;
-    protected getSelectionsAndDecosFromMetadata(result: ConfigurationResultObject): void;
-    protected selectionPublished(selection: Selection): boolean;
-    protected cleanupBeforePresetLoad(): void;
-    protected handleAfterPresetLoad(): void;
-    protected cleanup(): void;
-    protected canConnectSelections(sel1: Selection, sel2: Selection): boolean;
-    protected handleAnswerSelected(answer: Answer): void;
-    protected handleSelectionSelected(chosenOption: SelectorStructure): void;
-    protected createConfigurableItem(itemName: string): Object3D;
-    protected cloneSelections(): Selection[];
-    protected updateBuildObject(newItem: Object3D, resultObject: ConfigurationResultObject): Promise<ConfigurationResultObject>;
-    protected isMoveableObject(obj: Object3D): boolean;
-    protected addElementOnConnector(currentItem: Object3D, element: Object3D, connector: string, connectedNodeId: number): Promise<void>;
-    protected saveElementConnector(element: Object3D, connector: string): void;
-    protected getIdentifierFromSelection(selection: Selection): string;
-    protected reset(): void;
-    /**
-     * Returns the materialId of the parent up the tree until presentionlevel 1 is reached
-     * @param id
-     * @private
-     */
-    protected getMaterialIdFromParent(id: number): string;
-    protected getAdjustables(checkGameObject?: boolean, checkType?: boolean): Selection[];
-    protected getVariations(): any[];
-    protected createAdjustable(item: Object3D, adj: Selection): Object3D;
-    protected createAddable(item: Object3D, add: Selection, part2?: any, part1?: any): Object3D;
-    protected placeAddable(item: Object3D, add: any): Object3D;
-    protected createUniqueName(item: Object3D, obj: Object3D): string;
-    protected placeAddables(item: Object3D): void;
-    protected loadVariations(item: Object3D, instanceId: string): Promise<void>;
-    protected preloadMaterial(answer: Answer): void;
-    protected preloadMaterialBySelection(answer: SelectorStructure): void;
-    protected buildFloor(result: any): Promise<void>;
-    downloadUDSZforARIOS(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<BuildFurnitureBaseService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<BuildFurnitureBaseService>;
+declare class RenderBaseObject {
+    selections: Selection[];
+    decos: DecoNode[];
+    assetUrl: string;
+    cdnUrl: string;
+    schema: string;
+    options: any;
 }
 
-declare class BuildFurnitureService extends BuildFurnitureBaseService implements OnDestroy {
-    build(result: ConfigurationResultObject): Promise<ConfigurationResultObject>;
-    createNonConfigurableFloor(result: ConfigurationResultObject): Promise<ConfigurationResultObject>;
-    startToBuild(result?: ConfigurationResultObject, shouldCopyInstance?: boolean, looseOriginalConfiguration?: boolean, standAlone?: boolean, firstBuild?: boolean, fromPreset?: boolean, loadFromProject?: boolean): Promise<ConfigurationResultObject>;
-    createSimple3DModel(result: ConfigurationResultObject): ConfigurationResultObject;
-    startToBuildFromConfigurator(data: ConfigurationResultObject): Promise<ConfigurationResultObject>;
-    prepareSelectionsAndDecos(result: ConfigurationResultObject): Promise<ConfigurationResultObject>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<BuildFurnitureService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<BuildFurnitureService>;
+declare class RenderApi {
+    private _settingsService;
+    private _overWriteTransparency;
+    constructor(_settingsService: ConfiguratorSettingsService);
+    prepareGlbRender(buildResult: ConfigurationResultObject, object3dPosition: Vector3, object3dRotation: Vector3, cameraFov?: number, forceNewRender?: boolean, optionalRenderParameters?: OptionalRenderSettings): RenderBaseObject;
+    sendRenderRequest(data: RenderBaseObject): Promise<RenderResponse>;
+    degreesToVector3(value: number): Vector3;
+    private _adjustCameraRotation;
+    private _getSceneRenderSettings;
+    private _useTransparency;
+    private _setForceTransparency;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RenderApi, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RenderApi>;
 }
 
-declare class BuildFurnitureWithoutSceneService extends BuildFurnitureBaseService implements OnDestroy {
-    build(result: ConfigurationResultObject): Promise<ConfigurationResultObject>;
-    startToBuild(result?: ConfigurationResultObject, shouldCopyInstance?: boolean, looseOriginalConfiguration?: boolean, standAlone?: boolean, firstBuild?: boolean, fromPreset?: boolean, loadFromProject?: boolean): Promise<ConfigurationResultObject>;
-    startToBuildFromConfigurator(data: ConfigurationResultObject): Promise<ConfigurationResultObject>;
-    prepareSelectionsAndDecos(result: ConfigurationResultObject): Promise<ConfigurationResultObject>;
-    createSimple3DModel(result: ConfigurationResultObject, standAlone?: boolean): ConfigurationResultObject;
-    createNonConfigurableFloor(result: ConfigurationResultObject): Promise<ConfigurationResultObject>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<BuildFurnitureWithoutSceneService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<BuildFurnitureWithoutSceneService>;
+declare class RenderService implements OnDestroy {
+    private _settingsService;
+    private _cameraService;
+    private _appEventService;
+    private _sceneService;
+    private _renderApi;
+    blenderRenderStarted: EventEmitter<string>;
+    clientWidth: number;
+    clientHeight: number;
+    private _subs;
+    constructor(_settingsService: ConfiguratorSettingsService, _cameraService: ConfiguratorCameraService, _appEventService: ConfiguratorEventService, _sceneService: ConfiguratorSceneService, _renderApi: RenderApi);
+    ngOnDestroy(): void;
+    renderImage(buildResult: ConfigurationResultObject, optionalRenderParameters?: any, forceNewRender?: boolean): void;
+    getNewGlbFromServer(buildResult: ConfigurationResultObject, optionalRenderParameters?: any, forceNewRender?: boolean): void;
+    private _handleAjaxGlb;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RenderService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RenderService>;
 }
 
-declare class SwitchBuildFurnitureService implements OnDestroy {
+declare class ConfiguringService implements OnDestroy {
+    settingsService: ConfiguratorSettingsService;
+    private _loadFurnitureService;
     private _buildFurnitureService;
-    private _buildFurnitureWithoutSceneService;
-    private _settingsService;
-    private _configuratorService;
-    currentActiveService: BuildFurnitureBaseService;
-    private _controllerInitSub;
-    private _standAloneInstance;
-    constructor(_buildFurnitureService: BuildFurnitureService, _buildFurnitureWithoutSceneService: BuildFurnitureWithoutSceneService, _settingsService: SettingsService, _configuratorService: ConfiguratorConnectorService);
+    private _appEventService;
+    private _configuratorConnectorService;
+    private _itemService;
+    private _utilsService;
+    private _renderService;
+    set sku(value: string);
+    get sku(): string;
+    set instanceId(value: string);
+    get instanceId(): string;
+    set scene(value: Scene);
+    get scene(): Scene;
+    buildResult: ConfigurationResultObject;
+    private _sku;
+    private _instanceId;
+    private _scene;
+    private _subs;
+    constructor(settingsService: ConfiguratorSettingsService, _loadFurnitureService: SwitchLoadFurnitureService, _buildFurnitureService: SwitchBuildFurnitureService, _appEventService: ConfiguratorEventService, _configuratorConnectorService: ConfiguratorConnectorService, _itemService: ConfiguratorItemService, _utilsService: UtilsService, _renderService: RenderService);
     ngOnDestroy(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<SwitchBuildFurnitureService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<SwitchBuildFurnitureService>;
+    configure(furnitureData: ConfigurationResultObject, shouldCopyInstance?: boolean, looseOriginalConfiguration?: boolean, fromPreset?: boolean, standAlone?: boolean, fromScratch?: boolean, loadFromProject?: boolean): Promise<void>;
+    renderImage(buildResult: ConfigurationResultObject, optionalRenderParameters?: any, forceNewRender?: boolean): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfiguringService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ConfiguringService>;
 }
 
-declare enum ItemType {
-    Floor = 1,
-    Wall = 2,
-    InWall = 3,
-    InWallFloor = 7,
-    OnFloor = 8,
-    WallFloor = 9,
-    CustomFloorGroup = 10,
-    CustomShape = 11,
-    FloorGroup = 12,
-    ItemGroup = 13,
-    CustomCylinder = 14,
-    CustomCylinderWall = 15,
-    CustomShapeWall = 16,
-    CustomWall = 20,
-    CustomWallFloor = 21,
-    WallItemGroup = 22,
-    WallDecoration = 23,
-    WindowDecoration = 24,
-    FloorDecoration = 25
-}
-
-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>;
+declare class ConfiguratorComponent implements OnInit, OnDestroy {
+    settingsService: ConfiguratorSettingsService;
+    loaderService: LoaderService;
+    private _configuratorEventService;
+    private _configuringService;
+    private _buildFurnitureService;
+    private _configuratorConnectorService;
+    showClass: boolean;
+    set sku(value: string);
+    get sku(): string;
+    set instanceId(value: string);
+    get instanceId(): string;
+    set settings(value: ConfiguratorSettings);
+    scene: Scene;
+    showLoader: boolean;
+    showProgressBar: boolean;
+    showErrorMessages: boolean;
+    outputErrorMessages: boolean;
+    canCloseConfigurator: boolean;
+    animateSlideout: boolean;
+    showHeaderInformation: boolean;
+    isLoading: EventEmitter<boolean>;
+    updateProgressBar: EventEmitter<boolean>;
+    errorMessages: EventEmitter<ConfiguratorErrorMessage[]>;
+    showChange: EventEmitter<boolean>;
+    resultHasErrors: boolean;
+    showErrorDiagram: boolean;
+    configurationResultObject: ConfigurationResultObject;
+    showFullConfiguration: boolean;
+    showLiteSelector: boolean;
+    showSelections: boolean;
+    showAnswers: boolean;
+    loaded: boolean;
     private _subs;
-    private _article;
-    protected constructor(configuratorConnectorService: ConfiguratorConnectorService, threedSelectorService: ThreedselectorService, buildFurnitureService: SwitchBuildFurnitureService, settingsService: SettingsService);
+    private _loadingFromPreset;
+    private _settings;
+    private _instanceId;
+    private _instanceIdSet;
+    private _sku;
+    private _skuSet;
+    constructor(settingsService: ConfiguratorSettingsService, loaderService: LoaderService, _configuratorEventService: ConfiguratorEventService, _configuringService: ConfiguringService, _buildFurnitureService: SwitchBuildFurnitureService, _configuratorConnectorService: ConfiguratorConnectorService);
+    ngOnInit(): void;
     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>;
+    _initConnection(): void;
+    handleShowChange(show: boolean): void;
+    handleCloseErrorDialog(): void;
+    private _handleArticleNotFound;
+    private _handleAnswerCountReceived;
+    private _handleBuildFinished;
+    private _handleTemplateChange;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfiguratorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ConfiguratorComponent, "co-configurator", never, { "sku": { "alias": "sku"; "required": false; }; "instanceId": { "alias": "instanceId"; "required": false; }; "settings": { "alias": "settings"; "required": false; }; "scene": { "alias": "scene"; "required": false; }; "showLoader": { "alias": "showLoader"; "required": false; }; "showProgressBar": { "alias": "showProgressBar"; "required": false; }; "showErrorMessages": { "alias": "showErrorMessages"; "required": false; }; "outputErrorMessages": { "alias": "outputErrorMessages"; "required": false; }; "canCloseConfigurator": { "alias": "canCloseConfigurator"; "required": false; }; "animateSlideout": { "alias": "animateSlideout"; "required": false; }; "showHeaderInformation": { "alias": "showHeaderInformation"; "required": false; }; }, { "isLoading": "isLoading"; "updateProgressBar": "updateProgressBar"; "errorMessages": "errorMessages"; "showChange": "showChange"; }, never, never, false, never>;
 }
 
-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>;
+declare class ProgressBarComponent {
+    progressService: ProgressService;
+    showClass(): boolean;
+    get showBar(): boolean;
+    constructor(progressService: ProgressService);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProgressBarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ProgressBarComponent, "co-progress-bar", never, {}, {}, never, never, false, never>;
 }
 
-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>;
+declare class ProgressBarModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProgressBarModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ProgressBarModule, [typeof ProgressBarComponent], [typeof i3.CommonModule], [typeof ProgressBarComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ProgressBarModule>;
 }
 
-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>;
+declare class ConfiguratorLoaderComponent {
+    showClass(): boolean;
+    show: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfiguratorLoaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ConfiguratorLoaderComponent, "co-configurator-loader", never, { "show": { "alias": "show"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class ConfiguratorLoaderModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfiguratorLoaderModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ConfiguratorLoaderModule, [typeof ConfiguratorLoaderComponent], [typeof i3$1.LoaderModule, typeof i3$1.IconModule, typeof i3.CommonModule], [typeof ConfiguratorLoaderComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ConfiguratorLoaderModule>;
 }
 
 /** AUTO GENERATED FILE. DO NOT CHANGE.. **/
@@ -1654,783 +1396,84 @@ declare enum IconEnum {
     XmarkRegular = "xmark_regular"
 }
 
-declare class SceneOptionButtonInterface {
-    id: number;
-    elementId: string;
-    label?: string;
-    class?: string;
-    tooltip?: string;
-    image?: string | SafeHtml;
-    order?: number;
-    toggle?: boolean;
-    tooltipActive?: string;
-    active?: boolean;
-    object?: any;
-    click?: Function;
-    show?: boolean;
-    icon?: IconEnum;
-    children?: SceneOptionButtonInterface[];
-}
-
-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>;
+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>;
 }
 
-declare enum TextureType {
-    Basic = 0,
-    Image = 1,
-    CustomPattern = 2,
-    PBR = 3,
-    SHADOW = 4
+declare class ConfiguratorErrorDialogComponent {
+    iconService: IconCacheService;
+    showClass(): boolean;
+    readonly icons: typeof IconEnum;
+    errorMessages: ConfiguratorErrorMessage[];
+    closeErrorDialoag: EventEmitter<void>;
+    onClose(): void;
+    constructor(iconService: IconCacheService);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfiguratorErrorDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ConfiguratorErrorDialogComponent, "co-configurator-error-dialog", never, { "errorMessages": { "alias": "errorMessages"; "required": false; }; }, { "closeErrorDialoag": "closeErrorDialoag"; }, never, never, false, never>;
 }
 
-interface TextureInterface {
-    name?: string;
-    type?: string | TextureType;
-    url?: string;
-    materializeUrl?: string;
-    bumpMap?: string;
-    bumpScale?: number;
-    roughness?: number;
-    roughnessMap?: string;
-    normalMap?: string;
-    alphaMap?: string;
-    repeatX?: number;
-    repeatY?: number;
-    metalness?: number;
-    metalnessMap?: string;
-    aoMapIntensity?: number;
-    aoMap?: string;
-    data?: any;
-    color?: string;
-    emissive?: string;
-    show?: boolean;
-    default?: boolean;
-    surfaces?: string[];
-    offset?: THREE.Vector2;
-    scale?: number;
-    rotation?: number;
-    stretch?: boolean;
-    height?: number;
-    width?: number;
-    tileSize?: number;
-    tileRotation?: number;
-    useStandalone?: boolean;
-    defaultStandalone?: boolean;
-    mirror?: boolean;
-    simplePlane?: boolean;
-    toneMapped?: boolean;
-    transparent?: boolean;
-    opacity?: number;
-    side?: number;
-    depthWrite?: boolean;
-    depthTest?: boolean;
+declare class ConfiguratorExportDialogComponent {
+    iconService: IconCacheService;
+    itemService: ConfiguratorItemService;
+    private _utilService;
+    readonly icons: typeof IconEnum;
+    closeExportDialog: EventEmitter<void>;
+    constructor(iconService: IconCacheService, itemService: ConfiguratorItemService, _utilService: UtilsService);
+    onClose(): void;
+    downloadGLB(): void;
+    downloadUSDZ(): void;
+    downloadBoth(): void;
+    downloadThumbnail(): void;
+    private _getObjectToExport;
+    private _download3DModelAsGLB;
+    private _download3DModelAsUSDZ;
+    private _downloadFile;
+    private _base64ToBlob;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfiguratorExportDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ConfiguratorExportDialogComponent, "co-configurator-export-dialog", never, {}, { "closeExportDialog": "closeExportDialog"; }, never, never, false, never>;
 }
 
-interface AdjustableElementInterface {
-    identifier: string;
-    connector: string;
-    connectedNodeId: number;
+declare class CameraSettings {
+    sku: string;
+    position: Vector3;
+    rotation: Vector3;
+    maxHorizontalOrbit: number;
+    minHorizontalOrbit: number;
+    maxVerticalOrbit: number;
+    minVerticalOrbit: number;
+    maxZoomDistance: number;
+    minZoomDistance: number;
 }
 
-interface Skin {
-    [face: string]: SkinFragment;
-}
-interface SkinFragment {
-    color?: number;
-    texture?: Texture;
-}
-
-/** Meta data for items. */
-interface Metadata {
-    itemName?: string;
-    itemDescription?: string;
-    itemType?: number;
-    /**
-     * InstanceId
-     */
-    itemId?: string;
-    originalItemId?: string;
-    /**
-     * Sku
-     */
-    itemIdentifier?: string;
-    goodId?: string;
-    goodType?: string;
-    isCustom?: boolean;
-    locked?: boolean;
-    configurable?: boolean;
-    ione?: boolean;
-    position?: Vector3;
-    rotation?: number | Euler;
-    scale?: Vector3;
-    centerPivot?: boolean;
-    ignoreInvisible?: boolean;
-    updatePivotOnCreate?: boolean;
-    elementConfiguration?: AdjustableElementInterface[];
-    obsolete?: boolean;
-    thirdPartyModel?: boolean;
-    usePivot?: boolean;
-    decos?: DecoNode[];
-    selections?: Selection[];
-    canElevate?: boolean;
-    onWall?: boolean;
-    modelUrl?: string;
-    scalable?: boolean;
-    scalePercentage?: number;
-    resizable?: boolean;
-    elevation?: number;
-    elevationFixed?: boolean;
-    elevationAdjustable?: boolean;
-    schema?: string;
-    assetPath?: string;
-    texture?: Texture;
-    textureAssetName?: string;
-    skin?: Skin;
-    frameColor?: number;
-    doorColor?: number;
-    windowColor?: THREE.Color;
-    doorpost?: boolean;
-    isGlass?: boolean;
-    itemGroup?: any;
-    canRotateX?: boolean;
-    canRotateY?: boolean;
-    canRotateZ?: boolean;
-    canScaleX?: boolean;
-    canScaleY?: boolean;
-    canScaleZ?: boolean;
-    colorable?: boolean;
-    default180?: boolean;
-    objectUUID?: string;
-    conversionGTMSend?: boolean;
-    conversionSubmittedPrice?: string;
-    hdecoType?: string;
-    opening?: {
-        show: boolean;
-        double: boolean;
-        invertDirection: boolean;
-        invertSide: boolean;
-    };
-}
-
-declare class Texture {
-    name: string;
-    type: TextureType;
-    url: string;
-    materializeUrl: string;
-    bumpMap: string;
-    bumpScale: number;
-    roughness: number;
-    roughnessMap: string;
-    normalMap: string;
-    repeatX: number;
-    repeatY: number;
-    metalness: number;
-    metalnessMap: string;
-    aoMapIntensity: number;
-    aoMap: string;
-    alphaMap: string;
-    color: string;
-    emissive: string;
-    data: any;
-    surfaces: string[];
-    offset: THREE.Vector2;
-    scale: number;
-    rotation: number;
-    stretch: boolean;
-    show: boolean;
-    default: boolean;
-    height: number;
-    width: number;
-    tileSize: number;
-    tileRotation: number;
-    dimensions: Vector2;
-    offsetScale: number;
-    useStandalone: boolean;
-    defaultStandalone: boolean;
-    mirror: boolean;
-    simplePlane: boolean;
-    toneMapped: boolean;
-    transparent: boolean;
-    opacity: number;
-    side: THREE.Side;
-    depthWrite: boolean;
-    depthTest: boolean;
-    metadata?: Metadata;
-    static CreateModelFromInterface(modelInterface: TextureInterface): Texture;
-}
-
-declare enum ShadowMapLocalType {
-    BasicShadowMap = "BasicShadowMap",
-    PCFShadowMap = "PCFShadowMap",
-    PCFSoftShadowMap = "PCFSoftShadowMap",
-    VSMShadowMap = "VSMShadowMap"
-}
-
-declare enum OutputEncoding {
-    NoColorSpace = "NoColorSpace",
-    SRGBColorSpace = "SRGBColorSpace",
-    LinearSRGBColorSpace = "LinearSRGBColorSpace",
-    DisplayP3ColorSpace = "DisplayP3ColorSpace",
-    LinearDisplayP3ColorSpace = "LinearDisplayP3ColorSpace"
-}
-
-declare enum LightEnum {
-    SpotLight = "SpotLight",
-    DirectionalLight = "DirectionalLight",
-    AmbientLight = "AmbientLight",
-    HemisphereLight = "HemisphereLight",
-    PointLight = "PointLight"
-}
-
-declare class ShadowProperties {
-    mapSize: Vector2;
-    radius: number;
-    near: number;
-    far: number;
-}
-
-declare class LightProperties {
-    type: LightEnum;
-    name: string;
-    visible: boolean;
-    position: Vector3;
-    color: Color;
-    groundColor: Color;
-    intensity: number;
-    angle: number;
-    power: number;
-    decay: number;
-    distance: number;
-    penumbra: number;
-    bias: number;
-    radius: number;
-    castShadow: boolean;
-    wallOffset: number;
-    rotationOffset: number;
-    topDownDirectional: boolean;
-    shadow: ShadowProperties;
-    static CreateNew(rawData: any): LightProperties;
-}
-
-declare enum ToneMappingLocal {
-    NoToneMapping = "NoToneMapping",
-    LinearToneMapping = "LinearToneMapping",
-    ReinhardToneMapping = "ReinhardToneMapping",
-    CineonToneMapping = "CineonToneMapping",
-    ACESFilmicToneMapping = "ACESFilmicToneMapping",
-    CustomToneMapping = "CustomToneMapping",
-    AgXToneMapping = "AgXToneMapping",
-    NeutralToneMapping = "NeutralToneMapping"
-}
-
-interface LightPresetInterface {
-    id: string;
-    name: string;
-    default: boolean;
-    standalone: boolean;
-    group: string;
-    navigatorType: NavigatorType;
-    shadowMapType: ShadowMapLocalType;
-    outputEncoding: OutputEncoding;
-    shadowRadius: number;
-    toneMapping: ToneMappingLocal;
-    toneMappingExposure: number;
-    physicallyCorrectLights: boolean;
-    lights: LightProperties[];
-    hdri: string;
-    hdriIntensity: number;
-}
-
-declare class LightPreset {
-    id: string;
-    name: string;
-    navigatorType: NavigatorType;
-    default: boolean;
-    standalone: boolean;
-    group: string;
-    shadowMapType: ShadowMapLocalType;
-    outputEncoding: OutputEncoding;
-    colorSpace: ColorSpace;
-    shadowRadius: number;
-    toneMapping: ToneMappingLocal;
-    toneMappingExposure: number;
-    physicallyCorrectLights: boolean;
-    lights: LightProperties[];
-    hdri: string;
-    hdriIntensity: number;
-    dirty: boolean;
-    constructor();
-    static CreateModelFromInterface(modelInterface: LightPresetInterface): LightPreset;
-    private _generateUniqueId;
-}
-
-declare class BundleInitializerService implements OnDestroy {
-    private _jsonUtilsService;
-    private _settingsService;
-    private _ioneControllerService;
-    private _appInitializerService;
-    private _configurationService;
-    private _sceneService;
-    private _sceneOptionsService;
-    floorTextures: Texture[];
-    lightPresets: LightPreset[];
-    settings: Setting[];
-    floorTexturesLoaded: BehaviorSubject<Texture[]>;
-    lightPresetsLoaded: BehaviorSubject<LightPreset[]>;
-    settingsLoaded: BehaviorSubject<Setting[]>;
-    allLoaded: BehaviorSubject<boolean>;
-    private _assetPath;
-    private _connectionSet;
-    private _subs;
-    private _jsonFile;
-    private _lightPresetsJsonFile;
-    constructor(_jsonUtilsService: JsonUtilsService, _settingsService: SettingsService, _ioneControllerService: ConfiguratorConnectorService, _appInitializerService: AppInitializerService, _configurationService: ConfigurationService, _sceneService: SceneService, _sceneOptionsService: SceneOptionsService);
-    ngOnDestroy(): void;
-    getFloorTextures(): Texture[];
-    getFloorTexture(): Texture;
-    getLightPreset(): LightPreset[];
-    private _initialize;
-    private _createTexture;
-    private _createLightPreset;
-    private _createSettings;
-    static ɵfac: i0.ɵɵFactoryDeclaration<BundleInitializerService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<BundleInitializerService>;
-}
-
-declare class FloorPlaneService implements OnDestroy {
-    private _settingsService;
-    private _sceneService;
-    private _sceneOptionsService;
-    private _bundleInitializerService;
-    get floorPlane(): Object3D;
-    floorPlaneCreated: BehaviorSubject<boolean>;
-    private _standaloneFloors;
-    private _floorPlane;
-    private _subs;
-    private _sceneReady;
-    private _texturesReady;
-    constructor(_settingsService: SettingsService, _sceneService: SceneService, _sceneOptionsService: SceneOptionsService, _bundleInitializerService: BundleInitializerService);
-    ngOnDestroy(): void;
-    createFloorPlane(): Promise<void>;
-    getCenterFloorPlane(): Vector3;
-    getDimensions(scale?: number): {
-        x: {
-            min: number;
-            max: number;
-        };
-        y: {
-            min: number;
-            max: number;
-        };
-    };
-    getPlaneSize(): Vector3;
-    private _getStandaloneFloorSize;
-    private _generateFloorPlane;
-    private _createFloorMaterial;
-    private _upsertFloorButtons;
-    private _changeStandaloneFloor;
-    private _setFloorTexture;
-    private _updateFloorMaterial;
-    private _setUpdatedMaterial;
-    private _getMaterials;
-    static ɵfac: i0.ɵɵFactoryDeclaration<FloorPlaneService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<FloorPlaneService>;
-}
-
-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>;
-}
-
-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>;
-}
-
-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>;
-}
-
-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>;
-}
-
-declare class RenderResponse {
-    result: string;
-    statusCode: number;
-}
-
-declare enum BlenderRenderType {
-    Realtime = 0,
-    Raytrace = 1
-}
-
-declare class OptionalRenderSettings {
-    objectWidth: number;
-    objectHeight: number;
-    renderType: number | BlenderRenderType;
-    objectRotation: any;
-    margin: number;
-    cameraRotationX: number;
-    forceTransparency: boolean;
-}
-
-declare class RenderBaseObject {
-    selections: Selection[];
-    decos: DecoNode[];
-    assetUrl: string;
-    cdnUrl: string;
-    schema: string;
-    options: any;
-}
-
-declare class RenderApi {
-    private _settingsService;
-    private _overWriteTransparency;
-    constructor(_settingsService: SettingsService);
-    prepareGlbRender(buildResult: ConfigurationResultObject, object3dPosition: Vector3, object3dRotation: Vector3, cameraFov?: number, forceNewRender?: boolean, optionalRenderParameters?: OptionalRenderSettings): RenderBaseObject;
-    sendRenderRequest(data: RenderBaseObject): Promise<RenderResponse>;
-    degreesToVector3(value: number): Vector3;
-    private _adjustCameraRotation;
-    private _getSceneRenderSettings;
-    private _useTransparency;
-    private _setForceTransparency;
-    static ɵfac: i0.ɵɵFactoryDeclaration<RenderApi, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<RenderApi>;
-}
-
-declare class RenderService implements OnDestroy {
-    private _settingsService;
-    private _cameraService;
-    private _itemService;
-    private _appEventService;
-    private _renderApi;
-    renderImageChanged: BehaviorSubject<string>;
-    renderImageError: BehaviorSubject<string>;
-    blenderRenderStarted: EventEmitter<string>;
-    clientWidth: number;
-    clientHeight: number;
-    private _subs;
-    constructor(_settingsService: SettingsService, _cameraService: CameraService, _itemService: ItemService, _appEventService: AppEventService, _renderApi: RenderApi);
-    ngOnDestroy(): void;
-    renderImage(buildResult: ConfigurationResultObject, optionalRenderParameters?: any, forceNewRender?: boolean): void;
-    getNewGlbFromServer(buildResult: ConfigurationResultObject, optionalRenderParameters?: any, forceNewRender?: boolean): void;
-    private _handleAjaxGlb;
-    static ɵfac: i0.ɵɵFactoryDeclaration<RenderService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<RenderService>;
-}
-
-declare class ConfiguringService implements OnDestroy {
-    settingsService: SettingsService;
-    private _initializerService;
-    private _loadFurnitureService;
-    private _buildFurnitureService;
-    private _appEventService;
-    private _configuratorConnectorService;
-    private _itemService;
-    private _floorPlaneService;
-    private _lightPresetService;
-    private _cameraService;
-    private _sceneEventService;
-    private _sceneService;
-    private _utilsService;
-    private _renderService;
-    set settings(value: ConfiguratorSettings);
-    get settings(): ConfiguratorSettings;
-    set sku(value: string);
-    get sku(): string;
-    set instanceId(value: string);
-    get instanceId(): string;
-    set isConfiguring(value: boolean);
-    get isConfiguring(): boolean;
-    set scene(value: Scene);
-    get scene(): Scene;
-    onShowLiteSelector: EventEmitter<boolean>;
-    onShowSelections: EventEmitter<boolean>;
-    onShowAnswers: EventEmitter<boolean>;
-    onShowFullConfiguration: EventEmitter<boolean>;
-    onAnswersAvailable: EventEmitter<boolean>;
-    floorReady: EventEmitter<boolean>;
-    onRenderImageReceived: EventEmitter<string>;
-    onRenderErrorReceived: EventEmitter<string>;
-    onThumbnailReceived: EventEmitter<string>;
-    onCanvasImageReceived: EventEmitter<string>;
-    buildResult: ConfigurationResultObject;
-    private _settings;
-    private _sku;
-    private _instanceId;
-    private _isConfiguring;
-    private _scene;
-    private _showFullConfiguration;
-    private _subs;
-    constructor(settingsService: SettingsService, _initializerService: AppInitializerService, _loadFurnitureService: SwitchLoadFurnitureService, _buildFurnitureService: SwitchBuildFurnitureService, _appEventService: AppEventService, _configuratorConnectorService: ConfiguratorConnectorService, _itemService: ItemService, _floorPlaneService: FloorPlaneService, _lightPresetService: LightPresetsService, _cameraService: CameraService, _sceneEventService: SceneEventService, _sceneService: SceneService, _utilsService: UtilsService, _renderService: RenderService);
-    ngOnDestroy(): void;
-    init(settings: any): Promise<void>;
-    configure(furnitureData: ConfigurationResultObject, shouldCopyInstance?: boolean, looseOriginalConfiguration?: boolean, fromPreset?: boolean, standAlone?: boolean, fromScratch?: boolean, loadFromProject?: boolean): Promise<void>;
-    addBuildToScene(buildResult: ConfigurationResultObject): void;
-    handleLoadSceneContent(): Promise<void>;
-    renderImage(buildResult: ConfigurationResultObject, optionalRenderParameters?: any, forceNewRender?: boolean): Promise<void>;
-    private _handleTemplateChange;
-    private _handleFloorPlaneReady;
-    private _handleImageReceived;
-    private _handleRenderErrorReceived;
-    private _handleAnswerCountReceived;
-    static ɵfac: i0.ɵɵFactoryDeclaration<ConfiguringService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<ConfiguringService>;
-}
-
-declare class ConfiguratorComponent implements OnDestroy {
-    settingsService: SettingsService;
-    loaderService: LoaderService;
-    private _appEventService;
-    private _configuringService;
-    showClass(): boolean;
-    showLoader: boolean;
-    showProgressBar: boolean;
-    showErrorMessages: boolean;
-    outputErrorMessages: boolean;
-    canCloseConfigurator: boolean;
-    animateSlideout: boolean;
-    showHeaderInformation: boolean;
-    showSaveAndLoadConfiguration: boolean;
-    buildResult: EventEmitter<ConfigurationResultObject>;
-    isLoading: EventEmitter<boolean>;
-    updateProgressBar: EventEmitter<boolean>;
-    errorMessages: EventEmitter<ConfiguratorErrorMessage[]>;
-    showChange: EventEmitter<boolean>;
-    resultHasErrors: boolean;
-    showErrorDiagram: boolean;
-    configurationResultObject: ConfigurationResultObject;
-    private _subs;
-    constructor(settingsService: SettingsService, loaderService: LoaderService, _appEventService: AppEventService, _configuringService: ConfiguringService);
-    ngOnDestroy(): void;
-    handleBuildFinished(result: ConfigurationResultObject): void;
-    handleShowChange(show: boolean): void;
-    handleCloseErrorDialog(): void;
-    private _handleArticleNotFound;
-    static ɵfac: i0.ɵɵFactoryDeclaration<ConfiguratorComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<ConfiguratorComponent, "co-configurator", never, { "showLoader": { "alias": "showLoader"; "required": false; }; "showProgressBar": { "alias": "showProgressBar"; "required": false; }; "showErrorMessages": { "alias": "showErrorMessages"; "required": false; }; "outputErrorMessages": { "alias": "outputErrorMessages"; "required": false; }; "canCloseConfigurator": { "alias": "canCloseConfigurator"; "required": false; }; "animateSlideout": { "alias": "animateSlideout"; "required": false; }; "showHeaderInformation": { "alias": "showHeaderInformation"; "required": false; }; "showSaveAndLoadConfiguration": { "alias": "showSaveAndLoadConfiguration"; "required": false; }; }, { "buildResult": "buildResult"; "isLoading": "isLoading"; "updateProgressBar": "updateProgressBar"; "errorMessages": "errorMessages"; "showChange": "showChange"; }, never, never, false, never>;
-}
-
-declare class ProgressBarComponent {
-    progressService: ProgressService;
-    showClass(): boolean;
-    get showBar(): boolean;
-    constructor(progressService: ProgressService);
-    static ɵfac: i0.ɵɵFactoryDeclaration<ProgressBarComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<ProgressBarComponent, "co-progress-bar", never, {}, {}, never, never, false, never>;
-}
-
-declare class ProgressBarModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<ProgressBarModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<ProgressBarModule, [typeof ProgressBarComponent], [typeof i3.CommonModule], [typeof ProgressBarComponent]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<ProgressBarModule>;
-}
-
-declare class ConfiguratorLoaderComponent {
-    showClass(): boolean;
-    show: boolean;
-    static ɵfac: i0.ɵɵFactoryDeclaration<ConfiguratorLoaderComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<ConfiguratorLoaderComponent, "co-configurator-loader", never, { "show": { "alias": "show"; "required": false; }; }, {}, never, never, false, never>;
-}
-
-declare class ConfiguratorLoaderModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<ConfiguratorLoaderModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<ConfiguratorLoaderModule, [typeof ConfiguratorLoaderComponent], [typeof i3$1.LoaderModule, typeof i3$1.IconModule, typeof i3.CommonModule], [typeof ConfiguratorLoaderComponent]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<ConfiguratorLoaderModule>;
-}
-
-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>;
-}
-
-declare class ConfiguratorErrorDialogComponent {
-    iconService: IconCacheService;
-    showClass(): boolean;
-    readonly icons: typeof IconEnum;
-    errorMessages: ConfiguratorErrorMessage[];
-    closeErrorDialoag: EventEmitter<void>;
-    onClose(): void;
-    constructor(iconService: IconCacheService);
-    static ɵfac: i0.ɵɵFactoryDeclaration<ConfiguratorErrorDialogComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<ConfiguratorErrorDialogComponent, "co-configurator-error-dialog", never, { "errorMessages": { "alias": "errorMessages"; "required": false; }; }, { "closeErrorDialoag": "closeErrorDialoag"; }, never, never, false, never>;
-}
-
-declare class ConfiguratorExportDialogComponent {
-    iconService: IconCacheService;
-    itemService: ItemService;
-    private _utilService;
-    readonly icons: typeof IconEnum;
-    closeExportDialog: EventEmitter<void>;
-    constructor(iconService: IconCacheService, itemService: ItemService, _utilService: UtilsService);
-    onClose(): void;
-    downloadGLB(): void;
-    downloadUSDZ(): void;
-    downloadBoth(): void;
-    downloadThumbnail(): void;
-    private _getObjectToExport;
-    private _download3DModelAsGLB;
-    private _download3DModelAsUSDZ;
-    private _downloadFile;
-    private _base64ToBlob;
-    static ɵfac: i0.ɵɵFactoryDeclaration<ConfiguratorExportDialogComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<ConfiguratorExportDialogComponent, "co-configurator-export-dialog", never, {}, { "closeExportDialog": "closeExportDialog"; }, never, never, false, never>;
-}
-
-declare class CameraSettings {
-    sku: string;
-    position: Vector3;
-    rotation: Vector3;
-    maxHorizontalOrbit: number;
-    minHorizontalOrbit: number;
-    maxVerticalOrbit: number;
-    minVerticalOrbit: number;
-    maxZoomDistance: number;
-    minZoomDistance: number;
-}
-
-declare class DynamicCameraService {
+declare class ConfiguratorDynamicCameraService {
     private _cameraService;
     private _sceneService;
     private _settingsService;
     private _configuratorConnectorService;
     currentCameraSettings: CameraSettings[];
-    constructor(_cameraService: CameraService, _sceneService: SceneService, _settingsService: SettingsService, _configuratorConnectorService: ConfiguratorConnectorService);
+    constructor(_cameraService: ConfiguratorCameraService, _sceneService: ConfiguratorSceneService, _settingsService: ConfiguratorSettingsService, _configuratorConnectorService: ConfiguratorConnectorService);
     initCameraSettings(): Promise<void>;
     getCameraSettings(): CameraSettings;
     loadCustomCameraSettings(): Promise<void>;
     exportCameraSettings(): any;
     saveSettingsToCurrentSettings(cameraSettings: CameraSettings, asDefault: boolean): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicCameraService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<DynamicCameraService>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfiguratorDynamicCameraService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ConfiguratorDynamicCameraService>;
 }
 
 declare class ConfiguratorCameraSettingsComponent implements OnInit {
@@ -2444,7 +1487,7 @@ declare class ConfiguratorCameraSettingsComponent implements OnInit {
     currentSku: string;
     positionAsString: string;
     rotationAsString: string;
-    constructor(iconService: IconCacheService, _cameraService: CameraService, _dynamicCameraService: DynamicCameraService, _configuratorConnectorService: ConfiguratorConnectorService);
+    constructor(iconService: IconCacheService, _cameraService: ConfiguratorCameraService, _dynamicCameraService: ConfiguratorDynamicCameraService, _configuratorConnectorService: ConfiguratorConnectorService);
     ngOnInit(): void;
     onClose(): void;
     saveSettings(asDefault: boolean): void;
@@ -2456,101 +1499,46 @@ declare class ConfiguratorCameraSettingsComponent implements OnInit {
     static ɵcmp: i0.ɵɵComponentDeclaration<ConfiguratorCameraSettingsComponent, "co-configurator-camera-settings-dialog", never, {}, { "closeCameraDialog": "closeCameraDialog"; }, never, never, false, never>;
 }
 
-declare class AppendPipe implements PipeTransform {
-    transform(value: string, append?: string): string;
-    static ɵfac: i0.ɵɵFactoryDeclaration<AppendPipe, never>;
-    static ɵpipe: i0.ɵɵPipeDeclaration<AppendPipe, "append", false>;
-}
-
-declare class LocalizePipe implements PipeTransform {
-    private _dictionaryService;
-    constructor(_dictionaryService: DictionaryService);
-    transform(value: string, upperCaseFirst?: boolean, replace?: string | string[]): string;
-    static ɵfac: i0.ɵɵFactoryDeclaration<LocalizePipe, never>;
-    static ɵpipe: i0.ɵɵPipeDeclaration<LocalizePipe, "localize", false>;
-}
-
-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>;
-}
-
-declare class GoogleTranslatePipe implements PipeTransform {
-    private _googleTranslateService;
-    constructor(_googleTranslateService: GoogleTranslateService);
-    transform(value: string): Observable<string>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<GoogleTranslatePipe, never>;
-    static ɵpipe: i0.ɵɵPipeDeclaration<GoogleTranslatePipe, "googleTranslate", false>;
-}
-
-declare class PrependPipe implements PipeTransform {
-    transform(value: string, prepend?: string): string;
-    static ɵfac: i0.ɵɵFactoryDeclaration<PrependPipe, never>;
-    static ɵpipe: i0.ɵɵPipeDeclaration<PrependPipe, "prepend", false>;
-}
-
-declare class StripHtmlPipe implements PipeTransform {
-    transform(html: string): string;
-    static ɵfac: i0.ɵɵFactoryDeclaration<StripHtmlPipe, never>;
-    static ɵpipe: i0.ɵɵPipeDeclaration<StripHtmlPipe, "stripHtml", false>;
-}
-
-declare class PipesModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<PipesModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<PipesModule, [typeof AppendPipe, typeof LocalizePipe, typeof GoogleTranslatePipe, typeof PrependPipe, typeof StripHtmlPipe], never, [typeof AppendPipe, typeof LocalizePipe, typeof GoogleTranslatePipe, typeof PrependPipe, typeof StripHtmlPipe]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<PipesModule>;
-}
-
 declare class ConfiguratorDialogModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<ConfiguratorDialogModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<ConfiguratorDialogModule, [typeof ConfiguratorErrorDialogComponent, typeof ConfiguratorExportDialogComponent, typeof ConfiguratorCameraSettingsComponent], [typeof PipesModule, typeof i3$1.IconModule, typeof i3.CommonModule, typeof i7.FormsModule], [typeof ConfiguratorErrorDialogComponent, typeof ConfiguratorExportDialogComponent, typeof ConfiguratorCameraSettingsComponent]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ConfiguratorDialogModule, [typeof ConfiguratorErrorDialogComponent, typeof ConfiguratorExportDialogComponent, typeof ConfiguratorCameraSettingsComponent], [typeof i2.TranslationModule, typeof i3$1.IconModule, typeof i3.CommonModule, typeof i7.FormsModule], [typeof ConfiguratorErrorDialogComponent, typeof ConfiguratorExportDialogComponent, typeof ConfiguratorCameraSettingsComponent]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<ConfiguratorDialogModule>;
 }
 
-declare class ThreedselectorComponent implements OnInit, OnDestroy {
+declare class ConfigurationPresetDialogComponent implements OnDestroy {
+    iconService: IconCacheService;
+    private _overlay;
+    private _viewContainerRef;
+    private _configuratorConnectorService;
+    private _translationService;
     private _appEventService;
-    private _buildFurnitureService;
-    private _configuringService;
-    private _configuratorService;
+    readonly icons: typeof IconEnum;
+    readonly presetDialogMode: typeof PresetDialogMode;
+    dialogTemplate: TemplateRef<any>;
     showClass(): boolean;
-    customizeButtonClicked: EventEmitter<void>;
-    selections: Selection[];
-    canCloseConfigurator: boolean;
-    animateSlideout: boolean;
-    showHeaderInformation: boolean;
-    showSaveAndLoadConfiguration: boolean;
-    buildFinished: EventEmitter<ConfigurationResultObject>;
-    showChange: EventEmitter<boolean>;
-    showElementToolbar: boolean;
-    showLiteSelector: boolean;
-    showSelections: boolean;
-    showAnswers: boolean;
-    showFullConfiguration: boolean;
-    private _floorTexturesLoadedSub;
+    instanceIdInput: string;
+    showValidationErrors: boolean;
+    validationError: string;
+    dialogMode: PresetDialogMode;
+    private _overlayRef;
+    private _instanceId;
     private _subs;
-    private _loadingFromPreset;
-    constructor(_appEventService: AppEventService, _buildFurnitureService: SwitchBuildFurnitureService, _configuringService: ConfiguringService, _configuratorService: ConfiguratorService);
-    ngOnInit(): Promise<void>;
+    constructor(iconService: IconCacheService, _overlay: Overlay, _viewContainerRef: ViewContainerRef, _configuratorConnectorService: ConfiguratorConnectorService, _translationService: TranslationService, _appEventService: ConfiguratorEventService);
     ngOnDestroy(): void;
-    get showTemplate(): boolean;
-    handleShowChangeSelector(show: boolean): void;
-    private _handleAnswerCountReceived;
-    private _handleTemplateChange;
-    private _handleBuildResult;
-    static ɵfac: i0.ɵɵFactoryDeclaration<ThreedselectorComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<ThreedselectorComponent, "co-threedselector", never, { "selections": { "alias": "selections"; "required": false; }; "canCloseConfigurator": { "alias": "canCloseConfigurator"; "required": false; }; "animateSlideout": { "alias": "animateSlideout"; "required": false; }; "showHeaderInformation": { "alias": "showHeaderInformation"; "required": false; }; "showSaveAndLoadConfiguration": { "alias": "showSaveAndLoadConfiguration"; "required": false; }; }, { "customizeButtonClicked": "customizeButtonClicked"; "buildFinished": "buildFinished"; "showChange": "showChange"; }, never, never, false, never>;
+    handleOpenDialog(mode: PresetDialogMode): void;
+    handleCloseClick(): void;
+    handleCopySuccess(): Promise<void>;
+    loadConfiguration(): void;
+    private _openOverlay;
+    private _handleSetInstance;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfigurationPresetDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ConfigurationPresetDialogComponent, "co-configuration-preset-dialog", never, {}, {}, never, never, false, never>;
+}
+
+declare class ConfigurationPresetDialogModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfigurationPresetDialogModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ConfigurationPresetDialogModule, [typeof ConfigurationPresetDialogComponent], [typeof i2.TranslationModule, typeof i3$1.ButtonModule, typeof i3$1.IconModule, typeof i3$1.InputTextModule, typeof i4.CdkCopyToClipboard, typeof i3.AsyncPipe], [typeof ConfigurationPresetDialogComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ConfigurationPresetDialogModule>;
 }
 
 declare class LiteSelectorComponent implements OnDestroy {
@@ -2559,11 +1547,7 @@ declare class LiteSelectorComponent implements OnDestroy {
     private _configuringService;
     showClass(): boolean;
     templateAnswers: TemplateRef<any>;
-    set showAnswers(value: boolean);
-    get showAnswers(): boolean;
     show: boolean;
-    set showSelections(value: boolean);
-    get showSelections(): boolean;
     showLabel: boolean;
     canClose: boolean;
     animateSlideout: boolean;
@@ -2585,11 +1569,11 @@ declare class LiteSelectorComponent implements OnDestroy {
     onSelectionsSummaryDeleteSelection(selection: Selection): Promise<void>;
     onAnswersSlideoutAnswerChosen(answerSelected: any): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<LiteSelectorComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<LiteSelectorComponent, "co-lite-selector", never, { "showAnswers": { "alias": "showAnswers"; "required": false; }; "show": { "alias": "show"; "required": false; }; "showSelections": { "alias": "showSelections"; "required": false; }; "showLabel": { "alias": "showLabel"; "required": false; }; "canClose": { "alias": "canClose"; "required": false; }; "animateSlideout": { "alias": "animateSlideout"; "required": false; }; "customDimensions": { "alias": "customDimensions"; "required": false; }; "showSaveAndLoadConfiguration": { "alias": "showSaveAndLoadConfiguration"; "required": false; }; }, { "showChange": "showChange"; "answerChosen": "answerChosen"; }, never, never, false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LiteSelectorComponent, "co-lite-selector", never, { "show": { "alias": "show"; "required": false; }; "showLabel": { "alias": "showLabel"; "required": false; }; "canClose": { "alias": "canClose"; "required": false; }; "animateSlideout": { "alias": "animateSlideout"; "required": false; }; "customDimensions": { "alias": "customDimensions"; "required": false; }; "showSaveAndLoadConfiguration": { "alias": "showSaveAndLoadConfiguration"; "required": false; }; }, { "showChange": "showChange"; "answerChosen": "answerChosen"; }, never, never, false, never>;
 }
 
 declare class AnswerCardComponent implements OnInit {
-    settingsService: SettingsService;
+    settingsService: ConfiguratorSettingsService;
     iconService: IconCacheService;
     private _configuratorConnectorService;
     readonly icons: typeof IconEnum;
@@ -2619,7 +1603,7 @@ declare class AnswerCardComponent implements OnInit {
     showAnswerInfo: boolean;
     private _waitForInput;
     private _waitForInqValue;
-    constructor(settingsService: SettingsService, iconService: IconCacheService, _configuratorConnectorService: ConfiguratorConnectorService);
+    constructor(settingsService: ConfiguratorSettingsService, iconService: IconCacheService, _configuratorConnectorService: ConfiguratorConnectorService);
     ngOnInit(): void;
     onContentClick(): void;
     handleClick(event: MouseEvent): void;
@@ -2643,7 +1627,7 @@ declare class AnswerCardComponent implements OnInit {
 
 declare class AnswersSlideoutComponent implements OnInit, OnDestroy {
     configuratorConnectorService: ConfiguratorConnectorService;
-    settingsService: SettingsService;
+    settingsService: ConfiguratorSettingsService;
     iconService: IconCacheService;
     private _appEventService;
     private _buildFurnitureService;
@@ -2654,7 +1638,6 @@ declare class AnswersSlideoutComponent implements OnInit, OnDestroy {
     readonly icons: typeof IconEnum;
     private readonly _showSmallAnswerCardsFromThisAmount;
     private readonly _propsToSearch;
-    isShown: boolean;
     question: Question;
     showTitle: boolean;
     showFilter: boolean;
@@ -2662,7 +1645,6 @@ declare class AnswersSlideoutComponent implements OnInit, OnDestroy {
     useSlideout: boolean;
     get answers(): Answer[];
     customDimensions: boolean;
-    readonly isShownChange: EventEmitter<boolean>;
     readonly answerChosen: EventEmitter<{
         answer: Answer;
         input: string;
@@ -2670,7 +1652,7 @@ declare class AnswersSlideoutComponent implements OnInit, OnDestroy {
     isSmallCardsModus: boolean;
     bottomAlign: boolean;
     filteredAnswers: Answer[];
-    colorArray: Color$1[];
+    colorArray: Color[];
     tagArray: Tag[];
     showTheFilter: boolean;
     zoomImage: string;
@@ -2686,12 +1668,12 @@ declare class AnswersSlideoutComponent implements OnInit, OnDestroy {
     private _subs;
     private _filterOnColors;
     private _filterOnTags;
-    constructor(configuratorConnectorService: ConfiguratorConnectorService, settingsService: SettingsService, iconService: IconCacheService, _appEventService: AppEventService, _buildFurnitureService: SwitchBuildFurnitureService, _configuringService: ConfiguringService);
+    constructor(configuratorConnectorService: ConfiguratorConnectorService, settingsService: ConfiguratorSettingsService, iconService: IconCacheService, _appEventService: ConfiguratorEventService, _buildFurnitureService: SwitchBuildFurnitureService, _configuringService: ConfiguringService);
     ngOnInit(): void;
     ngOnDestroy(): void;
     onZoomClick(answer: Answer): void;
     applyFilter(): void;
-    onFilterColor(color: Color$1): void;
+    onFilterColor(color: Color): void;
     onFilterTag(tag: Tag): void;
     onCloseAnswerSlideout(): void;
     handleAnswerChosen(answer: Answer): void;
@@ -2711,7 +1693,7 @@ declare class AnswersSlideoutComponent implements OnInit, OnDestroy {
     private _addToArray;
     private _inArray;
     static ɵfac: i0.ɵɵFactoryDeclaration<AnswersSlideoutComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<AnswersSlideoutComponent, "co-answers-slideout", never, { "isShown": { "alias": "isShown"; "required": false; }; "question": { "alias": "question"; "required": false; }; "showTitle": { "alias": "showTitle"; "required": false; }; "showFilter": { "alias": "showFilter"; "required": false; }; "answers": { "alias": "answers"; "required": false; }; "useSlideout": { "alias": "useSlideout"; "required": false; }; "customDimensions": { "alias": "customDimensions"; "required": false; }; }, { "isShownChange": "isShownChange"; "answerChosen": "answerChosen"; }, never, never, false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AnswersSlideoutComponent, "co-answers-slideout", never, { "question": { "alias": "question"; "required": false; }; "showTitle": { "alias": "showTitle"; "required": false; }; "showFilter": { "alias": "showFilter"; "required": false; }; "answers": { "alias": "answers"; "required": false; }; "useSlideout": { "alias": "useSlideout"; "required": false; }; "customDimensions": { "alias": "customDimensions"; "required": false; }; }, { "answerChosen": "answerChosen"; }, never, never, false, never>;
 }
 
 declare class SlideoutComponent implements AfterViewInit {
@@ -2763,7 +1745,7 @@ declare class AnswersInfoDialogComponent implements OnInit {
     showTooltip: boolean;
     showPopup: boolean;
     hasEmbed: boolean;
-    constructor(iconService: IconCacheService, _settingsService: SettingsService, _configuratorConnectorService: ConfiguratorConnectorService, _sanitizer: DomSanitizer);
+    constructor(iconService: IconCacheService, _settingsService: ConfiguratorSettingsService, _configuratorConnectorService: ConfiguratorConnectorService, _sanitizer: DomSanitizer);
     ngOnInit(): Promise<void>;
     private _loadInfo;
     private _formatAnswerInfo;
@@ -2773,13 +1755,13 @@ declare class AnswersInfoDialogComponent implements OnInit {
 
 declare class AnswersInfoDialogModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<AnswersInfoDialogModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<AnswersInfoDialogModule, [typeof AnswersInfoDialogComponent], [typeof i3.CommonModule, typeof PipesModule, typeof i3$1.IconModule], [typeof AnswersInfoDialogComponent]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AnswersInfoDialogModule, [typeof AnswersInfoDialogComponent], [typeof i3.CommonModule, typeof i2.TranslationModule, typeof i3$1.IconModule], [typeof AnswersInfoDialogComponent]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<AnswersInfoDialogModule>;
 }
 
 declare class AnswerCardModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<AnswerCardModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<AnswerCardModule, [typeof AnswerCardComponent], [typeof i3.CommonModule, typeof i3$1.CardModule, typeof PipesModule, typeof i3$1.CardModule, typeof i3$1.InputTextModule, typeof i3$1.IconModule, typeof AnswersInfoDialogModule, typeof i3$1.CardModule, typeof i3$1.ButtonModule], [typeof AnswerCardComponent]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AnswerCardModule, [typeof AnswerCardComponent], [typeof i3.CommonModule, typeof i3$1.CardModule, typeof i3$1.CardModule, typeof i3$1.InputTextModule, typeof i3$1.IconModule, typeof AnswersInfoDialogModule, typeof i3$1.CardModule, typeof i3$1.ButtonModule, typeof i2.TranslationModule], [typeof AnswerCardComponent]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<AnswerCardModule>;
 }
 
@@ -2806,8 +1788,8 @@ declare class ColorFilterComponent {
     private _sanitizer;
     readonly icons: typeof IconEnum;
     showClass(): boolean;
-    set color(value: Color$1);
-    get color(): Color$1;
+    set color(value: Color);
+    get color(): Color;
     active: boolean;
     get lightBackground(): boolean;
     backgroundStyle: SafeStyle;
@@ -2870,7 +1852,7 @@ declare class DirectivesModule {
 
 declare class AnswersSlideoutModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<AnswersSlideoutModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<AnswersSlideoutModule, [typeof AnswersSlideoutComponent], [typeof SlideoutModule, typeof PipesModule, typeof i3.CommonModule, typeof i3$1.IconModule, typeof i3$1.PriceDisplayPipeModule, typeof AnswerCardModule, typeof ImageZoomModule, typeof ColorFilterModule, typeof TagFilterModule, typeof DirectivesModule], [typeof AnswersSlideoutComponent]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AnswersSlideoutModule, [typeof AnswersSlideoutComponent], [typeof SlideoutModule, typeof i2.TranslationModule, typeof i3.CommonModule, typeof i3$1.IconModule, typeof i3$1.PriceDisplayPipeModule, typeof AnswerCardModule, typeof ImageZoomModule, typeof ColorFilterModule, typeof TagFilterModule, typeof DirectivesModule, typeof i2.UtilitiesPipesModule], [typeof AnswersSlideoutComponent]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<AnswersSlideoutModule>;
 }
 
@@ -2957,7 +1939,7 @@ declare class CoSummaryLine implements AfterViewInit {
 
 declare class CoSummaryLineModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<CoSummaryLineModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<CoSummaryLineModule, [typeof CoSummaryLine], [typeof PipesModule, typeof i3.CommonModule, typeof i3$1.PriceDisplayPipeModule, typeof i3$1.ImageModule, typeof i3$1.IconModule], [typeof CoSummaryLine]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CoSummaryLineModule, [typeof CoSummaryLine], [typeof i2.TranslationModule, typeof i3.CommonModule, typeof i3$1.PriceDisplayPipeModule, typeof i3$1.ImageModule, typeof i3$1.IconModule], [typeof CoSummaryLine]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<CoSummaryLineModule>;
 }
 
@@ -2987,18 +1969,22 @@ declare class SelectionsSummaryLineComponent implements OnDestroy {
 
 declare class SelectionsSummaryLineModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<SelectionsSummaryLineModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<SelectionsSummaryLineModule, [typeof SelectionsSummaryLineComponent], [typeof PipesModule, typeof i3.CommonModule, typeof CoSummaryLineModule], [typeof SelectionsSummaryLineComponent]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SelectionsSummaryLineModule, [typeof SelectionsSummaryLineComponent], [typeof i3.CommonModule, typeof CoSummaryLineModule, typeof i2.TranslationModule], [typeof SelectionsSummaryLineComponent]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<SelectionsSummaryLineModule>;
 }
 
-declare class ConfigurationPresetComponent {
+declare class ConfigurationPresetComponent implements OnInit {
     iconService: IconCacheService;
+    settingService: ConfiguratorSettingsService;
     private _appEventService;
     readonly icons: typeof IconEnum;
-    isSaveLoadMenuOpen: boolean;
     showClass(): boolean;
     closeSaveLoadMenu(): void;
-    constructor(iconService: IconCacheService, _appEventService: AppEventService);
+    isSaveLoadMenuOpen: boolean;
+    showSavePresetButton: boolean;
+    showLoadPresetButton: boolean;
+    constructor(iconService: IconCacheService, settingService: ConfiguratorSettingsService, _appEventService: ConfiguratorEventService);
+    ngOnInit(): void;
     toggleSaveLoadMenu(event: MouseEvent): void;
     handleSavePresetClicked(): void;
     handleLoadPresetClicked(): void;
@@ -3008,13 +1994,13 @@ declare class ConfigurationPresetComponent {
 
 declare class ConfigurationPresetModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<ConfigurationPresetModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<ConfigurationPresetModule, [typeof ConfigurationPresetComponent], [typeof PipesModule, typeof i3$1.ButtonModule, typeof i3$1.IconModule, typeof i3$1.InputTextModule, typeof i4.CdkCopyToClipboard], [typeof ConfigurationPresetComponent]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ConfigurationPresetModule, [typeof ConfigurationPresetComponent], [typeof i2.TranslationModule, typeof i3$1.ButtonModule, typeof i3$1.IconModule, typeof i3$1.InputTextModule, typeof i4.CdkCopyToClipboard, typeof i3.AsyncPipe, typeof ConfigurationPresetDialogModule], [typeof ConfigurationPresetComponent]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<ConfigurationPresetModule>;
 }
 
 declare class SelectionsSummaryModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<SelectionsSummaryModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<SelectionsSummaryModule, [typeof SelectionsSummaryComponent], [typeof CoSummaryLineModule, typeof i3.CommonModule, typeof PipesModule, typeof i3$1.PriceDisplayPipeModule, typeof SelectionsSummaryLineModule, typeof i3$1.IconModule, typeof ConfigurationPresetModule], [typeof SelectionsSummaryComponent]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SelectionsSummaryModule, [typeof SelectionsSummaryComponent], [typeof CoSummaryLineModule, typeof i3.CommonModule, typeof i2.TranslationModule, typeof i3$1.PriceDisplayPipeModule, typeof SelectionsSummaryLineModule, typeof i3$1.IconModule, typeof ConfigurationPresetModule], [typeof SelectionsSummaryComponent]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<SelectionsSummaryModule>;
 }
 
@@ -3032,18 +2018,17 @@ declare class ProductConfiguratorService {
     static ɵprov: i0.ɵɵInjectableDeclaration<ProductConfiguratorService>;
 }
 
-declare class ProductConfiguratorComponent implements OnInit, OnDestroy {
+declare class ProductConfiguratorComponent implements OnDestroy {
     configuratorConnectorService: ConfiguratorConnectorService;
     buildFurnitureService: SwitchBuildFurnitureService;
-    settingsService: SettingsService;
+    settingsService: ConfiguratorSettingsService;
     productConfiguratorService: ProductConfiguratorService;
     iconService: IconCacheService;
     private _sanitizer;
     private _configuringService;
+    private _eventService;
     showClass(): boolean;
     readonly icons: typeof IconEnum;
-    set show(value: boolean);
-    get show(): boolean;
     showHeaderInformation: boolean;
     set showSelections(value: boolean);
     get showSelections(): boolean;
@@ -3061,18 +2046,19 @@ declare class ProductConfiguratorComponent implements OnInit, OnDestroy {
     private _show;
     private _selectionSelected;
     private _subs;
-    constructor(configuratorConnectorService: ConfiguratorConnectorService, buildFurnitureService: SwitchBuildFurnitureService, settingsService: SettingsService, productConfiguratorService: ProductConfiguratorService, iconService: IconCacheService, _sanitizer: DomSanitizer, _configuringService: ConfiguringService);
-    ngOnInit(): void;
+    constructor(configuratorConnectorService: ConfiguratorConnectorService, buildFurnitureService: SwitchBuildFurnitureService, settingsService: ConfiguratorSettingsService, productConfiguratorService: ProductConfiguratorService, iconService: IconCacheService, _sanitizer: DomSanitizer, _configuringService: ConfiguringService, _eventService: ConfiguratorEventService);
     ngOnDestroy(): void;
     onSelectionsSummarySelectSelection(chosenOption: SelectorStructure): Promise<void>;
     handleCloseClick(): void;
+    private _handleSelectionWithAnswersChanged;
+    private _handleArticleReceived;
     static ɵfac: i0.ɵɵFactoryDeclaration<ProductConfiguratorComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<ProductConfiguratorComponent, "co-product-configurator", never, { "show": { "alias": "show"; "required": false; }; "showHeaderInformation": { "alias": "showHeaderInformation"; "required": false; }; "showSelections": { "alias": "showSelections"; "required": false; }; "showLabel": { "alias": "showLabel"; "required": false; }; "canClose": { "alias": "canClose"; "required": false; }; "customDimensions": { "alias": "customDimensions"; "required": false; }; "showSaveAndLoadConfiguration": { "alias": "showSaveAndLoadConfiguration"; "required": false; }; }, { "showChange": "showChange"; "answerChosen": "answerChosen"; }, never, never, false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ProductConfiguratorComponent, "co-product-configurator", never, { "showHeaderInformation": { "alias": "showHeaderInformation"; "required": false; }; "showSelections": { "alias": "showSelections"; "required": false; }; "showLabel": { "alias": "showLabel"; "required": false; }; "canClose": { "alias": "canClose"; "required": false; }; "customDimensions": { "alias": "customDimensions"; "required": false; }; "showSaveAndLoadConfiguration": { "alias": "showSaveAndLoadConfiguration"; "required": false; }; }, { "showChange": "showChange"; "answerChosen": "answerChosen"; }, never, never, false, never>;
 }
 
 declare class ProductConfiguratorSelectorComponent implements OnInit, OnChanges {
     configuratorConnectorService: ConfiguratorConnectorService;
-    settingsService: SettingsService;
+    settingsService: ConfiguratorSettingsService;
     iconService: IconCacheService;
     get hostClasses(): string;
     readonly icons: typeof IconEnum;
@@ -3097,7 +2083,7 @@ declare class ProductConfiguratorSelectorComponent implements OnInit, OnChanges
     get suppressSubShowMoreForChildren(): boolean;
     get groupedRemainingTilesCount(): number;
     get useGroupedVisibilityForChildren(): boolean;
-    constructor(configuratorConnectorService: ConfiguratorConnectorService, settingsService: SettingsService, iconService: IconCacheService);
+    constructor(configuratorConnectorService: ConfiguratorConnectorService, settingsService: ConfiguratorSettingsService, iconService: IconCacheService);
     ngOnInit(): void;
     ngOnChanges(changes: SimpleChanges): void;
     showAndScroll(): void;
@@ -3120,7 +2106,7 @@ declare class ProductConfiguratorSelectorComponent implements OnInit, OnChanges
 
 declare class ProductConfiguratorSelectorOptionComponent implements OnInit, OnChanges {
     configuratorConnectorService: ConfiguratorConnectorService;
-    settingsService: SettingsService;
+    settingsService: ConfiguratorSettingsService;
     productConfiguratorService: ProductConfiguratorService;
     showClass(): boolean;
     selection: SelectorStructure;
@@ -3137,7 +2123,7 @@ declare class ProductConfiguratorSelectorOptionComponent implements OnInit, OnCh
     remainingTilesCount: number;
     readonly smallTileOptions: ConfigurationDisplayOption[];
     readonly largeTileOptions: ConfigurationDisplayOption[];
-    constructor(configuratorConnectorService: ConfiguratorConnectorService, settingsService: SettingsService, productConfiguratorService: ProductConfiguratorService);
+    constructor(configuratorConnectorService: ConfiguratorConnectorService, settingsService: ConfiguratorSettingsService, productConfiguratorService: ProductConfiguratorService);
     ngOnInit(): void;
     ngOnChanges(changes: SimpleChanges): void;
     selectionClicked(answer: SelectorStructure): void;
@@ -3152,14 +2138,14 @@ declare class ProductConfiguratorSelectorOptionComponent implements OnInit, OnCh
 declare class ProductConfiguratorSelectorOptionTileComponent {
     configuratorConnectorService: ConfiguratorConnectorService;
     iconService: IconCacheService;
-    settingsService: SettingsService;
+    settingsService: ConfiguratorSettingsService;
     showClass(): boolean;
     readonly icons: typeof IconEnum;
     option: SelectorStructure;
     tileClass: string;
     noLabel: boolean;
     selectionClicked: EventEmitter<void>;
-    constructor(configuratorConnectorService: ConfiguratorConnectorService, iconService: IconCacheService, settingsService: SettingsService);
+    constructor(configuratorConnectorService: ConfiguratorConnectorService, iconService: IconCacheService, settingsService: ConfiguratorSettingsService);
     changeSelection(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<ProductConfiguratorSelectorOptionTileComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<ProductConfiguratorSelectorOptionTileComponent, "co-product-configurator-selector-option-tile", never, { "option": { "alias": "option"; "required": false; }; "tileClass": { "alias": "tileClass"; "required": false; }; "noLabel": { "alias": "noLabel"; "required": false; }; }, { "selectionClicked": "selectionClicked"; }, never, never, false, never>;
@@ -3167,19 +2153,19 @@ declare class ProductConfiguratorSelectorOptionTileComponent {
 
 declare class ProductConfiguratorSelectorOptionTileModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<ProductConfiguratorSelectorOptionTileModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<ProductConfiguratorSelectorOptionTileModule, [typeof ProductConfiguratorSelectorOptionTileComponent], [typeof i3$1.IconModule, typeof i3.CommonModule, typeof PipesModule], [typeof ProductConfiguratorSelectorOptionTileComponent]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ProductConfiguratorSelectorOptionTileModule, [typeof ProductConfiguratorSelectorOptionTileComponent], [typeof i3$1.IconModule, typeof i3.CommonModule, typeof i2.TranslationModule], [typeof ProductConfiguratorSelectorOptionTileComponent]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<ProductConfiguratorSelectorOptionTileModule>;
 }
 
 declare class ProductConfiguratorOptionCheckboxComponent {
     configuratorConnectorService: ConfiguratorConnectorService;
     iconService: IconCacheService;
-    settingsService: SettingsService;
+    settingsService: ConfiguratorSettingsService;
     showClass(): boolean;
     readonly icons: typeof IconEnum;
     option: SelectorStructure;
     selectionClicked: EventEmitter<void>;
-    constructor(configuratorConnectorService: ConfiguratorConnectorService, iconService: IconCacheService, settingsService: SettingsService);
+    constructor(configuratorConnectorService: ConfiguratorConnectorService, iconService: IconCacheService, settingsService: ConfiguratorSettingsService);
     changeSelection(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<ProductConfiguratorOptionCheckboxComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<ProductConfiguratorOptionCheckboxComponent, "co-product-configurator-option-checkbox", never, { "option": { "alias": "option"; "required": false; }; }, { "selectionClicked": "selectionClicked"; }, never, never, false, never>;
@@ -3187,19 +2173,19 @@ declare class ProductConfiguratorOptionCheckboxComponent {
 
 declare class ProductConfiguratorSelectorOptionCheckboxModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<ProductConfiguratorSelectorOptionCheckboxModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<ProductConfiguratorSelectorOptionCheckboxModule, [typeof ProductConfiguratorOptionCheckboxComponent], [typeof PipesModule, typeof i3.CommonModule, typeof i3$1.IconModule], [typeof ProductConfiguratorOptionCheckboxComponent]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ProductConfiguratorSelectorOptionCheckboxModule, [typeof ProductConfiguratorOptionCheckboxComponent], [typeof i2.TranslationModule, typeof i3.CommonModule, typeof i3$1.IconModule], [typeof ProductConfiguratorOptionCheckboxComponent]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<ProductConfiguratorSelectorOptionCheckboxModule>;
 }
 
 declare class ProductConfiguratorSelectorOptionButtonComponent {
     configuratorConnectorService: ConfiguratorConnectorService;
     iconService: IconCacheService;
-    settingsService: SettingsService;
+    settingsService: ConfiguratorSettingsService;
     showClass(): boolean;
     readonly icons: typeof IconEnum;
     option: SelectorStructure;
     selectionClicked: EventEmitter<void>;
-    constructor(configuratorConnectorService: ConfiguratorConnectorService, iconService: IconCacheService, settingsService: SettingsService);
+    constructor(configuratorConnectorService: ConfiguratorConnectorService, iconService: IconCacheService, settingsService: ConfiguratorSettingsService);
     changeSelection(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<ProductConfiguratorSelectorOptionButtonComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<ProductConfiguratorSelectorOptionButtonComponent, "co-product-configurator-selector-option-button", never, { "option": { "alias": "option"; "required": false; }; }, { "selectionClicked": "selectionClicked"; }, never, never, false, never>;
@@ -3207,296 +2193,685 @@ declare class ProductConfiguratorSelectorOptionButtonComponent {
 
 declare class ProductConfiguratorSelectorOptionButtonModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<ProductConfiguratorSelectorOptionButtonModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<ProductConfiguratorSelectorOptionButtonModule, [typeof ProductConfiguratorSelectorOptionButtonComponent], [typeof PipesModule, typeof i3.CommonModule, typeof i3$1.IconModule], [typeof ProductConfiguratorSelectorOptionButtonComponent]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ProductConfiguratorSelectorOptionButtonModule, [typeof ProductConfiguratorSelectorOptionButtonComponent], [typeof i3.CommonModule, typeof i3$1.IconModule, typeof i2.TranslationModule], [typeof ProductConfiguratorSelectorOptionButtonComponent]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<ProductConfiguratorSelectorOptionButtonModule>;
 }
 
 declare class ProductConfiguratorSelectorOptionDropDownComponent {
     configuratorConnectorService: ConfiguratorConnectorService;
     iconService: IconCacheService;
-    settingsService: SettingsService;
+    settingsService: ConfiguratorSettingsService;
     showClass(): boolean;
     readonly icons: typeof IconEnum;
     options: SelectorStructure[];
     tileClass: string;
     selectionClicked: EventEmitter<SelectorStructure>;
-    constructor(configuratorConnectorService: ConfiguratorConnectorService, iconService: IconCacheService, settingsService: SettingsService);
+    constructor(configuratorConnectorService: ConfiguratorConnectorService, iconService: IconCacheService, settingsService: ConfiguratorSettingsService);
     onChange(event: Event): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<ProductConfiguratorSelectorOptionDropDownComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<ProductConfiguratorSelectorOptionDropDownComponent, "co-product-configurator-selector-option-dropdown", never, { "options": { "alias": "options"; "required": false; }; "tileClass": { "alias": "tileClass"; "required": false; }; }, { "selectionClicked": "selectionClicked"; }, never, never, false, never>;
 }
 
-declare class ProductConfiguratorSelectorOptionDropdownModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<ProductConfiguratorSelectorOptionDropdownModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<ProductConfiguratorSelectorOptionDropdownModule, [typeof ProductConfiguratorSelectorOptionDropDownComponent], [typeof PipesModule, typeof i3.CommonModule, typeof i3$1.IconModule], [typeof ProductConfiguratorSelectorOptionDropDownComponent]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<ProductConfiguratorSelectorOptionDropdownModule>;
+declare class ProductConfiguratorSelectorOptionDropdownModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProductConfiguratorSelectorOptionDropdownModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ProductConfiguratorSelectorOptionDropdownModule, [typeof ProductConfiguratorSelectorOptionDropDownComponent], [typeof i2.TranslationModule, typeof i3.CommonModule, typeof i3$1.IconModule], [typeof ProductConfiguratorSelectorOptionDropDownComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ProductConfiguratorSelectorOptionDropdownModule>;
+}
+
+declare class ProductConfiguratorSelectorOptionModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProductConfiguratorSelectorOptionModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ProductConfiguratorSelectorOptionModule, [typeof ProductConfiguratorSelectorOptionComponent], [typeof i2.TranslationModule, typeof i3.CommonModule, typeof ProductConfiguratorSelectorOptionTileModule, typeof ProductConfiguratorSelectorOptionCheckboxModule, typeof ProductConfiguratorSelectorOptionButtonModule, typeof ProductConfiguratorSelectorOptionDropdownModule], [typeof ProductConfiguratorSelectorOptionComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ProductConfiguratorSelectorOptionModule>;
+}
+
+declare class ProductConfiguratorSelectorModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProductConfiguratorSelectorModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ProductConfiguratorSelectorModule, [typeof ProductConfiguratorSelectorComponent], [typeof i2.TranslationModule, typeof i3.CommonModule, typeof i3$1.IconModule, typeof ProductConfiguratorSelectorOptionModule], [typeof ProductConfiguratorSelectorComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ProductConfiguratorSelectorModule>;
+}
+
+declare class ProductConfiguratorModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProductConfiguratorModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ProductConfiguratorModule, [typeof ProductConfiguratorComponent], [typeof i3.CommonModule, typeof i3$2.MatIconModule, typeof i4$1.MatButtonModule, typeof i3$1.CardModule, typeof SlideoutModule, typeof i3$1.PriceDisplayPipeModule, typeof i3$1.ButtonModule, typeof i3$1.InputTextModule, typeof i7.FormsModule, typeof i2.TranslationModule, typeof i3$1.IconModule, typeof i3$1.TooltipDirectiveModule, typeof ProductConfiguratorSelectorModule, typeof ConfigurationPresetModule], [typeof ProductConfiguratorComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ProductConfiguratorModule>;
+}
+
+declare class ConfiguratorModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfiguratorModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ConfiguratorModule, [typeof ConfiguratorComponent], [typeof i3.CommonModule, typeof ProgressBarModule, typeof ConfiguratorLoaderModule, typeof ConfiguratorDialogModule, typeof ConfigurationPresetDialogModule, typeof LiteSelectorModule, typeof ProductConfiguratorModule], [typeof ConfiguratorComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ConfiguratorModule>;
+}
+
+declare class ConfiguratorSceneLoaderComponent {
+    showClass: boolean;
+    loaderProgress: number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfiguratorSceneLoaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ConfiguratorSceneLoaderComponent, "co-configurator-scene-loader", never, { "loaderProgress": { "alias": "loaderProgress"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class ConfiguratorSceneLoaderModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfiguratorSceneLoaderModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ConfiguratorSceneLoaderModule, [typeof ConfiguratorSceneLoaderComponent], [typeof i3.CommonModule], [typeof ConfiguratorSceneLoaderComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ConfiguratorSceneLoaderModule>;
+}
+
+declare class CustomButton {
+    caption: string;
+    handler: Function;
+    data: any;
+    xPos: number;
+    yPos: number;
+    size: number;
+    opacity: number;
+    constructor(caption?: string, handler?: Function, data?: any);
+}
+
+declare class ElementButtonsComponent implements OnDestroy {
+    iconCache: IconCacheService;
+    private _elementRef;
+    private _settingsService;
+    showClass(): boolean;
+    readonly icon: typeof IconEnum;
+    disableMouse: boolean;
+    handleDocumentMouseUp(event: any): void;
+    handleDocumentMouseDown(event: any): void;
+    addButtons: CustomButton[];
+    customizeButtons: CustomButton[];
+    resizeButtons: CustomButton[];
+    elementPointer: ElementRef;
+    set elementPosition(value: Vector2);
+    customizeButtonClicked: EventEmitter<void>;
+    get elementPosition(): Vector2;
+    showCaptionAddButton: boolean;
+    private _elementPosition;
+    private _subs;
+    constructor(iconCache: IconCacheService, _elementRef: ElementRef, _settingsService: ConfiguratorSettingsService);
+    ngOnDestroy(): void;
+    private _repositionLine;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ElementButtonsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ElementButtonsComponent, "co-element-buttons", never, { "addButtons": { "alias": "addButtons"; "required": false; }; "customizeButtons": { "alias": "customizeButtons"; "required": false; }; "resizeButtons": { "alias": "resizeButtons"; "required": false; }; "elementPointer": { "alias": "elementPointer"; "required": false; }; "elementPosition": { "alias": "elementPosition"; "required": false; }; }, { "customizeButtonClicked": "customizeButtonClicked"; }, never, never, false, never>;
+}
+
+declare class ElementButtonsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ElementButtonsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ElementButtonsModule, [typeof ElementButtonsComponent], [typeof i3$1.IconModule, typeof i3.CommonModule], [typeof ElementButtonsComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ElementButtonsModule>;
+}
+
+declare class ElementToolbarComponent implements OnDestroy {
+    settingsService: ConfiguratorSettingsService;
+    iconCache: IconCacheService;
+    showClass(): boolean;
+    readonly icon: typeof IconEnum;
+    elementPointer: ElementRef;
+    hostClass: boolean;
+    editMenu: CustomButton[];
+    showPointer: boolean;
+    showSwap: boolean;
+    readonly deleteClicked: EventEmitter<any>;
+    readonly swapClicked: EventEmitter<any>;
+    readonly animationClicked: EventEmitter<any>;
+    showEditMenu: boolean;
+    get instantMenu(): boolean;
+    constructor(settingsService: ConfiguratorSettingsService, iconCache: IconCacheService);
+    ngOnDestroy(): void;
+    handleEditClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ElementToolbarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ElementToolbarComponent, "co-element-toolbar", never, { "editMenu": { "alias": "editMenu"; "required": false; }; "showPointer": { "alias": "showPointer"; "required": false; }; "showSwap": { "alias": "showSwap"; "required": false; }; }, { "deleteClicked": "deleteClicked"; "swapClicked": "swapClicked"; "animationClicked": "animationClicked"; }, never, never, false, never>;
 }
 
-declare class ProductConfiguratorSelectorOptionModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<ProductConfiguratorSelectorOptionModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<ProductConfiguratorSelectorOptionModule, [typeof ProductConfiguratorSelectorOptionComponent], [typeof PipesModule, typeof i3.CommonModule, typeof ProductConfiguratorSelectorOptionTileModule, typeof ProductConfiguratorSelectorOptionCheckboxModule, typeof ProductConfiguratorSelectorOptionButtonModule, typeof ProductConfiguratorSelectorOptionDropdownModule], [typeof ProductConfiguratorSelectorOptionComponent]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<ProductConfiguratorSelectorOptionModule>;
+declare class ElementToolbarModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ElementToolbarModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ElementToolbarModule, [typeof ElementToolbarComponent], [typeof i2.TranslationModule, typeof i3$1.IconModule, typeof i3.CommonModule], [typeof ElementToolbarComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ElementToolbarModule>;
 }
 
-declare class ProductConfiguratorSelectorModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<ProductConfiguratorSelectorModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<ProductConfiguratorSelectorModule, [typeof ProductConfiguratorSelectorComponent], [typeof PipesModule, typeof i3.CommonModule, typeof i3$1.IconModule, typeof ProductConfiguratorSelectorOptionModule], [typeof ProductConfiguratorSelectorComponent]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<ProductConfiguratorSelectorModule>;
+declare class SceneOptionButtonInterface {
+    id: number;
+    elementId: string;
+    label?: string;
+    class?: string;
+    tooltip?: string;
+    image?: string | SafeHtml;
+    order?: number;
+    toggle?: boolean;
+    tooltipActive?: string;
+    active?: boolean;
+    object?: any;
+    click?: Function;
+    show?: boolean;
+    icon?: IconEnum;
+    children?: SceneOptionButtonInterface[];
 }
 
-declare class ProductConfiguratorModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<ProductConfiguratorModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<ProductConfiguratorModule, [typeof ProductConfiguratorComponent], [typeof i3.CommonModule, typeof i3$2.MatIconModule, typeof i4$1.MatButtonModule, typeof i3$1.CardModule, typeof SlideoutModule, typeof i3$1.PriceDisplayPipeModule, typeof i3$1.ButtonModule, typeof i3$1.InputTextModule, typeof i7.FormsModule, typeof PipesModule, typeof i3$1.IconModule, typeof i3$1.TooltipDirectiveModule, typeof ProductConfiguratorSelectorModule, typeof ConfigurationPresetModule], [typeof ProductConfiguratorComponent]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<ProductConfiguratorModule>;
+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>;
 }
 
-declare class ConfigurationPresetDialogComponent implements OnDestroy {
+declare class SceneOptionsComponent implements OnDestroy {
     iconService: IconCacheService;
-    private _configuringService;
-    private _configuratorConnectorService;
-    private _dictionaryService;
-    private _appEventService;
-    readonly icons: typeof IconEnum;
-    readonly presetDialogMode: typeof PresetDialogMode;
+    private _sceneOptionsService;
     showClass(): boolean;
-    showDialog: boolean;
-    instanceIdInput: string;
-    dialogMode: PresetDialogMode;
-    showValidationErrors: boolean;
-    validationError: string;
+    readonly icons: typeof IconEnum;
+    buttons: SceneOptionButtonInterface[];
     private _subs;
-    constructor(iconService: IconCacheService, _configuringService: ConfiguringService, _configuratorConnectorService: ConfiguratorConnectorService, _dictionaryService: DictionaryService, _appEventService: AppEventService);
+    private _childrenShowing;
+    constructor(iconService: IconCacheService, _sceneOptionsService: SceneOptionsService);
     ngOnDestroy(): void;
-    handleOpenDialog(mode: PresetDialogMode): void;
-    handleCloseClick(): void;
-    handleCopySuccess(): void;
-    loadConfiguration(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<ConfigurationPresetDialogComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<ConfigurationPresetDialogComponent, "co-configuration-preset-dialog", never, {}, {}, never, never, false, never>;
+    handleClick(event: MouseEvent, button: SceneOptionButtonInterface): void;
+    handleShowChildren(event: MouseEvent, button: SceneOptionButtonInterface): void;
+    getIcon(buttonIcon: IconEnum): SafeHtml;
+    private _addButton;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SceneOptionsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SceneOptionsComponent, "co-scene-options", never, {}, {}, never, never, false, never>;
 }
 
-declare class ConfigurationPresetDialogModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<ConfigurationPresetDialogModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<ConfigurationPresetDialogModule, [typeof ConfigurationPresetDialogComponent], [typeof PipesModule, typeof i3$1.ButtonModule, typeof i3$1.IconModule, typeof i3$1.InputTextModule, typeof i4.CdkCopyToClipboard], [typeof ConfigurationPresetDialogComponent]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<ConfigurationPresetDialogModule>;
+declare class SelectionsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SelectionsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SelectionsModule, [typeof SceneOptionsComponent], [typeof i3.CommonModule, typeof i3$1.IconModule, typeof i2.TranslationModule], [typeof SceneOptionsComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SelectionsModule>;
+}
+
+declare enum ConfigurationKey {
+    DimensioningUnit = "dimUnit",
+    DimensioningSquareUnit = "dimSqUnit",
+    AngleUnit = "angleUnit",
+    CmStep = "cmStep",
+    MStep = "mStep",
+    MmStep = "mmStep",
+    AngleLabelDistanceInCm = "angleLabelDistanceCm",
+    WallHeight = "wallHeight",
+    WallThickness = "wallThickness",
+    MaxWallHeight = "maxWallHeight",
+    MaxWallThickness = "maxWallThickness",
+    MaxWallLength = "maxWallLength",
+    MinWallLength = "minWallLength",
+    WallSnapping = "wallSnapping",
+    CornerSnapping = "cornerSnapping",
+    ShowObjectDistances = "showObjectDistances",
+    ShowObjectMeasurements = "showObjectMeasurements",
+    ShowDetailedWallMeasurements = "showDetailedWallMeasurements",
+    ShowWallItemMeasurements = "showWallItemMeasurements",
+    ShowWallMeasurements = "showWallMeasurements",
+    ShowCornerAngles = "showCornerAngles",
+    RotationSnappingEnabled = "RotationSnappingEnabled",
+    DisplayCustomShapeNames = "DisplayCustomShapeNames",
+    ShowWalkThroughCameraControls = "ShowWalkThroughCameraControls",
+    ShowInteriorLights = "ShowInteriorLights",
+    InteriorLightIntensity = "InteriorLightIntensity",
+    ShowLightingControls = "ShowLightingControls",
+    ShowLightplansDialog = "ShowLightplansDialog",
+    WalkThroughCameraFoV = "WalkThroughCameraFoV",
+    WalkThroughCameraAspectRatio = "WalkThroughCameraAspectRatio",
+    WalkThroughCameraFocus = "WalkThroughCameraFocus",
+    ShowPostProcessingSettings = "showPostProcessingSettings",
+    ShowWalls = "ShowWalls",
+    ShowCeiling = "ShowCeiling",
+    IsLimited = "IsLimited",
+    EnableTouch = "EnableTouch",
+    CameraFOV = "CameraFOV"
 }
 
-declare class ThreedselectorModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<ThreedselectorModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<ThreedselectorModule, [typeof ThreedselectorComponent], [typeof LiteSelectorModule, typeof ProductConfiguratorModule, typeof i3.CommonModule, typeof ConfigurationPresetDialogModule], [typeof ThreedselectorComponent]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<ThreedselectorModule>;
+interface ConfigurationData {
+    [ConfigurationKey.DimensioningUnit]?: string;
+    [ConfigurationKey.DimensioningSquareUnit]?: string;
+    [ConfigurationKey.AngleUnit]?: string;
+    [ConfigurationKey.CmStep]?: number;
+    [ConfigurationKey.MStep]?: number;
+    [ConfigurationKey.MmStep]?: number;
+    [ConfigurationKey.AngleLabelDistanceInCm]?: number;
+    [ConfigurationKey.WallHeight]?: number;
+    [ConfigurationKey.WallThickness]?: number;
+    [ConfigurationKey.MaxWallHeight]?: number;
+    [ConfigurationKey.MaxWallThickness]?: number;
+    [ConfigurationKey.MaxWallLength]?: number;
+    [ConfigurationKey.MinWallLength]?: number;
+    [ConfigurationKey.WallSnapping]?: boolean;
+    [ConfigurationKey.CornerSnapping]?: boolean;
+    [ConfigurationKey.ShowObjectDistances]?: boolean;
+    [ConfigurationKey.ShowObjectMeasurements]?: boolean;
+    [ConfigurationKey.ShowDetailedWallMeasurements]?: boolean;
+    [ConfigurationKey.ShowWallItemMeasurements]?: boolean;
+    [ConfigurationKey.ShowWallMeasurements]?: boolean;
+    [ConfigurationKey.ShowCornerAngles]?: boolean;
+    [ConfigurationKey.RotationSnappingEnabled]?: boolean;
+    [ConfigurationKey.DisplayCustomShapeNames]?: boolean;
+    [ConfigurationKey.ShowInteriorLights]?: boolean;
+    [ConfigurationKey.InteriorLightIntensity]?: number;
+    [ConfigurationKey.ShowWalkThroughCameraControls]?: boolean;
+    [ConfigurationKey.ShowLightingControls]?: boolean;
+    [ConfigurationKey.ShowLightplansDialog]?: boolean;
+    [ConfigurationKey.WalkThroughCameraFoV]?: number;
+    [ConfigurationKey.WalkThroughCameraAspectRatio]?: number;
+    [ConfigurationKey.WalkThroughCameraFocus]?: number;
+    [ConfigurationKey.ShowPostProcessingSettings]?: boolean;
+    [ConfigurationKey.ShowWalls]?: boolean;
+    [ConfigurationKey.ShowCeiling]?: boolean;
+    [ConfigurationKey.IsLimited]?: boolean;
+    [ConfigurationKey.EnableTouch]?: boolean;
+    [ConfigurationKey.CameraFOV]?: number;
 }
 
-declare class ConfiguratorModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<ConfiguratorModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<ConfiguratorModule, [typeof ConfiguratorComponent], [typeof i3.CommonModule, typeof ProgressBarModule, typeof ConfiguratorLoaderModule, typeof ConfiguratorDialogModule, typeof ThreedselectorModule], [typeof ConfiguratorComponent]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<ConfiguratorModule>;
+declare class ConfigurationService {
+    private _data;
+    onChange: BehaviorSubject<{}>;
+    setValue<T extends ConfigurationKey>(key: T, value: ConfigurationData[T]): void;
+    getValue<T extends ConfigurationKey>(key: T): ConfigurationData[T];
+    get(): ConfigurationData;
+    set(data: ConfigurationData): void;
+    getDistanceStep(): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfigurationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ConfigurationService>;
 }
 
-declare class ConfiguratorSceneLoaderComponent {
-    showClass(): boolean;
-    loaderProgress: number;
-    static ɵfac: i0.ɵɵFactoryDeclaration<ConfiguratorSceneLoaderComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<ConfiguratorSceneLoaderComponent, "co-configurator-scene-loader", never, { "loaderProgress": { "alias": "loaderProgress"; "required": false; }; }, {}, never, never, false, never>;
+declare class ConfiguratorRotationService implements OnDestroy {
+    private _configService;
+    private _sceneService;
+    private _settingsService;
+    objectRotated: Subject<void>;
+    sliderValue: number;
+    private _subs;
+    private _mouseXOnMouseDown;
+    private _targetRotationOnMouseDownX;
+    private _targetRotationX;
+    private _mouseX;
+    private _itemToRotate;
+    private _renderInterval;
+    private _renderTimeout;
+    private _timeToRender;
+    private _moveFactor;
+    constructor(_configService: ConfigurationService, _sceneService: ConfiguratorSceneService, _settingsService: ConfiguratorSettingsService);
+    ngOnDestroy(): void;
+    rotate(item: Object3D, from: Vector3, to: Vector3, ccw?: boolean): Vector3;
+    enableRotationFor(item: Object3D): void;
+    private _handleMouseDown;
+    private _handleMouseMove;
+    private _handleSliderChange;
+    private _handleMouseUp;
+    private _handleMouseOut;
+    private _handleTouchStart;
+    private _handleTouchMove;
+    private _handleTouchEnd;
+    private _handleTouchCancel;
+    private _removeMouseEvents;
+    private _removeTouchEvents;
+    private _renderForAmountOfTime;
+    private _doRender;
+    private _removeListeners;
+    private _addListeners;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfiguratorRotationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ConfiguratorRotationService>;
 }
 
-declare class ConfiguratorSceneLoaderModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<ConfiguratorSceneLoaderModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<ConfiguratorSceneLoaderModule, [typeof ConfiguratorSceneLoaderComponent], [typeof i3.CommonModule], [typeof ConfiguratorSceneLoaderComponent]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<ConfiguratorSceneLoaderModule>;
+declare enum TextureType {
+    Basic = 0,
+    Image = 1,
+    CustomPattern = 2,
+    PBR = 3,
+    SHADOW = 4
 }
 
-declare class CustomButton {
-    caption: string;
-    handler: Function;
-    data: any;
-    xPos: number;
-    yPos: number;
-    size: number;
-    opacity: number;
-    constructor(caption?: string, handler?: Function, data?: any);
+interface TextureInterface {
+    name?: string;
+    type?: string | TextureType;
+    url?: string;
+    materializeUrl?: string;
+    bumpMap?: string;
+    bumpScale?: number;
+    roughness?: number;
+    roughnessMap?: string;
+    normalMap?: string;
+    alphaMap?: string;
+    repeatX?: number;
+    repeatY?: number;
+    metalness?: number;
+    metalnessMap?: string;
+    aoMapIntensity?: number;
+    aoMap?: string;
+    data?: any;
+    color?: string;
+    emissive?: string;
+    show?: boolean;
+    default?: boolean;
+    surfaces?: string[];
+    offset?: THREE.Vector2;
+    scale?: number;
+    rotation?: number;
+    stretch?: boolean;
+    height?: number;
+    width?: number;
+    tileSize?: number;
+    tileRotation?: number;
+    useStandalone?: boolean;
+    defaultStandalone?: boolean;
+    mirror?: boolean;
+    simplePlane?: boolean;
+    toneMapped?: boolean;
+    transparent?: boolean;
+    opacity?: number;
+    side?: number;
+    depthWrite?: boolean;
+    depthTest?: boolean;
+}
+
+interface AdjustableElementInterface {
+    identifier: string;
+    connector: string;
+    connectedNodeId: number;
 }
 
-declare class ElementButtonsComponent implements OnDestroy {
-    iconCache: IconCacheService;
-    private _elementRef;
-    private _settingsService;
-    showClass(): boolean;
-    readonly icon: typeof IconEnum;
-    disableMouse: boolean;
-    handleDocumentMouseUp(event: any): void;
-    handleDocumentMouseDown(event: any): void;
-    addButtons: CustomButton[];
-    customizeButtons: CustomButton[];
-    resizeButtons: CustomButton[];
-    elementPointer: ElementRef;
-    set elementPosition(value: Vector2);
-    customizeButtonClicked: EventEmitter<void>;
-    get elementPosition(): Vector2;
-    showCaptionAddButton: boolean;
-    private _elementPosition;
-    private _subs;
-    constructor(iconCache: IconCacheService, _elementRef: ElementRef, _settingsService: SettingsService);
-    ngOnDestroy(): void;
-    private _repositionLine;
-    static ɵfac: i0.ɵɵFactoryDeclaration<ElementButtonsComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<ElementButtonsComponent, "co-element-buttons", never, { "addButtons": { "alias": "addButtons"; "required": false; }; "customizeButtons": { "alias": "customizeButtons"; "required": false; }; "resizeButtons": { "alias": "resizeButtons"; "required": false; }; "elementPointer": { "alias": "elementPointer"; "required": false; }; "elementPosition": { "alias": "elementPosition"; "required": false; }; }, { "customizeButtonClicked": "customizeButtonClicked"; }, never, never, false, never>;
+interface Skin {
+    [face: string]: SkinFragment;
 }
-
-declare class ElementButtonsModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<ElementButtonsModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<ElementButtonsModule, [typeof ElementButtonsComponent], [typeof i3$1.IconModule, typeof i3.CommonModule], [typeof ElementButtonsComponent]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<ElementButtonsModule>;
+interface SkinFragment {
+    color?: number;
+    texture?: Texture;
 }
 
-declare class ElementToolbarComponent implements OnDestroy {
-    settingsService: SettingsService;
-    iconCache: IconCacheService;
-    showClass(): boolean;
-    readonly icon: typeof IconEnum;
-    elementPointer: ElementRef;
-    hostClass: boolean;
-    editMenu: CustomButton[];
-    showPointer: boolean;
-    showSwap: boolean;
-    readonly deleteClicked: EventEmitter<any>;
-    readonly swapClicked: EventEmitter<any>;
-    readonly animationClicked: EventEmitter<any>;
-    showEditMenu: boolean;
-    get instantMenu(): boolean;
-    constructor(settingsService: SettingsService, iconCache: IconCacheService);
-    ngOnDestroy(): void;
-    handleEditClick(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<ElementToolbarComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<ElementToolbarComponent, "co-element-toolbar", never, { "editMenu": { "alias": "editMenu"; "required": false; }; "showPointer": { "alias": "showPointer"; "required": false; }; "showSwap": { "alias": "showSwap"; "required": false; }; }, { "deleteClicked": "deleteClicked"; "swapClicked": "swapClicked"; "animationClicked": "animationClicked"; }, never, never, false, never>;
+/** Meta data for items. */
+interface Metadata {
+    itemName?: string;
+    itemDescription?: string;
+    itemType?: number;
+    /**
+     * InstanceId
+     */
+    itemId?: string;
+    originalItemId?: string;
+    /**
+     * Sku
+     */
+    itemIdentifier?: string;
+    goodId?: string;
+    goodType?: string;
+    isCustom?: boolean;
+    locked?: boolean;
+    configurable?: boolean;
+    ione?: boolean;
+    position?: Vector3;
+    rotation?: number | Euler;
+    scale?: Vector3;
+    centerPivot?: boolean;
+    ignoreInvisible?: boolean;
+    updatePivotOnCreate?: boolean;
+    elementConfiguration?: AdjustableElementInterface[];
+    obsolete?: boolean;
+    thirdPartyModel?: boolean;
+    usePivot?: boolean;
+    decos?: DecoNode[];
+    selections?: Selection[];
+    canElevate?: boolean;
+    onWall?: boolean;
+    modelUrl?: string;
+    scalable?: boolean;
+    scalePercentage?: number;
+    resizable?: boolean;
+    elevation?: number;
+    elevationFixed?: boolean;
+    elevationAdjustable?: boolean;
+    schema?: string;
+    assetPath?: string;
+    texture?: Texture;
+    textureAssetName?: string;
+    skin?: Skin;
+    frameColor?: number;
+    doorColor?: number;
+    windowColor?: THREE.Color;
+    doorpost?: boolean;
+    isGlass?: boolean;
+    itemGroup?: any;
+    canRotateX?: boolean;
+    canRotateY?: boolean;
+    canRotateZ?: boolean;
+    canScaleX?: boolean;
+    canScaleY?: boolean;
+    canScaleZ?: boolean;
+    colorable?: boolean;
+    default180?: boolean;
+    objectUUID?: string;
+    conversionGTMSend?: boolean;
+    conversionSubmittedPrice?: string;
+    hdecoType?: string;
+    opening?: {
+        show: boolean;
+        double: boolean;
+        invertDirection: boolean;
+        invertSide: boolean;
+    };
 }
 
-declare class ElementToolbarModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<ElementToolbarModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<ElementToolbarModule, [typeof ElementToolbarComponent], [typeof PipesModule, typeof i3$1.IconModule, typeof i3.CommonModule], [typeof ElementToolbarComponent]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<ElementToolbarModule>;
+declare class Texture {
+    name: string;
+    type: TextureType;
+    url: string;
+    materializeUrl: string;
+    bumpMap: string;
+    bumpScale: number;
+    roughness: number;
+    roughnessMap: string;
+    normalMap: string;
+    repeatX: number;
+    repeatY: number;
+    metalness: number;
+    metalnessMap: string;
+    aoMapIntensity: number;
+    aoMap: string;
+    alphaMap: string;
+    color: string;
+    emissive: string;
+    data: any;
+    surfaces: string[];
+    offset: THREE.Vector2;
+    scale: number;
+    rotation: number;
+    stretch: boolean;
+    show: boolean;
+    default: boolean;
+    height: number;
+    width: number;
+    tileSize: number;
+    tileRotation: number;
+    dimensions: Vector2;
+    offsetScale: number;
+    useStandalone: boolean;
+    defaultStandalone: boolean;
+    mirror: boolean;
+    simplePlane: boolean;
+    toneMapped: boolean;
+    transparent: boolean;
+    opacity: number;
+    side: THREE.Side;
+    depthWrite: boolean;
+    depthTest: boolean;
+    metadata?: Metadata;
+    static CreateModelFromInterface(modelInterface: TextureInterface): Texture;
 }
 
-declare class SceneOptionsComponent implements OnDestroy {
-    iconService: IconCacheService;
+declare class FloorPlaneService implements OnDestroy {
+    private _settingsService;
+    private _sceneService;
     private _sceneOptionsService;
-    showClass(): boolean;
-    readonly icons: typeof IconEnum;
-    buttons: SceneOptionButtonInterface[];
+    get floorPlane(): Object3D;
+    floorPlaneCreated: BehaviorSubject<boolean>;
+    floorTextures: Texture[];
+    private _standaloneFloors;
+    private _floorPlane;
     private _subs;
-    private _childrenShowing;
-    constructor(iconService: IconCacheService, _sceneOptionsService: SceneOptionsService);
+    constructor(_settingsService: ConfiguratorSettingsService, _sceneService: ConfiguratorSceneService, _sceneOptionsService: SceneOptionsService);
     ngOnDestroy(): void;
-    handleClick(event: MouseEvent, button: SceneOptionButtonInterface): void;
-    handleShowChildren(event: MouseEvent, button: SceneOptionButtonInterface): void;
-    getIcon(buttonIcon: IconEnum): SafeHtml;
-    private _addButton;
-    static ɵfac: i0.ɵɵFactoryDeclaration<SceneOptionsComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<SceneOptionsComponent, "co-scene-options", never, {}, {}, never, never, false, never>;
-}
-
-declare class SelectionsModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<SelectionsModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<SelectionsModule, [typeof SceneOptionsComponent], [typeof i3.CommonModule, typeof i3$1.IconModule, typeof PipesModule], [typeof SceneOptionsComponent]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<SelectionsModule>;
+    createFloorPlane(rawFloors: TextureInterface$1[]): Promise<void>;
+    getCenterFloorPlane(): Vector3;
+    getDimensions(scale?: number): {
+        x: {
+            min: number;
+            max: number;
+        };
+        y: {
+            min: number;
+            max: number;
+        };
+    };
+    getPlaneSize(): Vector3;
+    private _getStandaloneFloorSize;
+    private _generateFloorPlane;
+    private _createFloorMaterial;
+    private _upsertFloorButtons;
+    private _changeStandaloneFloor;
+    private _setFloorTexture;
+    private _updateFloorMaterial;
+    private _setUpdatedMaterial;
+    private _getMaterials;
+    private _createTexture;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FloorPlaneService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FloorPlaneService>;
 }
 
-declare class ConfiguratorSceneComponent implements OnDestroy {
-    private settingsService;
+declare class DimensionsService implements OnDestroy {
     private _sceneService;
-    private _lightService;
-    private _lightPresetService;
-    private _sceneEventService;
-    private _initializerService;
-    showClass(): boolean;
+    private _fontService;
+    private _itemService;
+    set enabled(value: boolean);
+    get enabled(): boolean;
+    private readonly _offSet;
+    private readonly _labelOffSet;
+    private readonly _nameHeightArrow;
+    private readonly _nameWidthArrow;
+    private readonly _nameDepthArrow;
+    private readonly _headLength;
+    private readonly _headWidth;
+    private readonly _defaultColor;
+    private _subs;
+    private _dimensions;
+    private _enabled;
+    constructor(_sceneService: ConfiguratorSceneService, _fontService: FontService, _itemService: ConfiguratorItemService);
+    ngOnDestroy(): void;
+    private _renderDimensions;
+    private _removeDimensionsOfNotExistingFurniture;
+    private _removeDimensions;
+    private _positionDimensions;
+    private _createDimensions;
+    private _createLabel;
+    private _getBoxSize;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DimensionsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DimensionsService>;
+}
+
+declare class ConfiguratorSceneComponent implements AfterViewInit, OnDestroy {
+    private _settingsService;
+    private _rotationService;
+    private _dynamicCameraService;
+    private _sceneService;
+    private _eventService;
+    private _cameraService;
+    private _itemService;
+    private _buildFurnitureService;
+    private _sceneOptionsService;
+    private _dimensionsService;
+    private _floorService;
     canvasElement: ElementRef;
+    elementToolbar: ElementToolbarComponent;
+    showSceneBuildLoader: boolean;
+    showClass: boolean;
+    totalSteps: number;
+    currentStep: number;
+    showSwapButton: boolean;
+    selectedElementPosition: Vector2;
+    editElementMenu: CustomButton[];
+    editAddButtons: CustomButton[];
+    setSceneBuildLoader: boolean;
+    loaderProgress: number;
+    showElementToolbar: boolean;
+    animateEditAddButtons: boolean;
+    enabledDownloadDialog: boolean;
+    development: boolean;
+    showDownloadDialog: boolean;
+    showCameraSettingsDialog: boolean;
     private _subs;
-    constructor(settingsService: SettingsService, _sceneService: SceneService, _lightService: LightsService, _lightPresetService: LightPresetsService, _sceneEventService: SceneEventService, _initializerService: AppInitializerService);
+    private _firstBuild;
+    private _selectedElementObject;
+    private _buildResult;
+    constructor(_settingsService: ConfiguratorSettingsService, _rotationService: ConfiguratorRotationService, _dynamicCameraService: ConfiguratorDynamicCameraService, _sceneService: ConfiguratorSceneService, _eventService: ConfiguratorEventService, _cameraService: ConfiguratorCameraService, _itemService: ConfiguratorItemService, _buildFurnitureService: SwitchBuildFurnitureService, _sceneOptionsService: SceneOptionsService, _dimensionsService: DimensionsService, _floorService: FloorPlaneService);
+    ngAfterViewInit(): void;
     ngOnDestroy(): void;
-    loadScene(ready: boolean): void;
+    swapElement(): void;
+    deleteElement(): void;
+    openAnimationSidebar(): void;
+    handleCustomizeClick(): void;
+    private _handleFirstBuildStandalone;
+    private _loaderProcessUpdate;
+    private _animateProgress;
+    private _removeAddButtons;
+    private _resetElementPosition;
+    private _repositionButtons;
+    private _handleAddButtonClick;
+    private _resetSelectedElement;
+    private _removeAllButtons;
+    private _repositionButton;
+    private _showPlusButtonsBriefly;
+    private _createDownloadButton;
+    private _createCameraSettingsButton;
+    private _createMeasurementsButton;
+    private _downloadCurrentBuild;
+    private _openCameraSettingsDialog;
+    private _handleShowMeasurements;
     static ɵfac: i0.ɵɵFactoryDeclaration<ConfiguratorSceneComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<ConfiguratorSceneComponent, "co-configurator-scene", never, {}, {}, never, never, false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ConfiguratorSceneComponent, "co-configurator-scene", never, { "showSceneBuildLoader": { "alias": "showSceneBuildLoader"; "required": false; }; }, {}, never, never, false, never>;
 }
 
 declare class ConfiguratorSceneModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<ConfiguratorSceneModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<ConfiguratorSceneModule, [typeof ConfiguratorSceneComponent], never, [typeof ConfiguratorSceneComponent]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ConfiguratorSceneModule, [typeof ConfiguratorSceneComponent], [typeof ConfiguratorSceneLoaderModule, typeof SelectionsModule, typeof ElementToolbarModule, typeof ElementButtonsModule, typeof ConfiguratorDialogModule], [typeof ConfiguratorSceneComponent]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<ConfiguratorSceneModule>;
 }
 
-declare class Builder {
-    selectionsReceived: BehaviorSubject<Selection[]>;
-    articleLoaded: BehaviorSubject<Article>;
-    decosReceived: BehaviorSubject<DecoNode[]>;
-    answersReceived: BehaviorSubject<Answer[]>;
-    modelLoaded: BehaviorSubject<THREE.Object3D>;
-    set debug(value: Function);
-    get debug(): Function;
-    private _scene;
-    private _instanceId;
-    private _sku;
-    private _goodId;
-    private _selections;
-    private _answers;
-    private _decos;
-    private _placedAdjustables;
-    private _placedAddables;
-    private _adjustables;
-    private _addables;
-    private _debug;
-    private _imageCache;
-    private _boFactory;
-    private _source;
-    private _threedUtils;
-    private _variationHelper;
-    private _articleCache;
-    private _configuratorService;
-    private _buildFurnitureService;
-    private _loadFurnitureService;
-    private _configuratorConnectorService;
+declare enum ArFeature {
+    PlaneDetection = "PlaneDetection",
+    PlaneDetectionHitTest = "PlaneDetectionHitTest",
+    DefaultHitTest = "DefaultHitTest",
+    AnchoredHitTest = "AnchoredHitTest",
+    CPUDepthHitTest = "CPUDepthHitTest",
+    GPUDepthHitTest = "GPUDepthHitTest",
+    CPUDepthOcclusion = "CPUDepthOcclusion",
+    GPUDepthOcclusion = "GPUDepthOcclusion",
+    LightEstimation = "LightEstimation",
+    ReflectionCubeMap = "ReflectionCubeMap"
+}
+
+/**
+ This file is a modified version of THREE.OrbitControls
+ Contributors:
+ * @author qiao / https://github.com/qiao
+ * @author mrdoob / http://mrdoob.com
+ * @author alteredq / http://alteredqualia.com/
+ * @author WestLangley / http://github.com/WestLangley
+ * @author erich666 / http://erichaines.com
+ */
+declare let Controls: (camera: any, domElement: any) => void;
+
+declare class Reticle extends Object3D {
+    private _rayCaster;
+    /**
+     * @param {XRSession} xrSession
+     * @param {THREE.Camera} camera
+     */
     constructor();
-    initNewBuild(scene: Scene, options?: Options, sku?: string, instanceId?: string, goodId?: number): Promise<THREE.Object3D>;
-    buildWithData(options?: Options, selections?: Selection[], decos?: DecoNode[], assetUrl?: string, cdnUrl?: string, schema?: string): Promise<THREE.Object3D>;
-    init(scene: Scene, options?: Options): void;
-    buildModel(sku?: string, instanceId?: string, goodId?: number): Promise<THREE.Object3D>;
-    buildModelFromData(selections: Selection[], decos: DecoNode[], assetUrl: string, cdnUrl: string, schema: string): Promise<THREE.Object3D>;
-    initNodeInstance(goodId: number): Promise<any>;
-    destroy(): void;
-    selectSelection(selection: Selection): Promise<void>;
-    getQuestionAndAnswers(publicationCode?: number): Promise<void>;
-    selectAnswer(answer: Answer): Promise<void>;
-    getImageForSelectionOrAnswer(object: Selection | Answer): Promise<string>;
-    _cleanUp(): void;
-    private _handleResponseData;
-    private _preloadMaterials;
-    private _setInstanceId;
-    private _prepareConfiguration;
-    private _downloadAsset;
-    private _build;
-    private _prepareTheSelections;
     /**
-     * Returns the materialId of the parent up the tree until presentionlevel 1 is reached
-     * @param id
-     * @private
+     * Fires a hit test in the middle of the screen and places the reticle
+     * upon the surface if found.
+     *
+     * @param {XRCoordinateSystem} frameOfRef
      */
-    private _getMaterialIdFromParent;
-    private _createAdjustable;
-    private _createAddable;
-    private _placeAddables;
-    private _createUniqueName;
-    private _getGoodIdFromSku;
-    private _getArticle;
-    private _getSelections;
-    private _getDecos;
-    private _linkSelectionsAndDecos;
-    private _getVariations;
-    private _loadVariations;
-    private _getAdjustables;
-    private _updatePivot;
-    private _reset;
-    private _log;
-    static ɵfac: i0.ɵɵFactoryDeclaration<Builder, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<Builder>;
-}
-
-export { AnswerCardComponent, AnswerCardModule, AnswersInfoDialogComponent, AnswersInfoDialogModule, AnswersSlideoutComponent, AnswersSlideoutModule, Builder, CoSummaryLine, CoSummaryLineModule, ColorFilterComponent, ColorFilterModule, ConfigurationResultObject, ConfiguratorCameraSettingsComponent, ConfiguratorComponent, ConfiguratorDialogModule, ConfiguratorErrorDialogComponent, ConfiguratorErrorMessage, ConfiguratorExportDialogComponent, ConfiguratorLoaderComponent, ConfiguratorLoaderModule, ConfiguratorModule, ConfiguratorSceneComponent, ConfiguratorSceneLoaderComponent, ConfiguratorSceneLoaderModule, ConfiguratorSceneModule, ConfiguringService, ElementButtonsComponent, ElementButtonsModule, ElementToolbarComponent, ElementToolbarModule, ImageZoomComponent, ImageZoomModule, LiteSelectorComponent, LiteSelectorModule, ProductConfiguratorComponent, ProductConfiguratorModule, ProductConfiguratorOptionCheckboxComponent, ProductConfiguratorSelectorComponent, ProductConfiguratorSelectorModule, ProductConfiguratorSelectorOptionButtonComponent, ProductConfiguratorSelectorOptionButtonModule, ProductConfiguratorSelectorOptionCheckboxModule, ProductConfiguratorSelectorOptionComponent, ProductConfiguratorSelectorOptionDropDownComponent, ProductConfiguratorSelectorOptionDropdownModule, ProductConfiguratorSelectorOptionModule, ProductConfiguratorSelectorOptionTileComponent, ProductConfiguratorSelectorOptionTileModule, ProgressBarComponent, ProgressBarModule, SceneOptionsComponent, SceneService, SelectionsModule, SelectionsSummaryComponent, SelectionsSummaryLineComponent, SelectionsSummaryModule, TagFilterComponent, TagFilterModule, ThreedselectorComponent, ThreedselectorModule };
+    update(session: any, camera: any, frameOfRef: any): Promise<void>;
+    toggleValidPosition(valid: boolean): void;
+}
+
+declare class ArPositionIndicator extends Object3D {
+    constructor(boundingBox: Box3);
+}
+
+export { AnswerCardComponent, AnswerCardModule, AnswersInfoDialogComponent, AnswersInfoDialogModule, AnswersSlideoutComponent, AnswersSlideoutModule, ArFeature, ArPositionIndicator, CoSummaryLine, CoSummaryLineModule, ColorFilterComponent, ColorFilterModule, ConfigurationPresetComponent, ConfigurationPresetModule, ConfigurationResultObject, ConfiguratorArService, ConfiguratorCameraService, ConfiguratorCameraSettingsComponent, ConfiguratorComponent, ConfiguratorConnectorService, ConfiguratorDialogModule, ConfiguratorErrorDialogComponent, ConfiguratorErrorMessage, ConfiguratorEventService, ConfiguratorExportDialogComponent, ConfiguratorLoaderComponent, ConfiguratorLoaderModule, ConfiguratorModule, ConfiguratorSceneComponent, ConfiguratorSceneLoaderComponent, ConfiguratorSceneLoaderModule, ConfiguratorSceneModule, ConfiguratorSceneService, ConfiguratorVrService, ConfiguratorXrService, ConfiguringService, Controls, ElementButtonsComponent, ElementButtonsModule, ElementToolbarComponent, ElementToolbarModule, ImageZoomComponent, ImageZoomModule, LiteSelectorComponent, LiteSelectorModule, ProductConfiguratorComponent, ProductConfiguratorModule, ProductConfiguratorOptionCheckboxComponent, ProductConfiguratorSelectorComponent, ProductConfiguratorSelectorModule, ProductConfiguratorSelectorOptionButtonComponent, ProductConfiguratorSelectorOptionButtonModule, ProductConfiguratorSelectorOptionCheckboxModule, ProductConfiguratorSelectorOptionComponent, ProductConfiguratorSelectorOptionDropDownComponent, ProductConfiguratorSelectorOptionDropdownModule, ProductConfiguratorSelectorOptionModule, ProductConfiguratorSelectorOptionTileComponent, ProductConfiguratorSelectorOptionTileModule, ProgressBarComponent, ProgressBarModule, Reticle, SceneOptionsComponent, SelectionsModule, SelectionsSummaryComponent, SelectionsSummaryLineComponent, SelectionsSummaryModule, TagFilterComponent, TagFilterModule, XrMode };