@colijnit/homedecorator 255.1.1

package/app/plugins/threedselector/element-slider/element-slider.component.d.ts

@@ -0,0 +1,14 @@
+import { MatSliderChange } from '@angular/material/slider';
+import { RotationService } from '../../core3d/service/rotation.service';
+import { HomedecoratorSettingsService } from '../../../core/service/homedecorator-settings.service';
+import * as i0 from "@angular/core";
+export declare class ElementSliderComponent {
+    private _rotationService;
+    settingsService: HomedecoratorSettingsService;
+    sliderValue: number;
+    step: number;
+    constructor(_rotationService: RotationService, settingsService: HomedecoratorSettingsService);
+    getSliderValue(event: MatSliderChange): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ElementSliderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ElementSliderComponent, "rp-element-slider", never, {}, {}, never, never>;
+}

package/app/plugins/threedselector/element-slider/element-slider.component.scss

@@ -0,0 +1,47 @@
+.slidecontainer {
+  width: 40%;
+  position: absolute;
+  left: 30%;
+  top: 85%;
+  z-index: 99;
+}
+
+.slider {
+  appearance: none;
+  width: 100%;
+  height: 25px;
+  background: #d3d3d3;
+  outline: none;
+  opacity: 0.7;
+  transition: opacity .2s;
+  border-radius: 25px;
+}
+
+.slider:hover {
+  opacity: 1;
+}
+
+.slider::-webkit-slider-thumb {
+  -webkit-appearance: none;
+  appearance: none;
+  width: 25px;
+  height: 25px;
+  background: #0094ff;
+  cursor: pointer;
+  border-radius: 25px;
+}
+
+::ng-deep {
+  .mat-slider.mat-slider-horizontal .mat-slider-wrapper {
+    top: 12px;
+  }
+
+  .mat-slider.mat-slider-horizontal .mat-slider-track-wrapper {
+    height: 0;
+    border-radius: 0;
+  }
+
+  .mat-slider-min-value:not(.mat-slider-thumb-label-showing) .mat-slider-thumb {
+    background: #0094ff;
+  }
+}

package/app/plugins/threedselector/element-toolbar/element-toolbar.component.d.ts

@@ -0,0 +1,26 @@
+import { ElementRef, EventEmitter, OnDestroy } from '@angular/core';
+import { IconEnum } from '../../../core/enum/icon.enum';
+import { CustomButton } from '../../../core/model/custom-button';
+import { HomedecoratorSettingsService } from '../../../core/service/homedecorator-settings.service';
+import { HomedecoratorIconCacheService } from '../../../core/service/homedecorator-icon-cache.service';
+import * as i0 from "@angular/core";
+export declare class ElementToolbarComponent implements OnDestroy {
+    settingsService: HomedecoratorSettingsService;
+    iconCache: HomedecoratorIconCacheService;
+    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: HomedecoratorSettingsService, iconCache: HomedecoratorIconCacheService);
+    ngOnDestroy(): void;
+    handleEditClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ElementToolbarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ElementToolbarComponent, "rp-element-toolbar", never, { "editMenu": "editMenu"; "showPointer": "showPointer"; "showSwap": "showSwap"; }, { "deleteClicked": "deleteClicked"; "swapClicked": "swapClicked"; "animationClicked": "animationClicked"; }, never, never>;
+}

package/app/plugins/threedselector/element-toolbar/element-toolbar.component.scss

