@colijnit/configurator 261.1.0 → 261.1.1

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

@@ -0,0 +1,117 @@
+import { Selection } from '@colijnit/configuratorapi/build/model/selection';
+import { OnDestroy } from '@angular/core';
+import { Answer } from '@colijnit/configuratorapi/build/model/answer';
+import { Euler, Mesh, Object3D, Scene, Vector3 } from 'three';
+import { VariationService } from './variation.service';
+import { VariationCacheService } from './variation-cache.service';
+import { SelectorStructure } from '@colijnit/configuratorapi/build/model/selector-structure.bo';
+import { Subject, Subscription } from 'rxjs';
+import { ConfiguratorConnectorService } from './configurator-connector.service';
+import { SettingsService } from './settings.service';
+import { DictionaryService } from './dictionary.service';
+import { AppEventService } from './app-event.service';
+import { ConfigurationResultObject } from '../model/configuration-result-object';
+import { UtilsService } from './utils.service';
+import { ItemService } from './item.service';
+import * as i0 from "@angular/core";
+export 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>;
+}

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

@@ -0,0 +1,14 @@
+import { OnDestroy } from '@angular/core';
+import { BuildFurnitureBaseService } from './build-furniture-base.service';
+import { ConfigurationResultObject } from '../model/configuration-result-object';
+import * as i0 from "@angular/core";
+export 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>;
+}

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

@@ -0,0 +1,14 @@
+import { OnDestroy } from '@angular/core';
+import { BuildFurnitureBaseService } from './build-furniture-base.service';
+import { ConfigurationResultObject } from '../model/configuration-result-object';
+import * as i0 from "@angular/core";
+export 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>;
+}

package/lib/services/bundle-initialzer.service.d.ts

@@ -0,0 +1,45 @@
+import { Texture } from '../model/texture';
+import { LightPreset } from '../model/light-preset';
+import { BehaviorSubject } from 'rxjs';
+import { JsonUtilsService } from './json-utils.service';
+import { SettingsService } from './settings.service';
+import { ConfiguratorConnectorService } from './configurator-connector.service';
+import { ConfigurationService } from './configuration.service';
+import { OnDestroy } from '@angular/core';
+import { SceneService } from './scene.service';
+import { SceneOptionsService } from './scene-options.service';
+import { AppInitializerService } from './app-initializer.service';
+import { Setting } from '../model/settings';
+import * as i0 from "@angular/core";
+export 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>;
+}

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

@@ -0,0 +1,44 @@
+import { OnDestroy } from '@angular/core';
+import { PerspectiveCamera } from 'three';
+import { Subject } from 'rxjs';
+import { SettingsService } from './settings.service';
+import * as i0 from "@angular/core";
+export 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>;
+}

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

@@ -0,0 +1,18 @@
+import { BehaviorSubject } from 'rxjs';
+import { ConfigurationKey } from '../enum/configuration-key.enum';
+import { ConfigurationData } from '../interfaces/configuration-data.interface';
+import * as i0 from "@angular/core";
+export declare const angleDegree = "\u00B0";
+export declare const dimCentiMeter = "cm";
+export declare const dimSqMeter = "m\u00B2";
+export 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>;
+}

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

