@colijnit/configurator 261.1.1 → 261.20.1

package/index.d.ts

@@ -0,0 +1,3299 @@
+import * as i0 from '@angular/core';
+import { OnDestroy, OnInit, EventEmitter, PipeTransform, TemplateRef, ElementRef, QueryList, AfterViewInit, ChangeDetectorRef } 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 { DecoNode } from '@colijnit/configuratorapi/build/model/deco-node';
+import { Selection } from '@colijnit/configuratorapi/build/model/selection';
+import { BehaviorSubject, Subject, Observable, Subscription } from 'rxjs';
+import { Answer } from '@colijnit/configuratorapi/build/model/answer';
+import { Article } from '@colijnit/configuratorapi/build/model/article';
+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 { 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 { WebGLPathTracer } from 'three-gpu-pathtracer';
+import { Font } from 'three/examples/jsm/loaders/FontLoader.js';
+import { DeviceDetectorService } from 'ngx-device-detector';
+import * as i3 from '@angular/common';
+import * as i5 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 * as i3$1 from '@angular/material/icon';
+import * as i4 from '@angular/material/button';
+import { ConfigurationDisplayOption } from '@colijnit/configuratorapi/build/enum/refcode/configuration-display-option.enum';
+import { ColorSpace } from 'three/src/constants.js';
+
+declare class ConfiguratorErrorMessage {
+    message: string;
+    safeMessage: SafeHtml;
+    description: string;
+    safeDescription: SafeHtml;
+    constructor(message: string, description?: string);
+}
+
+declare enum ResultType {
+    Unknown = "Unknown",
+    BuildFromScratch = "BuildFromScratch",
+    NeedsUserInput = "NeedsUserInput",
+    NoAdjustables = "NoAdjustables",
+    NoSelections = "NoSelections",
+    NoDecoNodes = "NoDecoNodes",
+    GameobjectNameMismatchInSource = "GameobjectNameMismatchInSource",
+    ArticleNotFound = "ArticleNotFound",
+    No3DModel = "No3DModel",
+    ErrorSettingInstance = "ErrorSettingInstance",
+    Timeout = "Timeout",
+    ConfigurationNotFixed = "ConfigurationNotFixed",
+    ConfigurationPartiallyFixed = "ConfigurationPartiallyFixed",
+    Obsolete = "Obsolete",
+    Loaded = "Loaded",
+    ConfigurationFixed = "ConfigurationFixed",
+    ExternalSourceNotAvailable = "ExternalSourceNotAvailable"
+}
+
+declare class ConfigurationResultObject {
+    sku: string;
+    articleName: string;
+    instanceId: string;
+    originalItemId: string;
+    goodId: string;
+    schema: string;
+    assetUrl: string;
+    assetPath: string;
+    cdnUrl: string;
+    placement: number;
+    object?: Object3D;
+    material?: Material;
+    resultType: ResultType;
+    errorMessages: ConfiguratorErrorMessage[];
+    selections: Selection[];
+    decos: DecoNode[];
+    obsolete: boolean;
+    configurable: boolean;
+    default180: boolean;
+    position?: Vector3;
+    rotation?: number | Euler;
+    itemType?: number;
+    hdecoType?: string;
+}
+
+declare class LoaderService {
+    private _hideLoaderTimeout;
+    private readonly _hideLoaderTimerTimeout;
+    set showLoader(value: boolean);
+    get showLoader(): boolean;
+    private _showLoader;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<LoaderService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LoaderService>;
+}
+
+declare enum ConfigurationTemplate {
+    default = "default",
+    showFullConfiguration = "showFullConfiguration"
+}
+
+declare class IntersectedObjects {
+    parent: Object3D;
+    child: Object3D;
+    constructor(parent?: any, child?: any);
+}
+
+declare class AppEventService {
+    instanceSet: BehaviorSubject<string>;
+    answerCountReceived: BehaviorSubject<number>;
+    readyToRender: BehaviorSubject<boolean>;
+    buildFinished: BehaviorSubject<ConfigurationResultObject>;
+    configurationTemplateChange: BehaviorSubject<ConfigurationTemplate>;
+    articleNotFound: BehaviorSubject<ConfigurationResultObject>;
+    glbCreated: Subject<string>;
+    showOutline: Subject<any>;
+    showErrorOutline: Subject<any>;
+    hideOutline: Subject<void>;
+    articleReceived: Subject<Article>;
+    selectionsReceived: Subject<Selection[]>;
+    answersReceived: Subject<Answer[]>;
+    extraAnswerDataLoaded: Subject<void>;
+    selectionsAndDecosLinked: Subject<void>;
+    connectionReset: Subject<void>;
+    selectSelectionsCalled: Subject<Selection>;
+    articleInfoReceived: Subject<string>;
+    onObjectSelected: Subject<IntersectedObjects>;
+    onObjectUnSelected: Subject<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppEventService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AppEventService>;
+}
+
+declare class ArParameters {
+    depthOcclusion: boolean;
+    depthHitTest: boolean;
+    anchoredHitTest: boolean;
+    lightEstimation: boolean;
+    reflectionEstimation: boolean;
+    planeDetection: boolean;
+    planeHitTest: boolean;
+}
+
+declare class SettingOptions {
+    showStockStatus?: boolean;
+    show3DWatermark?: boolean;
+    showZoomButton?: boolean;
+    showTagFilter?: boolean;
+    showAsConfigured?: boolean;
+    development?: boolean;
+    allowLocalSave?: boolean;
+    inlineAnswers?: boolean;
+    showArButton?: boolean;
+    showCaptionAddButton?: boolean;
+    instantReplace?: boolean;
+    bottomAnswers?: boolean;
+    onlyThreeD?: boolean;
+    showRenderConnectionInfo?: boolean;
+    forceAdjustables?: boolean;
+    showRoomDownloadButton?: boolean;
+    showRoomRenderButton?: boolean;
+    showOwnCatalogButton?: boolean;
+    showDownloadButton?: boolean;
+    showOnlyHomeDecoFilter?: boolean;
+    showMeasurementsButton?: boolean;
+    cameraPositionFixed?: boolean;
+    cameraPositionFixedAndScrollbar?: boolean;
+    handleParametric?: boolean;
+    arEnabled?: boolean;
+    showStandaloneARButton?: boolean;
+    vrEnabled?: boolean;
+    qualitySettingsEnabled?: boolean;
+    xrDebug?: boolean;
+    useStandaloneFloors?: boolean;
+    useStandaloneHighLight?: boolean;
+    useCustomFloorSize?: boolean;
+    customFloorSize?: number;
+    showEditPencilConfigurator?: boolean;
+    instantEditMenu?: boolean;
+    animationButton?: boolean;
+    customizationEnabled?: boolean;
+    usePlacementSnapping?: boolean;
+    showWallMeasurements?: boolean;
+    useVariationOnPart?: boolean;
+    showFormDialog?: boolean;
+    showOnlyLastAnswerDescriptionGenericSelection?: boolean;
+    enable3DInPhoto?: boolean;
+    createGlbStandalone?: boolean;
+    useRenderWebsocket?: boolean;
+    productRenderSceneAssetId?: string;
+    pathTracer?: boolean;
+    ssrEnabled?: boolean;
+    maxRenderSamples?: number;
+    aoEnabled?: boolean;
+    aaEnabled?: boolean;
+    vignetteEnabled?: boolean;
+    vignetteOffset?: number;
+    vignetteDarkness?: number;
+    useCanvasImage?: boolean;
+    useThumbnailImage?: boolean;
+    showProgressBar?: boolean;
+    showProgressText?: boolean;
+    showSelectionLoader?: boolean;
+    useAnimations?: boolean;
+    useThreedScene?: boolean;
+    showSlowConnectionWarning?: boolean;
+    useExternalOpenSave?: boolean;
+    floorFadeStart?: number;
+    floorFadeEnd?: number;
+}
+
+declare class RenderParameters {
+    host?: string;
+    port?: number;
+    secure?: boolean;
+    iterations?: number;
+    imageWidth?: number;
+    imageHeight?: number;
+    websocket?: string;
+    hdri?: string;
+    hdriIntensity?: number;
+    renderType?: number;
+}
+
+declare enum SceneType {
+    Product = "product",
+    Room = "room"
+}
+
+declare class SceneSetting {
+    name: string;
+    multiSceneRender: boolean;
+    primarySceneName: string;
+    secondarySceneName?: string;
+    defaultSceneName?: string;
+    hdriIntensity: number;
+    hdriRotation: number;
+    lightingExposure: number;
+    sceneType: SceneType;
+    forceTransparency: boolean;
+}
+
+declare class SceneSettings {
+    scenes: SceneSetting[];
+}
+
+declare class ConfiguratorSettings {
+    url?: string;
+    schema?: string;
+    version?: string;
+    branch?: string;
+    currency?: number;
+    currencySymbol?: string;
+    username?: string;
+    password?: string;
+    session?: any;
+    useGroups?: boolean;
+    useRenders?: boolean;
+    useLoginEncryption?: boolean;
+    logoutWhenRefresh?: boolean;
+    useMatch?: boolean;
+    assetPath?: string;
+    threeDAssetPath?: string;
+    assetIndex?: string;
+    lightPresetsIndex?: string;
+    additionalTranslationFile?: string;
+    apiUrl?: string;
+    client?: string;
+    timeoutInMs?: number;
+    languageCode?: string;
+    secondaryLogo?: string;
+    jwtEnabled?: boolean;
+    gtm?: string;
+    dracoPath?: string;
+    options?: SettingOptions;
+    catalogParameters?: GetArticlesForCatalogRequest;
+    renderParameters?: RenderParameters;
+    arParameters?: ArParameters;
+    faqUrl?: string;
+    feedbackUrl?: string;
+    envMap?: string;
+    spreadsheetSheetKey?: string;
+    cameraConfig?: string;
+    sceneBackground?: string;
+    sceneBackgroundColor?: string;
+    standaloneSceneBackgroundColor?: string;
+    blendFilesRender?: boolean;
+    renderApiClientId?: string;
+    uploadEndpoint?: string;
+    renderEndpoint?: string;
+    productRenderSceneAssetId?: string;
+    defaultRenderType?: number;
+    user3DModelUploadEnabled?: boolean;
+    showConversionButtons?: boolean;
+    showUploadDiagram?: boolean;
+    isHomeDecoHub?: boolean;
+    standAloneRoomplanner?: boolean;
+    projectSettings?: ConfiguratorSettings;
+    showFloorProductTab?: boolean;
+    showAddToCart?: boolean;
+    blenderSceneSettings?: SceneSettings;
+    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;
+    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): 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>;
+    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>;
+}
+
+declare class ConfiguratorConnectorService implements OnDestroy {
+    private _configuratorService;
+    private _appEventService;
+    private _settingsService;
+    private _loaderService;
+    get article(): Article;
+    set article(value: Article);
+    get sku(): string;
+    get objectResult(): ConfigurationResultObject;
+    set objectResult(value: ConfigurationResultObject);
+    get selections(): Selection[];
+    set selections(value: Selection[]);
+    get decoNodes(): DecoNode[];
+    set decoNodes(value: DecoNode[]);
+    get totalPrice(): number;
+    get currentSelections(): Selection[];
+    get activeSelection(): Selection;
+    set activeSelection(value: Selection);
+    set selectionWithAnswers(value: SelectorWithOptions[]);
+    get selectionWithAnswers(): SelectorWithOptions[];
+    get shouldShowLoader(): boolean;
+    controllerInitialized: BehaviorSubject<boolean>;
+    standAloneInstance: BehaviorSubject<boolean>;
+    connectionReset: Subject<void>;
+    selectionsToDisplay: Selection[];
+    activeQuestion: Question;
+    activeAnswers: Answer[];
+    assetPath: string;
+    private _selections;
+    private _currentSelections;
+    private _activeSelection;
+    private _selectionWithAnswers;
+    private _decoNodes;
+    private _article;
+    private _sku;
+    private _objectResult;
+    private _totalPrice;
+    private _imageCache;
+    private _exceptionQuestionChanged;
+    private _shouldShowLoader;
+    private _connectorOptions;
+    private _subs;
+    private _initializing;
+    private _initialized;
+    private _boFactory;
+    constructor(_configuratorService: ConfiguratorService, _appEventService: AppEventService, _settingsService: SettingsService, _loaderService: LoaderService);
+    ngOnDestroy(): void;
+    initConnection(forceReload?: boolean, standAlone?: boolean): Promise<void>;
+    onShowLoaderChange(showLoader: boolean): void;
+    onConnectionReset(): void;
+    getGoodIdFromSku(sku: string, showLoader?: boolean): Promise<number>;
+    setSelections(selections: Selection[]): void;
+    setDecoNodes(value: DecoNode[]): void;
+    getArticleQuickSel(goodId: string, showLoader?: boolean): Promise<Article>;
+    getArticleBySku(sku: string, branch: string): Promise<Article>;
+    initNodeInstance(goodId: string, showLoader?: boolean): Promise<DataServiceResponseData>;
+    changeConnection(instanceId: string, oldConnection: string, newConnection: string, showLoader?: boolean): Promise<boolean>;
+    setInstance(instanceId: string, showLoader?: boolean): Promise<DataServiceResponseData>;
+    copyInstanceAndSaveOriginalConfiguration(instanceId: string, result: ConfigurationResultObject): Promise<string>;
+    copyInstanceAndLoseOriginalConfiguration(instanceId: string, result: ConfigurationResultObject): Promise<string>;
+    getQuestionAndAnswersAsync(): Promise<QuestionAndAnswers>;
+    emptyAnswersAndQuestion(): void;
+    handleAnswersReceived(): void;
+    getSelectionsAndDecos(): Promise<void>;
+    getSelectionsAsync(): Promise<void>;
+    getDecosAsync(): Promise<void>;
+    selectAnswer(answer: Answer, input?: string): Promise<DataServiceResponseData>;
+    selectAnswerBySelection(selection: Selection, input?: string): Promise<DataServiceResponseData>;
+    navigateTo(choseValue: SelectorStructure, showLoader?: boolean): Promise<DataServiceResponseData>;
+    cancelAnswer(getAnswersAndQuestion?: boolean): Promise<DataServiceResponseData>;
+    selectSelection(selection: Selection, forceBackToNode?: boolean, after?: boolean, connector?: string): Promise<DataServiceResponseData>;
+    deleteSelection(selection: Selection): Promise<DataServiceResponseData>;
+    replaceSelection(selection: Selection): Promise<DataServiceResponseData>;
+    getAnswerPrices(): Promise<AnswerPrice[]>;
+    extendWithAnswerTextAndImage(answer: Answer, showLoader?: boolean): Promise<void>;
+    getSkipButtonImageAndText(goodId?: number): Promise<SkipButtonInfo>;
+    extendWithSelectionImage(selection: Selection, showLoader?: boolean): Promise<void>;
+    getImageForAnswerOrSelection(answerOrSelection: Answer | Selection, publication: number, thumbNail?: boolean, showLoader?: boolean): Promise<string>;
+    getMoodImageForInfoDialog(answerOrSelection: Answer | Selection, thumbNail?: boolean): Promise<string>;
+    getAnswerInfo(answer: Answer): Promise<ArticleText[]>;
+    getStructureInfo(answer: SelectorStructure): Promise<ArticleText[]>;
+    getInternalParameter(parameter: InternalParam): Promise<string>;
+    emptySelections(): void;
+    saveConfigurations(): Promise<void>;
+    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>;
+    isSelectionPublished(selection: Selection): boolean;
+    private _prepareSelections;
+    private _prepareSelectionsToDisplay;
+    private _prepareAnswersAndImages;
+    private _handleSelectionAnswers;
+    private _isSelectionPublished;
+    private _isAllSelectionPublished;
+    private _isAnswerPublished;
+    private _getPublicationCode;
+    private _getUniqueAnswers;
+    private _preloadCachedImages;
+    private _handleInstanceResponse;
+    private _prepareSelectionsNextOptionValues;
+    private _createSelectorFullConfiguration;
+    private _buildStructureThree;
+    private _markLastNodeWithChildren;
+    private _isStructurePublished;
+    private _loadPricesOfActiveAnswers;
+    private _cacheImage;
+    private _handleImageReceived;
+    private _prepareSelectionsToDisplayImages;
+    private _copyInstance;
+    private _handleImageReceivedForSelectorStructure;
+    private _handleImageResponse;
+    private _linkExceptionToOption;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfiguratorConnectorService, never>;
+    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 _variations;
+    private _subs;
+    constructor(_settingsService: SettingsService);
+    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;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VariationCacheService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<VariationCacheService>;
+}
+
+declare class ProgressService {
+    private _progressPercent;
+    get progress(): number;
+    set progress(value: number);
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProgressService, never>;
+    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;
+    private _subs;
+    get cameraLocked(): boolean;
+    set realAspectRatio(value: number);
+    constructor(_settingsService: SettingsService);
+    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>;
+}
+
+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: 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>;
+}
+
+declare class XrService implements OnDestroy {
+    private _settingsService;
+    private _debugService;
+    private _messageBoard;
+    gamepad: any;
+    axes: number[];
+    touchpadIsPressed: boolean;
+    triggerIsPressed: boolean;
+    angularVelocity: THREE.Vector3;
+    renderer: WebGLRenderer;
+    scene: Scene;
+    camera: Camera;
+    controller: any;
+    vrSupported: boolean;
+    arSupported: boolean;
+    sessionStarted: Subject<XrMode>;
+    sessionEnded: Subject<void>;
+    userSelectInAr: BehaviorSubject<boolean>;
+    refSpace: any;
+    viewerSpace: any;
+    session: any;
+    hitTestSource: any;
+    private _vrDisplay;
+    private _vrController;
+    private _subs;
+    private _cameraHeight;
+    private _mode;
+    constructor(_settingsService: SettingsService, _debugService: DebugService, _messageBoard: MessageBoardService);
+    ngOnDestroy(): void;
+    init(renderer: WebGLRenderer, scene: Scene, camera: Camera): Promise<void>;
+    startAr(): void;
+    stopAr(): void;
+    startVr(): void;
+    stopVr(): void;
+    update(): void;
+    private _doBeforeRenderScene;
+    private _logMessage;
+    private _onSessionStarted;
+    private _onUserSelect;
+    private _onSessionEnded;
+    private _updateController;
+    private _findGamepad;
+    private _createController;
+    private _createMeshes;
+    static ɵfac: i0.ɵɵFactoryDeclaration<XrService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<XrService>;
+}
+
+declare class VrService {
+    private _scene;
+    private _renderer;
+    private _camera;
+    private _tempMatrix;
+    private _currentClosestIntersection;
+    private _meshes;
+    private _raycaster;
+    private _reticle;
+    private _controller0;
+    private _controller1;
+    private _session;
+    private _user;
+    private _selectedObject;
+    constructor();
+    init(scene: Scene, renderer: WebGLRenderer): void;
+    render(): void;
+    endSession(): void;
+    private _initSession;
+    private _onSessionStarted;
+    private _onSessionEnded;
+    startVRSession(): void;
+    private _createControllers;
+    private _onSelectStart;
+    private _onSelectEnd;
+    private _getIntersections;
+    private _registerMeshes;
+    private _handleIntersections;
+    private _handleControllerIntersections;
+    private _getNearestIntersection;
+    private _handleFloorIntersection;
+    private _handleObjectIntersection;
+    private _handleNoIntersections;
+    private _updateControllerRay;
+    private _isObjectFloor;
+    private _getParentOfChild;
+    private _updateObjectSelection;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VrService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<VrService>;
+}
+
+declare class ArService implements OnDestroy {
+    private _cameraService;
+    private _settingsService;
+    private _iOne;
+    updateContextMenu: BehaviorSubject<void>;
+    shouldAddObjectToScene: Subject<Object3D>;
+    showConfigurator: boolean;
+    refSpace: any;
+    hitTestSource: any;
+    scene: Scene;
+    userInSelectionMenu: boolean;
+    showContextMenu: boolean;
+    private _arFeatures;
+    private _renderer;
+    private _glBinding;
+    private _session;
+    private _debug;
+    private _surfaceFoundOnce;
+    private _reticle;
+    private _hitTestResult;
+    private _reticleHitTestResult;
+    private _anchoredObjects;
+    private _activeARModel;
+    private _aRModelBackupYPosition;
+    private _aRModelBackupPosition;
+    private _aRModelBackupYRotation;
+    private _aRModelRotationStartingValue;
+    private _vertexList;
+    private _detectedPlanes;
+    private _rawPlanes;
+    private _planeMaterial;
+    private _shadowPlane;
+    private _lastEventTimestamp;
+    private _lastObjectTouchTimestamp;
+    private _doubleTapTimeframe;
+    private _holdingTouch;
+    private _controller;
+    private _raycaster;
+    private _tempMatrix;
+    private _cleanup;
+    private _animating;
+    private _liftAnimation;
+    private _dropAnimation;
+    private _lightProbe;
+    private _threeLightProbe;
+    private _cubeMapTexture;
+    private _depthDataTexture;
+    private _sunLight;
+    private _positionIndicator;
+    private _pointRepresentation;
+    constructor(_cameraService: CameraService, _settingsService: SettingsService, _iOne: ConfiguratorConnectorService);
+    ngOnDestroy(): void;
+    resetPlaneDetection(): Promise<void>;
+    endSessionEvent(): void;
+    arIOSSupported(): Promise<boolean>;
+    arSupported(): Promise<any>;
+    addObjectToARScene(object: Object3D): void;
+    modelLoading(): boolean;
+    modelPlaced(): boolean;
+    handleFrame(xrFrame: any): void;
+    init(renderer: WebGLRenderer): void;
+    savePreSelectionPosition(): void;
+    updateChangedModel(): void;
+    arModeHasBeenActive(): boolean;
+    showMovePhoneAnimation(): boolean;
+    getActiveModel(): any;
+    private _initSession;
+    private _checkAvailableFeatures;
+    private _initRenderer;
+    private _initController;
+    private _initScene;
+    private _initLightEstimation;
+    private _initReflectionCubeMap;
+    private _initCPUDepthOcclusion;
+    private _initAnchoredHitTest;
+    private _initPlaneDetection;
+    private _initLighting;
+    private _checkHitTestMethod;
+    private _executeDepthAnchorHitTest;
+    private _executeAnchoredHitTest;
+    private _executeCPUDepthHitTest;
+    private _executeDefaultHitTest;
+    private _checkExtraFeatures;
+    private _hideOccludedMeshes;
+    private _createPlaneMaterial;
+    private _onSessionStarted;
+    private _onSessionEnded;
+    private _setArModelShadows;
+    private _handleTouchEvent;
+    private _handleMultiTouchEvent;
+    private _handleDoubleTapEvent;
+    private _checkIfHoldTouchEvent;
+    private _handleHoldStartEvent;
+    private _handleHoldEndEvent;
+    private _toggleHoldTouchEvent;
+    private _handleHoldMoveEvent;
+    private _updateShadows;
+    private _adjustLighting;
+    private _toggleARModelTransparency;
+    private _setPlanesVisibilty;
+    private _getObjectIntersections;
+    private _drawPlane;
+    private _drawPlanes;
+    private _callLiftAnimation;
+    private _callDropAnimation;
+    private _createAugmentedMaterial;
+    private _updateAugmentedMaterialUniforms;
+    private _updateMeshMaterials;
+    private _removeMaterialShaders;
+    private _checkingInterfaceInteraction;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ArService>;
+}
+
+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"
+}
+
+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 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 {
+    private _cameraService;
+    private _xrService;
+    private _vrService;
+    private _arService;
+    private _settingsService;
+    private _postProcessing;
+    private _viewModeService;
+    set needsRender(value: boolean);
+    get needsRender(): boolean;
+    scene: Scene;
+    renderer: WebGLRenderer;
+    pathTracer: WebGLPathTracer;
+    standAlone: boolean;
+    onBeforeRender: Subject<{
+        renderer: WebGLRenderer;
+        scene: Scene;
+    }>;
+    onAfterRender: Subject<{
+        renderer: WebGLRenderer;
+        scene: Scene;
+    }>;
+    sceneInitialized: BehaviorSubject<boolean>;
+    renderingThroughPostProcessingPipeline: boolean;
+    webGL2Available: boolean;
+    domElement: HTMLElement;
+    private _needsRender;
+    private _arMode;
+    private _subs;
+    private _maxRenderSamples;
+    private _numberOfSamplesRendered;
+    constructor(_cameraService: CameraService, _xrService: XrService, _vrService: VrService, _arService: ArService, _settingsService: SettingsService, _postProcessing: PostProcessingService, _viewModeService: ViewModeService);
+    ngOnDestroy(): void;
+    getScene(): Scene;
+    set arMode(value: boolean);
+    get arMode(): boolean;
+    takeScreenshot(): string;
+    init(element: HTMLElement): Promise<void>;
+    getSceneCanvasImage(): string;
+    addObject(obj: Object3D, forceRender?: boolean): void;
+    removeObject(obj: Object3D | Mesh, forceRender?: boolean, cleanUp?: boolean): void;
+    updatePathTracer(): void;
+    positionInSceneToScreen(pos: Vector3): Vector2;
+    rendererPropsChange(): void;
+    private _initScene;
+    private _initCamera;
+    private _initPostProcessing;
+    private _initPathTracer;
+    private _initRenderer;
+    private _resizeRendererToDisplaySize;
+    private _updateWindowSize;
+    private _checkCanvasResize;
+    private _render;
+    private _animate;
+    private _pauseAnimation;
+    private _setSceneBackground;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SceneService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SceneService>;
+}
+
+declare class ItemService implements OnDestroy {
+    private _sceneService;
+    get sceneItems(): Object3D[];
+    private _sceneItems;
+    constructor(_sceneService: SceneService);
+    ngOnDestroy(): void;
+    addItem(item: Object3D, replace?: boolean): void;
+    removeAllItems(): void;
+    removeItem(obj: any): void;
+    objectDimensions(object: Object3D): Vector3;
+    glassMaterialCheck(item: Object3D): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ItemService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ItemService>;
+}
+
+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>;
+    cleanedUpObjects(object: Object3D, cleanUp?: boolean): Object3D;
+    private _addGroupChildrenToObject;
+    private _handleUpdateProgressBar;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UtilsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UtilsService>;
+}
+
+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 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 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 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 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 SwitchBuildFurnitureService implements OnDestroy {
+    private _buildFurnitureService;
+    private _buildFurnitureWithoutSceneService;
+    private _settingsService;
+    private _configuratorService;
+    currentActiveService: BuildFurnitureBaseService;
+    private _standAlone;
+    private _controllerInitSub;
+    private _standAloneInstance;
+    constructor(_buildFurnitureService: BuildFurnitureService, _buildFurnitureWithoutSceneService: BuildFurnitureWithoutSceneService, _settingsService: SettingsService, _configuratorService: ConfiguratorConnectorService);
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SwitchBuildFurnitureService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SwitchBuildFurnitureService>;
+}
+
+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>;
+    private _subs;
+    private _article;
+    protected constructor(configuratorConnectorService: ConfiguratorConnectorService, threedSelectorService: ThreedselectorService, buildFurnitureService: SwitchBuildFurnitureService, settingsService: SettingsService);
+    ngOnDestroy(): void;
+    abstract loadFurniture(furnitureData: ConfigurationResultObject, shouldCopyInstance: boolean, looseOriginalConfiguration: boolean, standAlone: boolean, fromScratch: boolean, fromPreset: boolean, loadFromProject: boolean): Promise<ConfigurationResultObject>;
+    loadArticle(sku: string): Promise<Article>;
+    extendConfigurationBuildResult(article: Article, result: ConfigurationResultObject): ConfigurationResultObject;
+    getFull3DObject(sku: string, assetUrl: string, prepareProgress?: boolean): Promise<Object3D>;
+    protected tryLoadArticle(sku: string, result: ConfigurationResultObject, initConnector: boolean): Promise<void>;
+    private _cleanUp;
+    protected needs3DModel(type: ItemType): boolean;
+    initFull3DObject(configurationResultObject: ConfigurationResultObject): Promise<void>;
+    protected getAssetPathFromMetadata(metadata: ConfigurationResultObject): string;
+    private _getAssetPathFromModelUrlAndSchema;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LoadFurnitureBaseService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LoadFurnitureBaseService>;
+}
+
+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: SettingsService, _iOne: ConfiguratorConnectorService);
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SwitchLoadFurnitureService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SwitchLoadFurnitureService>;
+}
+
+declare class ConfiguringService implements OnDestroy {
+    private _initializerService;
+    private _loadFurnitureService;
+    private _buildFurnitureService;
+    private _appEventService;
+    private _configuratorConnectorService;
+    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>;
+    buildResult: ConfigurationResultObject;
+    private _settings;
+    private _sku;
+    private _instanceId;
+    private _isConfiguring;
+    private _scene;
+    private _showFullConfiguration;
+    private _subs;
+    constructor(_initializerService: AppInitializerService, _loadFurnitureService: SwitchLoadFurnitureService, _buildFurnitureService: SwitchBuildFurnitureService, _appEventService: AppEventService, _configuratorConnectorService: ConfiguratorConnectorService);
+    ngOnDestroy(): void;
+    init(settings: any): Promise<void>;
+    configure(furnitureData: ConfigurationResultObject, shouldCopyInstance?: boolean, looseOriginalConfiguration?: boolean, fromPreset?: boolean, standAlone?: boolean, fromScratch?: boolean, loadFromProject?: boolean): Promise<void>;
+    private _handleTemplateChange;
+    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;
+    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; }; }, { "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 i5.LoaderModule, typeof i5.IconModule, typeof i3.CommonModule], [typeof ConfiguratorLoaderComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ConfiguratorLoaderModule>;
+}
+
+/** AUTO GENERATED FILE. DO NOT CHANGE.. **/
+declare enum IconEnum {
+    AddButton = "add-button",
+    AddLight = "add_light",
+    Angle90 = "angle_90",
+    Aperture = "aperture",
+    ArrowUpRightAndArrowDownLeftFromCenter = "arrow-up-right-and-arrow-down-left-from-center",
+    ArrowsLeftRight = "arrows-left-right",
+    ArrowsUpDown = "arrows-up-down",
+    ArrowsToEye = "arrows_to_eye",
+    ArrowPointDown = "arrow_point_down",
+    ArrowPointRight = "arrow_point_right",
+    ArrowRotateLeft = "arrow_rotate_left",
+    ArrowRotateRight = "arrow_rotate_right",
+    ArrowTurnLeft = "arrow_turn_left",
+    ArrowTurnLeftRegular = "arrow_turn_left_regular",
+    ArrowTurnRight = "arrow_turn_right",
+    ArrowTurnRightRegular = "arrow_turn_right_regular",
+    ArCircle = "ar_circle",
+    Brush = "brush",
+    CameraSolid = "camera_solid",
+    CameraTopdown = "camera_topdown",
+    CameraViewfinder = "camera_viewfinder",
+    CartShoppingRegular = "cart-shopping-regular",
+    Check = "check",
+    CheckRegular = "check_regular",
+    CheckSolid = "check_solid",
+    CircleCheck = "circle_check",
+    CircleCheckRegular = "circle_check_regular",
+    CircleInfo = "circle_info",
+    CircleMinusLight = "circle_minus_light",
+    CirclePlusLight = "circle_plus_light",
+    CircleQuestion = "circle_question",
+    CircleRegular = "circle_regular",
+    CircleXmark = "circle_xmark",
+    CitPoweredWhite = "cit_powered_white",
+    CloudArrowDown = "cloud_arrow_down",
+    CloudArrowUp = "cloud_arrow_up",
+    Comment = "comment",
+    Compress = "compress",
+    ConfFrame = "conf_frame",
+    ConfPlane = "conf_plane",
+    CopyLight = "copy_light",
+    Couch = "couch",
+    Cross = "cross",
+    CubeOutline = "cube-outline",
+    CubeUnfolded = "cube-unfolded",
+    Cube = "cube",
+    DashButton = "dash-button",
+    DeleteButton = "delete-button",
+    Download = "download",
+    DrawSquare = "draw_square",
+    EditButton = "edit-button",
+    Expand = "expand",
+    FillDripLight = "fill_drip_light",
+    Flower = "flower",
+    GaugeHighSolidFull = "gauge_high_solid_full",
+    GaugeLowSolidFull = "gauge_low_solid_full",
+    GaugeMaxSolidFull = "gauge_max_solid_full",
+    GaugeMinSolidFull = "gauge_min_solid_full",
+    GoogleCardboardOrange = "google-cardboard-orange",
+    GoogleCardboard = "google-cardboard",
+    GridLight = "grid_light",
+    HandPointer = "hand-pointer",
+    HandLight = "hand_light",
+    HandPointerLight = "hand_pointer_light",
+    HeightAdjust = "height_adjust",
+    House = "house",
+    ImageLight = "image_light",
+    ImageSlashRegular = "image_slash_regular",
+    InfoSolidFull = "info_solid_full",
+    LinkLight = "link_light",
+    LinkSlashLight = "link_slash_light",
+    List = "list",
+    LockLight = "lock_light",
+    LockOpenLight = "lock_open_light",
+    MagicWand = "magic-wand",
+    Magnet = "magnet",
+    MagnetStrikethrough = "magnet_strikethrough",
+    Magnifier = "magnifier",
+    MagnifyingGlassMinus = "magnifying_glass_minus",
+    MagnifyingGlassPlus = "magnifying_glass_plus",
+    Measurements = "measurements",
+    MeasurementsInside = "measurements_inside",
+    MovePhoneAr = "move-phone-ar",
+    PaintRollerLight = "paint_roller_light",
+    PenRuler = "pen-ruler",
+    PencilLight = "pencil_light",
+    PlusRegular = "plus_regular",
+    Qrcode = "qrcode",
+    RetryButton = "retry-button",
+    RotateLight = "rotate_light",
+    Scale = "scale",
+    Settings = "settings",
+    SquareCheckRegular = "square_check_regular",
+    SquareChevronDownRegular = "square_chevron_down_regular",
+    SquareRegular = "square_regular",
+    StreetViewOrange = "street-view-orange",
+    StreetView = "street_view",
+    SwapButton = "swap-button",
+    TiltPhone = "tilt-phone",
+    TrashCanLight = "trash_can_light",
+    TriangleDown = "triangle_down",
+    TriangleExclamation = "triangle_exclamation",
+    TriangleUp = "triangle_up",
+    UploadLight = "upload_light",
+    WandMagicSparkles = "wand_magic_sparkles",
+    WifiSolidFull = "wifi_solid_full",
+    XmarkLight = "xmark_light",
+    XmarkRegular = "xmark_regular"
+}
+
+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 {
+    private _cameraService;
+    private _sceneService;
+    private _settingsService;
+    private _configuratorConnectorService;
+    currentCameraSettings: CameraSettings[];
+    constructor(_cameraService: CameraService, _sceneService: SceneService, _settingsService: SettingsService, _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>;
+}
+
+declare class ConfiguratorCameraSettingsComponent implements OnInit {
+    iconService: IconCacheService;
+    private _cameraService;
+    private _dynamicCameraService;
+    private _configuratorConnectorService;
+    readonly icons: typeof IconEnum;
+    closeCameraDialog: EventEmitter<void>;
+    tempCameraSettings: CameraSettings;
+    currentSku: string;
+    positionAsString: string;
+    rotationAsString: string;
+    constructor(iconService: IconCacheService, _cameraService: CameraService, _dynamicCameraService: DynamicCameraService, _configuratorConnectorService: ConfiguratorConnectorService);
+    ngOnInit(): void;
+    onClose(): void;
+    saveSettings(asDefault: boolean): void;
+    exportSettings(): void;
+    saveCurrentPosition(): void;
+    saveCurrentRotation(): void;
+    private _parsePositionAndRotation;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfiguratorCameraSettingsComponent, never>;
+    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 i5.IconModule, typeof i3.CommonModule, typeof i7.FormsModule], [typeof ConfiguratorErrorDialogComponent, typeof ConfiguratorExportDialogComponent, typeof ConfiguratorCameraSettingsComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ConfiguratorDialogModule>;
+}
+
+declare class ThreedselectorComponent implements OnInit, OnDestroy {
+    private _appEventService;
+    private _buildFurnitureService;
+    private _configuringService;
+    private _configuratorService;
+    showClass(): boolean;
+    customizeButtonClicked: EventEmitter<void>;
+    selections: Selection[];
+    canCloseConfigurator: boolean;
+    buildFinished: EventEmitter<ConfigurationResultObject>;
+    showChange: EventEmitter<boolean>;
+    showElementToolbar: boolean;
+    showLiteSelector: boolean;
+    showSelections: boolean;
+    showAnswers: boolean;
+    showFullConfiguration: boolean;
+    private _floorTexturesLoadedSub;
+    private _subs;
+    private _loadingFromPreset;
+    constructor(_appEventService: AppEventService, _buildFurnitureService: SwitchBuildFurnitureService, _configuringService: ConfiguringService, _configuratorService: ConfiguratorService);
+    ngOnInit(): Promise<void>;
+    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; }; }, { "customizeButtonClicked": "customizeButtonClicked"; "buildFinished": "buildFinished"; "showChange": "showChange"; }, never, never, false, never>;
+}
+
+declare class LiteSelectorComponent implements OnDestroy {
+    buildFurnitureService: SwitchBuildFurnitureService;
+    configuratorConnectorService: ConfiguratorConnectorService;
+    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;
+    customDimensions: boolean;
+    readonly showChange: EventEmitter<boolean>;
+    readonly answerChosen: EventEmitter<Answer>;
+    answerToShowFromSelectionText: string;
+    inlineAnswers: boolean;
+    animateSlideout: boolean;
+    private _showAnswers;
+    private _answersShowing;
+    private _showSelections;
+    private _selectionSelected;
+    private _subs;
+    constructor(buildFurnitureService: SwitchBuildFurnitureService, configuratorConnectorService: ConfiguratorConnectorService, _configuringService: ConfiguringService);
+    ngOnDestroy(): void;
+    onCloseLiteSelectorButtonClick(): void;
+    onSelectionsSummarySelectSelection(selection: Selection, forceBackToNode?: boolean, after?: boolean): Promise<void>;
+    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; }; "customDimensions": { "alias": "customDimensions"; "required": false; }; }, { "showChange": "showChange"; "answerChosen": "answerChosen"; }, never, never, false, never>;
+}
+
+declare class AnswerCardComponent implements OnInit {
+    settingsService: SettingsService;
+    iconService: IconCacheService;
+    private _configuratorConnectorService;
+    readonly icons: typeof IconEnum;
+    showClass(): boolean;
+    get activeInfoClass(): boolean;
+    model: Answer | any;
+    valutaSymbol: string;
+    set showing(value: boolean);
+    isSelected: boolean;
+    isSmallModus: boolean;
+    freeInput: string;
+    readonly freeInputChange: EventEmitter<string>;
+    readonly inqNumberChange: EventEmitter<string>;
+    readonly select: EventEmitter<string>;
+    readonly selectWithInq: EventEmitter<string>;
+    readonly magnifierClick: EventEmitter<Answer>;
+    readonly answerInfoToggle: EventEmitter<{
+        open: boolean;
+        id: string;
+    }>;
+    dialogPosition: {
+        top: number;
+        right: number;
+    } | null;
+    inqNumberModel: string;
+    inqNumberError: boolean;
+    showAnswerInfo: boolean;
+    private _waitForInput;
+    private _waitForInqValue;
+    constructor(settingsService: SettingsService, iconService: IconCacheService, _configuratorConnectorService: ConfiguratorConnectorService);
+    ngOnInit(): void;
+    onContentClick(): void;
+    handleClick(event: MouseEvent): void;
+    onInfoButtonClick(event: MouseEvent): void;
+    closeInfo(silent?: boolean): void;
+    handleFocusFreeInput(event: MouseEvent): void;
+    handleBlurFreeInput(event: MouseEvent): void;
+    handleKeyDownFreeInput(event: KeyboardEvent): void;
+    handleFocusInqNumber(event: MouseEvent): void;
+    handleBlurInqNumber(event: MouseEvent): void;
+    handleKeyDownInqNumber(event: KeyboardEvent): void;
+    onZoomImage(): void;
+    validateInqNumber(event: MouseEvent): boolean;
+    replaceTranslationValues(translation: string, min: number, max: number): string;
+    private _checkVisibility;
+    private _getThumbnailImage;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AnswerCardComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AnswerCardComponent, "co-answer-card", never, { "model": { "alias": "model"; "required": false; }; "valutaSymbol": { "alias": "valutaSymbol"; "required": false; }; "showing": { "alias": "showing"; "required": false; }; "isSelected": { "alias": "isSelected"; "required": false; }; "isSmallModus": { "alias": "isSmallModus"; "required": false; }; "freeInput": { "alias": "freeInput"; "required": false; }; }, { "freeInputChange": "freeInputChange"; "inqNumberChange": "inqNumberChange"; "select": "select"; "selectWithInq": "selectWithInq"; "magnifierClick": "magnifierClick"; "answerInfoToggle": "answerInfoToggle"; }, never, never, false, never>;
+}
+
+declare class AnswersSlideoutComponent implements OnInit, OnDestroy {
+    configuratorConnectorService: ConfiguratorConnectorService;
+    settingsService: SettingsService;
+    iconService: IconCacheService;
+    private _appEventService;
+    private _buildFurnitureService;
+    private _configuringService;
+    showClass(): boolean;
+    slideOut: ElementRef;
+    cards: QueryList<AnswerCardComponent>;
+    readonly icons: typeof IconEnum;
+    private readonly _showSmallAnswerCardsFromThisAmount;
+    private readonly _propsToSearch;
+    isShown: boolean;
+    question: Question;
+    showTitle: boolean;
+    showFilter: boolean;
+    set answers(value: Answer[]);
+    useSlideout: boolean;
+    get answers(): Answer[];
+    customDimensions: boolean;
+    readonly isShownChange: EventEmitter<boolean>;
+    readonly answerChosen: EventEmitter<{
+        answer: Answer;
+        input: string;
+    }>;
+    isSmallCardsModus: boolean;
+    bottomAlign: boolean;
+    filteredAnswers: Answer[];
+    colorArray: Color$1[];
+    tagArray: Tag[];
+    showTheFilter: boolean;
+    zoomImage: string;
+    showZoom: boolean;
+    searchExpanded: boolean;
+    chipTexts: string[];
+    freeInput: string;
+    inqNumber: number;
+    valutaSymbol: string;
+    hasInfoOpen: boolean;
+    private _openCount;
+    private _answers;
+    private _subs;
+    private _filterOnColors;
+    private _filterOnTags;
+    constructor(configuratorConnectorService: ConfiguratorConnectorService, settingsService: SettingsService, iconService: IconCacheService, _appEventService: AppEventService, _buildFurnitureService: SwitchBuildFurnitureService, _configuringService: ConfiguringService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    onZoomClick(answer: Answer): void;
+    applyFilter(): void;
+    onFilterColor(color: Color$1): void;
+    onFilterTag(tag: Tag): void;
+    onCloseAnswerSlideout(): void;
+    handleAnswerChosen(answer: Answer): void;
+    isSelectedAnswer(answer: Answer): boolean;
+    onChipsValueChange(value: string[]): void;
+    onChipsClose(): void;
+    handleFreeInputChange($event: string): void;
+    handleIngNumberChange($event: string): void;
+    onAnswerInfoToggle(evt: {
+        open: boolean;
+        id: string;
+    }): void;
+    private _filterOnArray;
+    private _filterOnChips;
+    private _containsTextParts;
+    private _setArrays;
+    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>;
+}
+
+declare class SlideoutComponent implements AfterViewInit {
+    private _elementRef;
+    show: boolean;
+    showClass(): boolean;
+    resizable: boolean;
+    readonly dragGutter: ElementRef;
+    private _originalWidthPx;
+    private _dragStartX;
+    private _isDragResizing;
+    private readonly _minWidthAfterDragResize;
+    constructor(_elementRef: ElementRef);
+    ngAfterViewInit(): void;
+    onDragGutterMouseDown(event: MouseEvent): void;
+    onDocumentMouseUp(event: MouseEvent): void;
+    onDocumentDragEnd(event: DragEvent): void;
+    onDragGutterMouseUp(event: MouseEvent): void;
+    onDragGutterDoubleClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlideoutComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SlideoutComponent, "co-slideout", never, { "show": { "alias": "show"; "required": false; }; "resizable": { "alias": "resizable"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+declare class SlideoutModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlideoutModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SlideoutModule, [typeof SlideoutComponent], never, [typeof SlideoutComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SlideoutModule>;
+}
+
+declare class AnswersInfoDialogComponent implements OnInit {
+    iconService: IconCacheService;
+    private _settingsService;
+    private _configuratorConnectorService;
+    private _sanitizer;
+    readonly icons: typeof IconEnum;
+    showClass(): boolean;
+    answer: Answer;
+    structure: SelectorStructure;
+    fixedPosition: {
+        top: number;
+        right: number;
+    } | null;
+    nothingToShow: EventEmitter<void>;
+    answerText: string;
+    answerImage: string;
+    answerHtml: SafeHtml;
+    textLoading: boolean;
+    textError: string;
+    showTooltip: boolean;
+    showPopup: boolean;
+    hasEmbed: boolean;
+    constructor(iconService: IconCacheService, _settingsService: SettingsService, _configuratorConnectorService: ConfiguratorConnectorService, _sanitizer: DomSanitizer);
+    ngOnInit(): Promise<void>;
+    private _loadInfo;
+    private _formatAnswerInfo;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AnswersInfoDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AnswersInfoDialogComponent, "co-answer-info-dialog", never, { "answer": { "alias": "answer"; "required": false; }; "structure": { "alias": "structure"; "required": false; }; "fixedPosition": { "alias": "fixedPosition"; "required": false; }; }, { "nothingToShow": "nothingToShow"; }, never, never, false, never>;
+}
+
+declare class AnswersInfoDialogModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AnswersInfoDialogModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AnswersInfoDialogModule, [typeof AnswersInfoDialogComponent], [typeof i3.CommonModule, typeof PipesModule, typeof i5.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 i5.CardModule, typeof PipesModule, typeof i5.CardModule, typeof i5.InputTextModule, typeof i5.IconModule, typeof AnswersInfoDialogModule, typeof i5.CardModule], [typeof AnswerCardComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AnswerCardModule>;
+}
+
+declare class ImageZoomComponent {
+    iconService: IconCacheService;
+    showClass(): boolean;
+    readonly icons: typeof IconEnum;
+    imageData: string;
+    show: boolean;
+    showChange: EventEmitter<boolean>;
+    constructor(iconService: IconCacheService);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ImageZoomComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ImageZoomComponent, "co-image-zoom", never, { "imageData": { "alias": "imageData"; "required": false; }; "show": { "alias": "show"; "required": false; }; }, { "showChange": "showChange"; }, never, ["*"], false, never>;
+}
+
+declare class ImageZoomModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ImageZoomModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ImageZoomModule, [typeof ImageZoomComponent], [typeof i5.IconModule, typeof i3.CommonModule], [typeof ImageZoomComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ImageZoomModule>;
+}
+
+declare class ColorFilterComponent {
+    iconService: IconCacheService;
+    private _sanitizer;
+    readonly icons: typeof IconEnum;
+    showClass(): boolean;
+    set color(value: Color$1);
+    get color(): Color$1;
+    active: boolean;
+    get lightBackground(): boolean;
+    backgroundStyle: SafeStyle;
+    private _color;
+    constructor(iconService: IconCacheService, _sanitizer: DomSanitizer);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ColorFilterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ColorFilterComponent, "co-color-filter", never, { "color": { "alias": "color"; "required": false; }; "active": { "alias": "active"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class ColorFilterModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ColorFilterModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ColorFilterModule, [typeof ColorFilterComponent], [typeof i5.IconModule], [typeof ColorFilterComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ColorFilterModule>;
+}
+
+declare class TagFilterComponent {
+    showClass(): boolean;
+    tag: Tag;
+    active: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TagFilterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TagFilterComponent, "co-tag-filter", never, { "tag": { "alias": "tag"; "required": false; }; "active": { "alias": "active"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class TagFilterModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TagFilterModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TagFilterModule, [typeof TagFilterComponent], never, [typeof TagFilterComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TagFilterModule>;
+}
+
+declare class VisibilityObserverMasterDirective implements OnDestroy {
+    private _mapping;
+    private _observer;
+    constructor();
+    ngOnDestroy(): void;
+    add(element: HTMLElement, callback: Function): void;
+    remove(element: HTMLElement): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VisibilityObserverMasterDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<VisibilityObserverMasterDirective, "[visibilityObserverMaster]", never, {}, {}, never, never, false, never>;
+}
+
+declare class VisibilityObserverDirective implements OnDestroy, OnInit {
+    observerEnabled: boolean;
+    isIntersecting: boolean;
+    IS_INTERSECTING: boolean;
+    IS_NOT_INTERSECTING: boolean;
+    private _elementRef;
+    private _parent;
+    constructor(parent: VisibilityObserverMasterDirective, elementRef: ElementRef);
+    ngOnDestroy(): void;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VisibilityObserverDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<VisibilityObserverDirective, "[visibilityObserver]", ["intersection"], { "observerEnabled": { "alias": "observerEnabled"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class DirectivesModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DirectivesModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DirectivesModule, [typeof VisibilityObserverDirective, typeof VisibilityObserverMasterDirective], never, [typeof VisibilityObserverDirective, typeof VisibilityObserverMasterDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<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 i5.IconModule, typeof i5.PriceDisplayPipeModule, typeof AnswerCardModule, typeof ImageZoomModule, typeof ColorFilterModule, typeof TagFilterModule, typeof DirectivesModule], [typeof AnswersSlideoutComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AnswersSlideoutModule>;
+}
+
+declare class SelectionsSummaryComponent implements OnDestroy {
+    configuratorConnectorService: ConfiguratorConnectorService;
+    iconService: IconCacheService;
+    showClass(): boolean;
+    readonly icons: typeof IconEnum;
+    selections: Selection[];
+    showLabel: boolean;
+    canClose: boolean;
+    answersTemplate: TemplateRef<any>;
+    answerToShowFromSelectionText: string;
+    customDimensions: boolean;
+    disableMouse: boolean;
+    handledocumentMouseUp(event: any): void;
+    handleDocumentMouseDown(event: any): void;
+    readonly closeClick: EventEmitter<void>;
+    readonly cancelAnswers: EventEmitter<void>;
+    readonly selectSelection: EventEmitter<Selection>;
+    readonly repeatSelection: EventEmitter<Selection>;
+    readonly deleteSelection: EventEmitter<Selection>;
+    selectionToCustomize: Selection;
+    valutaSymbol: string;
+    showAsConfigured: boolean;
+    private _subs;
+    constructor(configuratorConnectorService: ConfiguratorConnectorService, iconService: IconCacheService);
+    ngOnDestroy(): void;
+    handleClick(sel: Selection): void;
+    handleRepeat(event: MouseEvent, sel: Selection): void;
+    handleDelete(event: MouseEvent, sel: Selection): void;
+    toggleElement(sel: Selection): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SelectionsSummaryComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SelectionsSummaryComponent, "co-selections-summary", never, { "selections": { "alias": "selections"; "required": false; }; "showLabel": { "alias": "showLabel"; "required": false; }; "canClose": { "alias": "canClose"; "required": false; }; "answersTemplate": { "alias": "answersTemplate"; "required": false; }; "answerToShowFromSelectionText": { "alias": "answerToShowFromSelectionText"; "required": false; }; "customDimensions": { "alias": "customDimensions"; "required": false; }; }, { "closeClick": "closeClick"; "cancelAnswers": "cancelAnswers"; "selectSelection": "selectSelection"; "repeatSelection": "repeatSelection"; "deleteSelection": "deleteSelection"; }, never, never, false, never>;
+}
+
+declare class CoSummaryLine implements AfterViewInit {
+    iconService: IconCacheService;
+    private _changeDetector;
+    showClass(): boolean;
+    readonly icons: typeof IconEnum;
+    titleBlock: ElementRef;
+    imageData: string;
+    title: string;
+    description: string;
+    /**
+     * Total price of the selection
+     */
+    price: number | string;
+    /**
+     * Multiline data for selection tree
+     * title: string
+     * description: string
+     * price: number | string
+     */
+    multilineData: any;
+    valutaSymbol: string;
+    isHighlighted: boolean;
+    isCollapsable: boolean;
+    canRepeat: boolean;
+    isDeletable: boolean;
+    showContent: boolean;
+    repeatClicked: EventEmitter<MouseEvent>;
+    deleteClicked: EventEmitter<MouseEvent>;
+    data: {
+        title: string;
+        description: string;
+        price: number | string;
+    }[];
+    showList: boolean;
+    showCollapsable: boolean;
+    showListTotalPrice: boolean;
+    constructor(iconService: IconCacheService, _changeDetector: ChangeDetectorRef);
+    ngAfterViewInit(): void;
+    collapsableCheck(): void;
+    toggleShowHideList(event: MouseEvent): void;
+    handleRepeatClick(event: MouseEvent): void;
+    handleDeleteClick(event: MouseEvent): void;
+    private _setShowList;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CoSummaryLine, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CoSummaryLine, "co-summary-line", never, { "imageData": { "alias": "imageData"; "required": false; }; "title": { "alias": "title"; "required": false; }; "description": { "alias": "description"; "required": false; }; "price": { "alias": "price"; "required": false; }; "multilineData": { "alias": "multilineData"; "required": false; }; "valutaSymbol": { "alias": "valutaSymbol"; "required": false; }; "isHighlighted": { "alias": "isHighlighted"; "required": false; }; "isCollapsable": { "alias": "isCollapsable"; "required": false; }; "canRepeat": { "alias": "canRepeat"; "required": false; }; "isDeletable": { "alias": "isDeletable"; "required": false; }; "showContent": { "alias": "showContent"; "required": false; }; }, { "repeatClicked": "repeatClicked"; "deleteClicked": "deleteClicked"; }, never, ["*"], false, never>;
+}
+
+declare class CoSummaryLineModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CoSummaryLineModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CoSummaryLineModule, [typeof CoSummaryLine], [typeof PipesModule, typeof i3.CommonModule, typeof i5.PriceDisplayPipeModule, typeof i5.ImageModule, typeof i5.IconModule], [typeof CoSummaryLine]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CoSummaryLineModule>;
+}
+
+declare class SelectionsSummaryLineComponent implements OnDestroy {
+    configuratorConnectorService: ConfiguratorConnectorService;
+    showClass(): boolean;
+    set selection(value: Selection);
+    get selection(): Selection;
+    valutaSymbol: string;
+    answersTemplate: TemplateRef<any>;
+    answerToShowFromSelectionText: string;
+    customizeButtonClicked: EventEmitter<void>;
+    summaryLineClick: EventEmitter<void>;
+    summaryLineRepeat: EventEmitter<MouseEvent>;
+    summaryLineDelete: EventEmitter<MouseEvent>;
+    shouldBeHidden: boolean;
+    selectionDescription: string;
+    showCustomizeButton: boolean;
+    showOnlyLastAnswerDescriptionGenericSelection: boolean;
+    private _subs;
+    private _selection;
+    constructor(configuratorConnectorService: ConfiguratorConnectorService);
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SelectionsSummaryLineComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SelectionsSummaryLineComponent, "co-selections-summary-line", never, { "selection": { "alias": "selection"; "required": false; }; "valutaSymbol": { "alias": "valutaSymbol"; "required": false; }; "answersTemplate": { "alias": "answersTemplate"; "required": false; }; "answerToShowFromSelectionText": { "alias": "answerToShowFromSelectionText"; "required": false; }; }, { "customizeButtonClicked": "customizeButtonClicked"; "summaryLineClick": "summaryLineClick"; "summaryLineRepeat": "summaryLineRepeat"; "summaryLineDelete": "summaryLineDelete"; }, never, never, false, never>;
+}
+
+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 ɵinj: i0.ɵɵInjectorDeclaration<SelectionsSummaryLineModule>;
+}
+
+declare class SelectionsSummaryModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SelectionsSummaryModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SelectionsSummaryModule, [typeof SelectionsSummaryComponent], [typeof CoSummaryLineModule, typeof i3.CommonModule, typeof PipesModule, typeof i5.PriceDisplayPipeModule, typeof SelectionsSummaryLineModule, typeof i5.IconModule], [typeof SelectionsSummaryComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SelectionsSummaryModule>;
+}
+
+declare class LiteSelectorModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<LiteSelectorModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<LiteSelectorModule, [typeof LiteSelectorComponent], [typeof AnswersSlideoutModule, typeof i3.CommonModule, typeof SelectionsSummaryModule], [typeof LiteSelectorComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<LiteSelectorModule>;
+}
+
+declare class ProductConfiguratorService {
+    showChange: EventEmitter<boolean>;
+    answerChosen: EventEmitter<Answer>;
+    selectSelection: EventEmitter<SelectorStructure>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProductConfiguratorService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ProductConfiguratorService>;
+}
+
+declare class ProductConfiguratorComponent implements OnInit, OnDestroy {
+    configuratorConnectorService: ConfiguratorConnectorService;
+    buildFurnitureService: SwitchBuildFurnitureService;
+    settingsService: SettingsService;
+    productConfiguratorService: ProductConfiguratorService;
+    iconService: IconCacheService;
+    private _sanitizer;
+    private _configuringService;
+    showClass(): boolean;
+    readonly icons: typeof IconEnum;
+    set show(value: boolean);
+    get show(): boolean;
+    showHeaderInformation: boolean;
+    set showSelections(value: boolean);
+    get showSelections(): boolean;
+    showLabel: boolean;
+    canClose: boolean;
+    customDimensions: boolean;
+    readonly showChange: EventEmitter<boolean>;
+    readonly answerChosen: EventEmitter<Answer>;
+    valutaSymbol: string;
+    article: Article;
+    selectionList: SelectorWithOptions[];
+    safeDescription: SafeHtml;
+    private _showSelections;
+    private _show;
+    private _selectionSelected;
+    private _subs;
+    constructor(configuratorConnectorService: ConfiguratorConnectorService, buildFurnitureService: SwitchBuildFurnitureService, settingsService: SettingsService, productConfiguratorService: ProductConfiguratorService, iconService: IconCacheService, _sanitizer: DomSanitizer, _configuringService: ConfiguringService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    onSelectionsSummarySelectSelection(chosenOption: SelectorStructure): Promise<void>;
+    handleCloseClick(): void;
+    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; }; }, { "showChange": "showChange"; "answerChosen": "answerChosen"; }, never, never, false, never>;
+}
+
+declare class ProductConfiguratorSelectorComponent implements OnInit {
+    configuratorConnectorService: ConfiguratorConnectorService;
+    settingsService: SettingsService;
+    iconService: IconCacheService;
+    showClass(): boolean;
+    readonly icons: typeof IconEnum;
+    exceptionContainer?: ElementRef;
+    get hostClasses(): string;
+    selection: SelectorStructure;
+    options: SelectorWithOptions[];
+    lastNodeWithChildren: boolean;
+    selectionIndex: number;
+    treeLevelIndex: number;
+    isActive: boolean;
+    markAsException: boolean;
+    activate: EventEmitter<void>;
+    get selectionIndexText(): string;
+    selectionClass: string;
+    listOfChoices: SelectorStructure[];
+    activeChildIndex: number;
+    constructor(configuratorConnectorService: ConfiguratorConnectorService, settingsService: SettingsService, iconService: IconCacheService);
+    ngOnInit(): void;
+    showAndScroll(): void;
+    onSubHeaderClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProductConfiguratorSelectorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ProductConfiguratorSelectorComponent, "co-product-configurator-selector", never, { "selection": { "alias": "selection"; "required": false; }; "options": { "alias": "options"; "required": false; }; "lastNodeWithChildren": { "alias": "lastNodeWithChildren"; "required": false; }; "selectionIndex": { "alias": "selectionIndex"; "required": false; }; "treeLevelIndex": { "alias": "treeLevelIndex"; "required": false; }; "isActive": { "alias": "isActive"; "required": false; }; "markAsException": { "alias": "markAsException"; "required": false; }; }, { "activate": "activate"; }, never, never, false, never>;
+}
+
+declare class ProductConfiguratorSelectorOptionComponent implements OnInit {
+    configuratorConnectorService: ConfiguratorConnectorService;
+    settingsService: SettingsService;
+    productConfiguratorService: ProductConfiguratorService;
+    showClass(): boolean;
+    selection: SelectorStructure;
+    listOfChoices: SelectorStructure[];
+    markAsException: boolean;
+    configurationDisplayOption: typeof ConfigurationDisplayOption;
+    selectionClass: string;
+    showAllTiles: boolean;
+    maxVisibleTiles: number;
+    maxVisibleSmallTiles: number;
+    visibleAnswers: SelectorStructure[];
+    remainingTilesCount: number;
+    constructor(configuratorConnectorService: ConfiguratorConnectorService, settingsService: SettingsService, productConfiguratorService: ProductConfiguratorService);
+    ngOnInit(): void;
+    selectionClicked(answer: SelectorStructure): void;
+    showMore(): void;
+    showLess(): void;
+    private _calculateVisibleAnswers;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProductConfiguratorSelectorOptionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ProductConfiguratorSelectorOptionComponent, "co-product-configurator-selector-option", never, { "selection": { "alias": "selection"; "required": false; }; "listOfChoices": { "alias": "listOfChoices"; "required": false; }; "markAsException": { "alias": "markAsException"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class ProductConfiguratorSelectorOptionTileComponent {
+    configuratorConnectorService: ConfiguratorConnectorService;
+    iconService: IconCacheService;
+    settingsService: SettingsService;
+    showClass(): boolean;
+    readonly icons: typeof IconEnum;
+    option: SelectorStructure;
+    tileClass: string;
+    selectionClicked: EventEmitter<void>;
+    constructor(configuratorConnectorService: ConfiguratorConnectorService, iconService: IconCacheService, settingsService: SettingsService);
+    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; }; }, { "selectionClicked": "selectionClicked"; }, never, never, false, never>;
+}
+
+declare class ProductConfiguratorSelectorOptionTileModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProductConfiguratorSelectorOptionTileModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ProductConfiguratorSelectorOptionTileModule, [typeof ProductConfiguratorSelectorOptionTileComponent], [typeof i5.IconModule, typeof i3.CommonModule, typeof PipesModule], [typeof ProductConfiguratorSelectorOptionTileComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ProductConfiguratorSelectorOptionTileModule>;
+}
+
+declare class ProductConfiguratorOptionCheckboxComponent {
+    configuratorConnectorService: ConfiguratorConnectorService;
+    iconService: IconCacheService;
+    settingsService: SettingsService;
+    showClass(): boolean;
+    readonly icons: typeof IconEnum;
+    option: SelectorStructure;
+    selectionClicked: EventEmitter<void>;
+    constructor(configuratorConnectorService: ConfiguratorConnectorService, iconService: IconCacheService, settingsService: SettingsService);
+    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>;
+}
+
+declare class ProductConfiguratorSelectorOptionCheckboxModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProductConfiguratorSelectorOptionCheckboxModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ProductConfiguratorSelectorOptionCheckboxModule, [typeof ProductConfiguratorOptionCheckboxComponent], [typeof PipesModule, typeof i3.CommonModule, typeof i5.IconModule], [typeof ProductConfiguratorOptionCheckboxComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ProductConfiguratorSelectorOptionCheckboxModule>;
+}
+
+declare class ProductConfiguratorSelectorOptionButtonComponent {
+    configuratorConnectorService: ConfiguratorConnectorService;
+    iconService: IconCacheService;
+    settingsService: SettingsService;
+    showClass(): boolean;
+    readonly icons: typeof IconEnum;
+    option: SelectorStructure;
+    selectionClicked: EventEmitter<void>;
+    constructor(configuratorConnectorService: ConfiguratorConnectorService, iconService: IconCacheService, settingsService: SettingsService);
+    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>;
+}
+
+declare class ProductConfiguratorSelectorOptionButtonModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProductConfiguratorSelectorOptionButtonModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ProductConfiguratorSelectorOptionButtonModule, [typeof ProductConfiguratorSelectorOptionButtonComponent], [typeof PipesModule, typeof i3.CommonModule, typeof i5.IconModule], [typeof ProductConfiguratorSelectorOptionButtonComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ProductConfiguratorSelectorOptionButtonModule>;
+}
+
+declare class ProductConfiguratorSelectorOptionDropDownComponent {
+    configuratorConnectorService: ConfiguratorConnectorService;
+    iconService: IconCacheService;
+    settingsService: SettingsService;
+    showClass(): boolean;
+    readonly icons: typeof IconEnum;
+    options: SelectorStructure[];
+    tileClass: string;
+    selectionClicked: EventEmitter<SelectorStructure>;
+    constructor(configuratorConnectorService: ConfiguratorConnectorService, iconService: IconCacheService, settingsService: SettingsService);
+    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 i5.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 PipesModule, 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 PipesModule, typeof i3.CommonModule, typeof i5.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$1.MatIconModule, typeof i4.MatButtonModule, typeof i5.CardModule, typeof SlideoutModule, typeof i5.PriceDisplayPipeModule, typeof i5.ButtonModule, typeof i5.InputTextModule, typeof i7.FormsModule, typeof PipesModule, typeof i5.IconModule, typeof i5.TooltipDirectiveModule, typeof ProductConfiguratorSelectorModule], [typeof ProductConfiguratorComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ProductConfiguratorModule>;
+}
+
+declare class ThreedselectorModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ThreedselectorModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ThreedselectorModule, [typeof ThreedselectorComponent], [typeof LiteSelectorModule, typeof ProductConfiguratorModule, typeof i3.CommonModule], [typeof ThreedselectorComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ThreedselectorModule>;
+}
+
+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 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: 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>;
+}
+
+declare class ElementButtonsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ElementButtonsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ElementButtonsModule, [typeof ElementButtonsComponent], [typeof i5.IconModule, typeof i3.CommonModule], [typeof ElementButtonsComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ElementButtonsModule>;
+}
+
+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>;
+}
+
+declare class ElementToolbarModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ElementToolbarModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ElementToolbarModule, [typeof ElementToolbarComponent], [typeof PipesModule, typeof i5.IconModule, typeof i3.CommonModule], [typeof ElementToolbarComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ElementToolbarModule>;
+}
+
+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 SceneOptionsComponent implements OnDestroy {
+    iconService: IconCacheService;
+    private _sceneOptionsService;
+    showClass(): boolean;
+    readonly icons: typeof IconEnum;
+    buttons: SceneOptionButtonInterface[];
+    private _subs;
+    private _childrenShowing;
+    constructor(iconService: IconCacheService, _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 i5.IconModule, typeof PipesModule], [typeof SceneOptionsComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SelectionsModule>;
+}
+
+declare enum TextureType {
+    Basic = 0,
+    Image = 1,
+    CustomPattern = 2,
+    PBR = 3,
+    SHADOW = 4
+}
+
+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;
+}
+
+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 ConfiguratorSceneComponent implements OnDestroy {
+    private settingsService;
+    private _sceneService;
+    private _lightService;
+    private _lightPresetService;
+    private _sceneEventService;
+    private _initializerService;
+    showClass(): boolean;
+    canvasElement: ElementRef;
+    private _subs;
+    constructor(settingsService: SettingsService, _sceneService: SceneService, _lightService: LightsService, _lightPresetService: LightPresetsService, _sceneEventService: SceneEventService, _initializerService: AppInitializerService);
+    ngOnDestroy(): void;
+    loadScene(ready: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfiguratorSceneComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ConfiguratorSceneComponent, "co-configurator-scene", never, {}, {}, never, never, false, never>;
+}
+
+declare class ConfiguratorSceneModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfiguratorSceneModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ConfiguratorSceneModule, [typeof ConfiguratorSceneComponent], never, [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;
+    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
+     */
+    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, SelectionsModule, SelectionsSummaryComponent, SelectionsSummaryLineComponent, SelectionsSummaryModule, TagFilterComponent, TagFilterModule, ThreedselectorComponent, ThreedselectorModule };