@@ -0,0 +1,142 @@
+
+
+:host {
+  position: absolute;
+  display: block;
+  height: 50px;
+  top: 64px;
+  left: 50%;
+  width: 150px;
+  transform: translateX(-50%);
+  &.custom-menu {
+    top: 90px;
+    left: 80px;
+    height: auto;
+    transform: translateX(0);
+    .toolbar-wrapper {
+      column-gap: 10px;
+    }
+    .toolbar-button {
+      cursor: pointer;
+      display: flex;
+      align-items: center;
+
+      .instant-edit-button {
+        display: flex;
+        align-items: center;
+
+        ::ng-deep co-icon {
+          margin-right: 7px;
+          border: 1px solid black;
+          width: 18px;
+          height: 18px;
+          border-radius: 10px;
+
+          svg g {
+            polygon {
+              fill: black;
+            }
+            path {
+              fill: black;
+            }
+          }
+        }
+      }
+
+      button {
+        box-shadow: none;
+        border: 1px solid rgba(0, 0, 0, 0.1);
+        height: 30px;
+        width: 30px;
+        .mat-icon {
+          height: 30px;
+          width: 30px;
+        }
+      }
+    }
+    .toolbar-label {
+      font-size: 12px;
+      font-weight: bold;
+      margin-right: 22px;
+    }
+    .edit-menu-wrapper {
+      left: 0;
+      transform: translateX(0);
+    }
+  }
+
+  @media screen and (max-width: 768px) {
+    &.custom-menu {
+      top: 18px;
+      left: 5%;
+    }
+  }
+}
+
+.toolbar-wrapper {
+  display: flex;
+  align-items: center;
+}
+.toolbar-wrapper button:not(:last-child) {
+  margin-right: 5px;
+}
+
+:host ::ng-deep .mat-mini-fab .mat-button-wrapper {
+  padding: 0;
+  display: flex;
+  line-height: 0px;
+  align-items: center;
+  justify-content: center;
+}
+
+:host ::ng-deep .mat.mat-mini-fab {
+  margin-right: 200px;
+}
+
+:host ::ng-deep .mat-icon {
+  height: 40px;
+  width: 40px;
+}
+
+.element-pointer {
+  pointer-events: none;
+  position: absolute;
+  width: 0px;
+  border-left: 2px dashed #2c67ff;
+  transform-origin: top center;
+  top: 45px;
+  left: 50%;
+  margin-left: 20px;
+}
+
+.edit-menu-wrapper {
+  position: absolute;
+  margin-top: 10px;
+  min-width: 175px;
+  left: 25px;
+  transform: translateX(-50%);
+  overflow: hidden;
+}
+.edit-menu-wrapper .edit-menu:not(:last-child) {
+  margin-bottom: 5px;
+}
+.edit-menu {
+  font-size: 12px;
+  background: white;
+  color: #41403D;
+  height: 30px;
+  display: flex;
+  align-items: center;
+  padding: 5px;
+  cursor: pointer;
+  white-space: nowrap;
+  display: flex;
+  justify-content: space-between;
+  span {
+    margin-right: 50px;
+  }
+  mat-icon {
+    width: 20px;
+    height: 20px;
+  }
+}

package/app/plugins/threedselector/threedselector/model/furniture-connected-part-integration.d.ts

@@ -0,0 +1,7 @@
+export declare class FurnitureConnectedPartIntegration {
+    ConnectionLabel: string;
+    ForeignConnectionLabel: string;
+    ForeignPartId: string;
+    Position: any;
+    Rotation: any;
+}

package/app/plugins/threedselector/threedselector/model/furniture-integration.d.ts

@@ -0,0 +1,12 @@
+import * as THREE from 'three';
+import { FurniturePartIntegration } from './furniture-part-integration';
+export declare class FurnitureIntegration {
+    Id: string;
+    MrpCode: string;
+    BrandIdentifier: string;
+    Parts: FurniturePartIntegration[];
+    Position: THREE.Vector3;
+    Rotation: THREE.Euler;
+    Variation: string;
+    VariationDescription: string;
+}

package/app/plugins/threedselector/threedselector/model/furniture-part-integration.d.ts

@@ -0,0 +1,14 @@
+import { FurnitureConnectedPartIntegration } from './furniture-connected-part-integration';
+import { FurniturePartVariation } from './furniture-part-variation';
+export declare class FurniturePartIntegration {
+    Id: string;
+    SupplierArticleNr: string;
+    BrandDescription: string;
+    BrandIdentifier: string;
+    ConnectedParts: FurnitureConnectedPartIntegration[];
+    Position: any;
+    Rotation: any;
+    Variations: FurniturePartVariation[];
+    Variation: string;
+    VariationDescription: string;
+}

package/app/plugins/threedselector/threedselector/model/furniture-part-variation.d.ts