@@ -0,0 +1,140 @@
+import { OnDestroy } from '@angular/core';
+import { ConfiguratorService } from './configurator.service';
+import { DataServiceResponseData } from '@colijnit/ioneconnector/build/model/data-service-response-data';
+import { AppEventService } from './app-event.service';
+import { Article } from '@colijnit/configuratorapi/build/model/article';
+import { Selection } from '@colijnit/configuratorapi/build/model/selection';
+import { Answer } from '@colijnit/configuratorapi/build/model/answer';
+import { SelectorStructure } from '@colijnit/configuratorapi/build/model/selector-structure.bo';
+import { SelectorWithOptions } from '@colijnit/configuratorapi/build/model/selector-with-options';
+import { QuestionAndAnswers } from '@colijnit/configuratorapi/build/model/question-and-answers';
+import { AnswerPrice } from '@colijnit/configuratorapi/build/model/answer-price';
+import { Question } from '@colijnit/configuratorapi/build/model/question';
+import { ArticleText } from '@colijnit/configuratorapi/build/model/article-text.bo';
+import { SkipButtonInfo } from '@colijnit/configuratorapi/build/model/skip-button-info';
+import { InternalParam } from '@colijnit/mainapi/build/enum/internal-param.enum';
+import { DecoNode } from '@colijnit/configuratorapi/build/model/deco-node';
+import { BehaviorSubject, Subject } from 'rxjs';
+import { ConfigurationResultObject } from '../model/configuration-result-object';
+import { SettingsService } from './settings.service';
+import { LoaderService } from './loader.service';
+import { ConfiguratorStatisticsEnvironment } from '@colijnit/configuratorapi/build/model/configurator-statistics-environment';
+import * as i0 from "@angular/core";
+export 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>;
+}

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

@@ -0,0 +1,62 @@
+import { Selection } from '@colijnit/configuratorapi/build/model/selection';
+import { Answer } from '@colijnit/configuratorapi/build/model/answer';
+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 { Subject } from 'rxjs';
+import { ConfiguratorStatisticsEnvironment } from '@colijnit/configuratorapi/build/model/configurator-statistics-environment';
+import * as i0 from "@angular/core";
+export 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>;
+}

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

@@ -0,0 +1,46 @@
+import { EventEmitter, OnDestroy } from '@angular/core';
+import { ConfiguratorSettings } from '../model/configurator-settings';
+import { Scene } from 'three';
+import { AppInitializerService } from './app-initializer.service';
+import { ConfigurationResultObject } from '../model/configuration-result-object';
+import { SwitchLoadFurnitureService } from './switch-load-furniture.service';
+import { AppEventService } from './app-event.service';
+import { SwitchBuildFurnitureService } from './switch-build-furniture.service';
+import { ConfiguratorConnectorService } from './configurator-connector.service';
+import * as i0 from "@angular/core";
+export 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>;
+}

package/lib/services/controls.d.ts

@@ -0,0 +1,11 @@
+/**
+ This file is a modified version of THREE.OrbitControls
+ Contributors:
+ * @author qiao / https://github.com/qiao
+ * @author mrdoob / http://mrdoob.com
+ * @author alteredq / http://alteredqualia.com/
+ * @author WestLangley / http://github.com/WestLangley
+ * @author erich666 / http://erichaines.com
+ */
+declare let Controls: (camera: any, domElement: any) => void;
+export { Controls };

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

@@ -0,0 +1,16 @@
+import * as i0 from "@angular/core";
+export 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>;
+}

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

@@ -0,0 +1,15 @@
+import { JsonUtilsService } from './json-utils.service';
+import * as i0 from "@angular/core";
+export 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>;
+}

package/lib/services/dynamic-camera.service.d.ts

@@ -0,0 +1,21 @@
+import { CameraSettings } from '../model/camera-settings';
+import { CameraService } from './camera.service';
+import { SceneService } from './scene.service';
+import { SettingsService } from './settings.service';
+import { ConfiguratorConnectorService } from './configurator-connector.service';
+import * as i0 from "@angular/core";
+export 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>;
+}

package/lib/services/floor-plane.service.d.ts

@@ -0,0 +1,47 @@
+import { Object3D, Vector3 } from 'three';
+import { SettingsService } from './settings.service';
+import { SceneService } from './scene.service';
+import { SceneOptionsService } from './scene-options.service';
+import { BundleInitializerService } from './bundle-initialzer.service';
+import { OnDestroy } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+export 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>;
+}

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

@@ -0,0 +1,10 @@
+import { Font } from 'three/examples/jsm/loaders/FontLoader';
+import * as i0 from "@angular/core";
+export declare class FontService {
+    hudFont: Font;
+    monospaceFont: Font;
+    constructor();
+    private _loadFont;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FontService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FontService>;
+}