@@ -0,0 +1,7 @@
+export declare class FurniturePartVariation {
+    Variation: string;
+    VariationDescription: string;
+    MaterialId: string;
+    SupplierArticleNr: string;
+    Option: string;
+}

package/app/plugins/threedselector/threedselector/model/material.d.ts

@@ -0,0 +1,41 @@
+import * as THREE from 'three';
+import { Side } from 'three';
+export declare class Material {
+    name: string;
+    schema: string;
+    specular: THREE.Color;
+    shininess: number;
+    normal: THREE.Texture;
+    texture: THREE.Texture;
+    ao: THREE.Texture;
+    metalness: THREE.Texture;
+    roughness: THREE.Texture;
+    repeatX: number;
+    repeatY: number;
+    loaded: boolean;
+    metalnessValue: number;
+    roughnessValue: number;
+    displacement: THREE.Texture;
+    displacementValue: number;
+    sheen: number;
+    sheenColor: THREE.Color;
+    sheenColorMap: THREE.Texture | null;
+    sheenRoughness: number;
+    sheenRoughnessMap: THREE.Texture | null;
+    emissive: THREE.Texture;
+    emissiveValue: THREE.Color;
+    emissiveIntensityValue: number;
+    envMap: THREE.Texture;
+    envMapIntensity: number;
+    opacity: number;
+    transparent: boolean;
+    reflectivity: number;
+    side: Side;
+    ior: number;
+    transmission: number;
+    thickness: number;
+    specularIntensity: number;
+    transmissionMap: THREE.Texture | null;
+    clearcoatMap: THREE.Texture | null;
+    clearcoatRoughnessMap: THREE.Texture | null;
+}

package/app/plugins/threedselector/threedselector/model/variation-settings.d.ts

@@ -0,0 +1,53 @@
+import { Subject } from 'rxjs';
+import { Color, Side } from 'three';
+export declare class VariationSettingsSettings {
+    repeatx: number;
+    repeaty: number;
+    roughness: number;
+    metalness: number;
+}
+export 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>;
+}

package/app/plugins/threedselector/threedselector/model/variation.d.ts

@@ -0,0 +1,11 @@
+import { Material } from './material';
+export declare class Variation {
+    decoId: number;
+    brandId: string;
+    gameObjectName: string;
+    node: any;
+    optionText: string;
+    supplierArticleNr: string;
+    materialId: string;
+    material: Material;
+}

package/app/plugins/threedselector/threedselector/service/animation.service.d.ts

@@ -0,0 +1,22 @@
+import { Item } from '../../../core3d/items/item';
+import { ItemGroupService } from '../../../core3d/service/item-group.service';
+import { UtilsService } from '../../../../core/service/utils.service';
+import { MessageBusService } from '../../../../core/service/message-bus.service';
+import { SceneService } from '../../../core3d/service/scene.service';
+import * as i0 from "@angular/core";
+export declare class AnimationService {
+    private _itemGroupService;
+    private _utilsService;
+    private _messageBusService;
+    private _sceneService;
+    animationPlaying: boolean;
+    selectedObject: Item;
+    private _clock;
+    private _selectedObject;
+    private _subs;
+    constructor(_itemGroupService: ItemGroupService, _utilsService: UtilsService, _messageBusService: MessageBusService, _sceneService: SceneService);
+    playAnimation(element: Item): void;
+    findAnimation(gltf: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AnimationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AnimationService>;
+}

package/app/plugins/threedselector/threedselector/service/build-furniture.service.d.ts

@@ -0,0 +1,186 @@
+import { Selection } from '@colijnit/configuratorapi/build/model/selection';
+import { OnDestroy } from '@angular/core';
+import { Subject } from 'rxjs';
+import { Answer } from '@colijnit/configuratorapi/build/model/answer';
+import { Mesh, Object3D, Vector3 } from 'three';
+import { MatDialog } from '@angular/material/dialog';
+import { Question } from '@colijnit/configuratorapi/build/model/question';
+import { Item } from '../../../core3d/items/item';
+import { Metadata } from '../../../core3d/items/metadata';
+import { CustomFloorGroupResult } from '../../../core3d/model/custom-floor-group-result';
+import { ThreedselectorService } from './threedselector.service';
+import { CollisionManagerService } from '../../../core3d/collision-manager/collision-manager.service';
+import { MessageBusService } from '../../../../core/service/message-bus.service';
+import { HudService } from '../../../core3d/service/hud.service';
+import { SceneService } from '../../../core3d/service/scene.service';
+import { CameraService } from '../../../core3d/service/camera.service';
+import { SceneEventService } from '../../../core3d/service/scene-event.service';
+import { PresetsService } from '../../../../core/service/presets.service';
+import { ItemService } from '../../../core3d/service/item.service';
+import { ElementService } from './element.service';
+import { PermanentStoreService } from '../../../../core/service/permanent-store.service';
+import { GoogleTagManagerService } from '../../../../service/google-tag-manager.service';
+import { UtilsService } from '../../../../core/service/utils.service';
+import { VariationService } from './variation.service';
+import { AppStateService } from '../../../../core/service/app-state.service';
+import { ErrorService } from '../../../../core/service/error.service';
+import { ItemGroupService } from '../../../core3d/service/item-group.service';
+import { VariationCacheService } from './variation-cache.service';
+import { ResizeService } from './resize.service';
+import { ViewModeService } from '../../../../core/service/view-mode.service';
+import { CustomMesh, CustomObject3D } from '../../../core3d/items/custom-objects';
+import { HomedecoratorConnectorService } from '../../../../core/service/homedecorator-connector.service';
+import { HomedecoratorDictionaryService } from '../../../../core/service/homedecorator-dictionary.service';
+import { HomedecoratorAppEventService } from '../../../../core/service/homedecorator-app-event.service';
+import { HomedecoratorSettingsService } from '../../../../core/service/homedecorator-settings.service';
+import { FloorService } from '../../../core3d/service/floor.service';
+import * as i0 from "@angular/core";
+export interface ConfiguringModeChangeInterface {
+    metadata: Metadata;
+    configuring: boolean;
+}
+export declare class BuildFurnitureService implements OnDestroy {
+    private _dialog;
+    private _iOne;
+    private _threedSelectorService;
+    private _collisionManager;
+    private _messageBus;
+    private _dictionaryService;
+    private _hudService;
+    private _sceneService;
+    private _cameraService;
+    private _sceneEventService;
+    private _appEventService;
+    private _presetService;
+    private _itemService;
+    private _elementService;
+    private _permanentStoreService;
+    private _googleTagManager;
+    private _settingsService;
+    private _utilsService;
+    private _variationService;
+    private _appStateService;
+    private _errorService;
+    private _itemGroupService;
+    private _variationCacheService;
+    private _resizeService;
+    private _viewModeService;
+    private _floorService;
+    baseElementNodeId: number;
+    articleAssetPath: string;
+    toggleSelectedElement: Subject<Mesh>;
+    configureModeChanged: Subject<ConfiguringModeChangeInterface>;
+    buildFinished: Subject<CustomFloorGroupResult>;
+    answerSelected: Subject<CustomFloorGroupResult>;
+    arPlacementUpdate: Subject<boolean>;
+    showElementToolbar: boolean;
+    startPosition: Vector3;
+    full3DObjectToUse: Object3D;
+    isMouseOverObject: boolean;
+    activeConnector: any;
+    get useNodeIdToLink(): boolean;
+    get currentCustomFloorGroup(): Item;
+    activeQuestion: Question;
+    activeAnswers: Answer[];
+    get standAlone(): boolean;
+    set standAlone(value: boolean);
+    get selections(): Selection[];
+    standAloneFirstBuildReady: boolean;
+    private get scene();
+    private _useNodeIdToLink;
+    private _standAlone;
+    private _activeChildElement;
+    private _originalElementPosition;
+    private _integrationEnabled;
+    private _placedAdjustables;
+    private _placedAddables;
+    private _adjustables;
+    private _addables;
+    private _currentCustomFloorGroup;
+    private _genericSelection;
+    private _subs;
+    private _answerSelected;
+    private _furnitureConfigurations;
+    constructor(_dialog: MatDialog, _iOne: HomedecoratorConnectorService, _threedSelectorService: ThreedselectorService, _collisionManager: CollisionManagerService, _messageBus: MessageBusService, _dictionaryService: HomedecoratorDictionaryService, _hudService: HudService, _sceneService: SceneService, _cameraService: CameraService, _sceneEventService: SceneEventService, _appEventService: HomedecoratorAppEventService, _presetService: PresetsService, _itemService: ItemService, _elementService: ElementService, _permanentStoreService: PermanentStoreService, _googleTagManager: GoogleTagManagerService, _settingsService: HomedecoratorSettingsService, _utilsService: UtilsService, _variationService: VariationService, _appStateService: AppStateService, _errorService: ErrorService, _itemGroupService: ItemGroupService, _variationCacheService: VariationCacheService, _resizeService: ResizeService, _viewModeService: ViewModeService, _floorService: FloorService);
+    ngOnDestroy(): void;
+    build(result: CustomFloorGroupResult): Promise<CustomFloorGroupResult>;
+    startToBuild(result?: CustomFloorGroupResult, metadata?: Metadata, shouldCopyInstance?: boolean, looseOriginalConfiguration?: boolean, standAlone?: boolean, firstBuild?: boolean): Promise<CustomFloorGroupResult>;
+    getOptionsFromSelection(baseSelection: Selection): Selection[];
+    downloadCurrentCustomFloorgroup(): void;
+    downloadScene(): void;
+    createSimple3DModel(result: CustomFloorGroupResult, standAlone?: boolean): CustomFloorGroupResult;
+    private _buildFloor;
+    private _startToBuildFromConfigurator;
+    private _setInstanceToConfigure;
+    private _prepareSelectionsAndDecos;
+    private _preloadMaterials;
+    private _getSelectionsAndDecosFromMetadata;
+    private _selectionPublished;
+    private _handleIntegration;
+    private _startWithNew;
+    private _cleanupBeforePresetLoad;
+    private _handleAfterPresetLoad;
+    private _cleanup;
+    private _enableIntegration;
+    private _handleItemRemovedFromScene;
+    private _clearElements;
+    private _handleIntegrationConnections;
+    private _upsertFurniture;
+    private _setCodeOnFurnitureConfiguration;
+    private _canConnectSelections;
+    private _handleSelectionsReceived;
+    private _handleConnectionReset;
+    private _handleAnswerSelected;
+    cancelAnswer(metadata: Metadata, rebuild?: boolean, getAnswers?: boolean): Promise<void>;
+    selectSelection(selection: Selection, metadata: Metadata, forceBackToNode?: boolean, after?: boolean, connector?: string): Promise<void>;
+    deleteSelection(selection: Selection, metadata: Metadata): Promise<void>;
+    replaceSelection(selection: Selection, metadata: Metadata): Promise<void>;
+    selectAnswer(answer: Answer, input: string, metadata: Metadata): Promise<void>;
+    private _getActiveFurniture;
+    private _linkSelectionsAndDecos;
+    private _createConfigurableItem;
+    private _createPositionAnimation;
+    private _animateChanges;
+    private _replaceCurrentItem;
+    mouseOver: () => void;
+    mouseOff: () => void;
+    selectItem: (mesh: Mesh) => void;
+    unSelectItem: () => void;
+    selectElement: (element: Mesh, mousePos: Vector3) => void;
+    unSelectElement: () => void;
+    moveChildElement: (element: CustomObject3D, pos: Vector3) => void;
+    placeChildElement: (element: CustomObject3D) => Promise<void>;
+    changeConfigureMode: (metadata: Metadata, configuring: boolean) => Promise<void>;
+    dragConnector: (connector: CustomMesh, pos: Vector3) => Promise<void>;
+    cancelConfiguringCurrentInstance(): void;
+    private _isMoveableObject;
+    private _addElementOnConnector;
+    private _saveElementConnector;
+    /**
+     * @param element The element to move
+     * @param pos The local position
+     * @private
+     */
+    private _moveChildElementToPosition;
+    private _reset;
+    /**
+     * Returns the materialId of the parent up the tree until presentionlevel 1 is reached
+     * @param id
+     * @private
+     */
+    private _getMaterialIdFromParent;
+    private _prepareTheSelections;
+    private _getAdjustables;
+    private _getVariations;
+    private _createAdjustable;
+    private _createAddable;
+    private _placeAddable;
+    private _createUniqueName;
+    private _placeAddables;
+    private _loadVariations;
+    private _showWarning;
+    private _prepareStandAlone;
+    private _preloadMaterial;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BuildFurnitureService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BuildFurnitureService>;
+}

package/app/plugins/threedselector/threedselector/service/dimensions.service.d.ts

@@ -0,0 +1,33 @@
+import { OnDestroy } from '@angular/core';
+import { ItemService } from '../../../core3d/service/item.service';
+import { SceneService } from '../../../core3d/service/scene.service';
+import { FontService } from '../../../core3d/service/font.service';
+import * as i0 from "@angular/core";
+export declare class DimensionsService implements OnDestroy {
+    private _itemService;
+    private _sceneService;
+    private _fontService;
+    set enabled(value: boolean);
+    get enabled(): boolean;
+    private readonly _offSet;
+    private readonly _labelOffSet;
+    private readonly _nameHeightArrow;
+    private readonly _nameWidthArrow;
+    private readonly _nameDepthArrow;
+    private readonly _headLength;
+    private readonly _headWidth;
+    private readonly _defaultColor;
+    private _subs;
+    private _dimensions;
+    private _enabled;
+    constructor(_itemService: ItemService, _sceneService: SceneService, _fontService: FontService);
+    ngOnDestroy(): void;
+    private _renderDimensions;
+    private _removeDimensionsOfNotExistingFurniture;
+    private _removeDimensions;
+    private _positionDimensions;
+    private _createDimensions;
+    private _createLabel;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DimensionsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DimensionsService>;
+}

package/app/plugins/threedselector/threedselector/service/element.service.d.ts

@@ -0,0 +1,45 @@
+import { Object3D, Vector3 } from 'three';
+import { SceneService } from '../../../core3d/service/scene.service';
+import { ErrorGlowService } from '../../../core3d/service/error-glow.service';
+import { OutlineService } from '../../../core3d/service/outline.service';
+import { HomedecoratorConnectorService } from '../../../../core/service/homedecorator-connector.service';
+import * as i0 from "@angular/core";
+export interface CollisionInfo {
+    collision?: boolean;
+    validX?: boolean;
+    validZ?: boolean;
+}
+export declare class ElementService {
+    private _sceneService;
+    private _errorGlowService;
+    private _outlineService;
+    private _ione;
+    private readonly _connectorPositionOffset;
+    private readonly _roundDecimals;
+    private _baseBoundaries;
+    private _elementBoundaries;
+    private _collisionPosition;
+    constructor(_sceneService: SceneService, _errorGlowService: ErrorGlowService, _outlineService: OutlineService, _ione: HomedecoratorConnectorService);
+    moveElementToNewPosition(instance: string, element: Object3D, newPosition: Vector3, baseElement: Object3D): void;
+    placeElementOnConnector(instance: string, element: Object3D, baseElement: Object3D, animate?: boolean, onConnector?: string, saveConnector?: boolean): Promise<string>;
+    removeElement(instanceId: string, id?: string): void;
+    private _isValidConnectorForElement;
+    private _getCollisionInfo;
+    private _roundBox;
+    private _intersectionBox;
+    private _getNearestConnector;
+    private _prepareBaseBoundaries;
+    private _getElementBoundariesBasedOnPosition;
+    private _round;
+    private _validPositionOnXAxis;
+    private _validPositionOnZAxis;
+    private _getParentObject;
+    private _finishPlacement;
+    private _saveBoundaries;
+    private _clearConnectorConnected;
+    private _moveToPosition;
+    private _getMatchingConnectorsFromElement;
+    private _disconnectElementFromBase;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ElementService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ElementService>;
+}