@colijnit/homedecorator 255.1.1

package/app/plugins/room-planner/components/settings/settings-options.component.scss

@@ -0,0 +1,46 @@
+:host {
+  .edit-popup {
+    position: fixed;
+    min-height: 200px;
+    min-width: 400px;
+    top: 50%;
+    left: 50%;
+    transform: translate(-50%, -50%);
+    background: white;
+    box-shadow: 0px 0px 5px 1px rgb(0 0 0 / 50%);
+  }
+  .title-bar {
+    display: flex;
+    justify-content: space-between;
+    background: #3760a1;
+    color: white;
+    padding-left: 10px;
+
+    .title-bar-move {
+      display: flex;
+      flex-basis: 100%;
+      align-items: center;
+
+      .title-description {
+        user-select: none;
+      }
+    }
+
+    mat-icon {
+      color: white;
+    }
+  }
+  .popup-content {
+    padding: 20px;
+  }
+  .section-title {
+    font-size: 12px;
+    font-weight: bold;
+  }
+  .section-content {
+    margin-top: 10px;
+    font-size: 12px;
+    display: grid;
+    grid-template-columns: 80% 20%;
+  }
+}

package/app/plugins/room-planner/components/settings/settings.component.d.ts

@@ -0,0 +1,63 @@
+import { ElementRef, EventEmitter, OnDestroy, OnInit } from '@angular/core';
+import { MatSnackBar } from '@angular/material/snack-bar';
+import { ConfigurationKey } from '../../../../core/enum/configuration-key.enum';
+import { HomedecoratorSettingsService } from '../../../../core/service/homedecorator-settings.service';
+import { MessageBusService } from '../../../../core/service/message-bus.service';
+import { ConfigurationService } from '../../../../core/service/configuration.service';
+import { SceneService } from '../../../core3d/service/scene.service';
+import { ItemService } from '../../../core3d/service/item.service';
+import { HomedecoratorAppService } from '../../../../core/service/homedecorator-app.service';
+import { FontService } from '../../../core3d/service/font.service';
+import * as i0 from "@angular/core";
+export declare class SettingsComponent implements OnInit, OnDestroy {
+    settingsService: HomedecoratorSettingsService;
+    private _snackBar;
+    private _messageBus;
+    private _configurationService;
+    private _sceneService;
+    private _itemService;
+    private _appService;
+    private _fontService;
+    readonly configurationKey: typeof ConfigurationKey;
+    versionFieldRef: ElementRef;
+    minWallHeight: number;
+    placeCameraDisabled: boolean;
+    onWallsHeightUpdate: EventEmitter<number>;
+    version: string;
+    wallHeight: number;
+    dimensioningUnit: string;
+    angleUnit: string;
+    wallThickness: number;
+    showObjectDistances: boolean;
+    showObjectMeasurements: boolean;
+    showDetailedWallMeasurements: boolean;
+    showWallItemMeasurements: boolean;
+    rotationSnappingEnabled: boolean;
+    showCameraControls: boolean;
+    showLightControls: boolean;
+    showWalls: boolean;
+    showCeiling: boolean;
+    wallSnapping: boolean;
+    cornerSnapping: boolean;
+    displayCustomShapeNames: boolean;
+    showInteriorLights: boolean;
+    interiorLightIntensity: number;
+    showSettingsOptions: boolean;
+    enableTouch: boolean;
+    constructor(settingsService: HomedecoratorSettingsService, _snackBar: MatSnackBar, _messageBus: MessageBusService, _configurationService: ConfigurationService, _sceneService: SceneService, _itemService: ItemService, _appService: HomedecoratorAppService, _fontService: FontService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    applyNewHeight(height: number): void;
+    toggle(key: ConfigurationKey, checked: boolean): void;
+    setInteriorLightIntensity(value: number): void;
+    removeAll(): void;
+    compareEnum(a: string, b: string): boolean;
+    placeCamera(): Promise<void>;
+    handleBackendUrlChange(event: KeyboardEvent): void;
+    hideMaterials(): void;
+    showConnectors(): void;
+    selectVersionFieldContent(): void;
+    copyToClipboard(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SettingsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SettingsComponent, "rp-settings", never, { "minWallHeight": "minWallHeight"; "placeCameraDisabled": "placeCameraDisabled"; }, { "onWallsHeightUpdate": "onWallsHeightUpdate"; }, never, never>;
+}

package/app/plugins/room-planner/components/settings/settings.component.scss

@@ -0,0 +1,42 @@
+:host {
+  overflow-y: auto;
+  overflow-x: hidden;
+  .powered-by-wrapper {
+    margin-top: 20px;
+    font-size: 12px;
+    .powered-logo-wrapper {
+      display: flex;
+      align-items: center;
+      justify-content: space-between;
+    }
+    .colijn-it-logo {
+      margin: 0 5px;
+      img {
+        width: 100px;
+      }
+    }
+    .ione-360-logo {
+      margin: 5px;
+      img {
+        width: 134px;
+      }
+    }
+  }
+}
+
+.panel-item {
+  min-height: 40px;
+}
+
+.panel-item + h3 {
+  margin-top: 16px;
+}
+
+mat-form-field {
+  width: 100%;
+}
+
+::ng-deep .mat-drawer-content {
+  overflow-y: auto;
+  overflow-x: hidden;
+}

package/app/plugins/room-planner/components/texture-editor/texture-editor.component.d.ts

@@ -0,0 +1,125 @@
+import * as THREE from 'three';
+import { ElementRef, EventEmitter, OnChanges, OnDestroy, OnInit, SimpleChanges } from '@angular/core';
+import { TextureType } from '../../../../core/model/texture-type';
+import { Texture } from '../../../../core/model/texture';
+import { HomedecoratorSettingsService } from '../../../../core/service/homedecorator-settings.service';
+import * as i0 from "@angular/core";
+export declare enum TextureEditorOptions {
+    None = 0,
+    Image = 1,
+    Tiles = 2,
+    Both = 3
+}
+export declare class TextureEditorComponent implements OnInit, OnChanges, OnDestroy {
+    private _settingsService;
+    readonly textureType: typeof TextureType;
+    fileInput: ElementRef;
+    canvas: ElementRef;
+    width: number;
+    height: number;
+    texturePlane: any;
+    plainTexture: any;
+    changedTexture: Texture;
+    options: TextureEditorOptions;
+    dragNDropEnforced: boolean;
+    setTexture: EventEmitter<number | Texture>;
+    removeTexture: EventEmitter<void>;
+    imageHasBeenResized: boolean;
+    private _subs;
+    Options: typeof TextureEditorOptions;
+    texture: Texture;
+    mouseDown: boolean;
+    lastTouchPosition: THREE.Vector2;
+    editorWidth: number;
+    editorHeight: number;
+    editorMargin: number;
+    minZoom: number;
+    maxZoom: {
+        0: number;
+        1: number;
+        2: number;
+        3: number;
+    };
+    customPatternMultiplier: number;
+    zoomSliderMax: number;
+    editorRatio: number;
+    editorScale: number;
+    targetWidth: number;
+    targetHeight: number;
+    targetPosX: number;
+    targetPosY: number;
+    textureRotationDeg: number;
+    textureScale: number;
+    textureScaleSlider: number;
+    tileRotationDeg: number;
+    tileSizeMin: number;
+    tileSizeMax: number;
+    tileSize: number;
+    tileTextureRatio: number;
+    textureOffsetX: number;
+    textureOffsetY: number;
+    textureWidth: number;
+    textureHeight: number;
+    image: HTMLImageElement;
+    imgRatio: number;
+    targetRatio: number;
+    context: CanvasRenderingContext2D;
+    dampSetTexture: any;
+    tiled: boolean;
+    createDampener: (emitter: any) => {
+        emit: (value: any) => void;
+        release: () => void;
+    };
+    constructor(_settingsService: HomedecoratorSettingsService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    handleRemoveTextureClick(event: any): void;
+    private _loadTextureData;
+    setPhotoImage(dataUrl: string, resize?: boolean): Promise<void>;
+    private setTiled;
+    loadPhotoData(texture: Texture, resize?: boolean): Promise<void>;
+    private _setTextureImage;
+    private _loadCustomTextureData;
+    loadBasicTextureData(texture: Texture): Promise<void>;
+    loadPBRTextureData(texture: Texture): Promise<void>;
+    initializeTexture(): Promise<void>;
+    initializeTextureProps(texture: Texture): void;
+    initializeTargetProps(): void;
+    onMouseDown(): void;
+    onTouchStart(event: TouchEvent): void;
+    onMouseUp(): void;
+    onTouchEnd(): void;
+    onDragOver(event: DragEvent): void;
+    onDrop(event: DragEvent): Promise<void>;
+    isBasic(texture: Texture): boolean;
+    isPBR(texture: Texture): boolean;
+    isTile(texture: Texture): boolean;
+    getTextureOffset(): THREE.Vector2;
+    onPhotoDataChange({ data, fileName, resized }: {
+        data: string;
+        fileName: string;
+        resized: boolean;
+    }): Promise<void>;
+    onMouseMove(event: MouseEvent): void;
+    onTouchMove(event: TouchEvent): void;
+    offsetTexture(x: number, y: number): void;
+    onRotationChange(value: number): void;
+    onScaleChange(value: number): void;
+    onTileSizeChange(value: number): void;
+    onTileRotationChange(value: number): void;
+    tiledChanged(newTiled: boolean): Promise<void>;
+    drawPhotoImage(): void;
+    drawBasicTextureImage(): void;
+    drawCustomTextureImage(): void;
+    drawTextureImage(): void;
+    drawTargetOverlay(): void;
+    drawTileOverlay(): void;
+    redraw(background?: string): void;
+    resetTexture(): void;
+    clampNumber(number: number, min: number, max: number): number;
+    getCroppedCanvas(): string;
+    cropCanvas(sourceCanvas: any, left: any, top: any, width: any, height: any): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TextureEditorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TextureEditorComponent, "rp-texture-editor", never, { "width": "width"; "height": "height"; "texturePlane": "texturePlane"; "plainTexture": "plainTexture"; "changedTexture": "changedTexture"; "options": "options"; "dragNDropEnforced": "dragNDropEnforced"; }, { "setTexture": "setTexture"; "removeTexture": "removeTexture"; }, never, never>;
+}

package/app/plugins/room-planner/components/texture-editor/texture-editor.component.scss

@@ -0,0 +1,38 @@
+rp-texture-editor {
+  display: block;
+  width: 100%;
+}
+
+.picture-editor-footer {
+  margin-bottom: 16px;
+}
+.picture-editor-canvas {
+  margin-top: .75em;
+  margin-bottom: 1.5em;
+  text-align: center;
+}
+
+.canvas-wrapper {
+  position: relative;
+
+  mat-button-toggle-group {
+    text-align: center;
+    width: 320px;
+  }
+
+  mat-button-toggle {
+    flex-basis: 50%;
+    padding: 4px 0px;
+  }
+}
+
+.resize-message-wrapper {
+  margin: 10px 3px 3px;
+  text-align: -webkit-center;
+  .resize-message {
+    color: red;
+    font-style: italic;
+    font-weight: bold;
+    font-size: 0.9em;
+  }
+}

package/app/plugins/room-planner/components/texture-picker/texture-picker.component.d.ts

@@ -0,0 +1,25 @@
+import { EventEmitter, OnChanges, OnDestroy, SimpleChanges } from '@angular/core';
+import { Texture } from '../../../../core/model/texture';
+import { HomedecoratorAppService } from '../../../../core/service/homedecorator-app.service';
+import { HomedecoratorSettingsService } from '../../../../core/service/homedecorator-settings.service';
+import * as i0 from "@angular/core";
+export declare class TexturePickerComponent implements OnChanges, OnDestroy {
+    private _appService;
+    private _settingsService;
+    allowedTextureType: 'wall' | 'floor';
+    current: string;
+    textureSelected: EventEmitter<Texture>;
+    currentTexture: Texture;
+    textures: Texture[];
+    assetPath: string;
+    private _subs;
+    private set allTextures(value);
+    private get allTextures();
+    private _allTextures;
+    constructor(_appService: HomedecoratorAppService, _settingsService: HomedecoratorSettingsService);
+    ngOnDestroy(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private findCurrentTexture;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TexturePickerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TexturePickerComponent, "rp-texture-picker", never, { "allowedTextureType": "allowedTextureType"; "current": "current"; }, { "textureSelected": "textureSelected"; }, never, never>;
+}

package/app/plugins/room-planner/components/texture-picker/texture-picker.component.scss

@@ -0,0 +1,49 @@
+@use '~@angular/material' as mat;
+@import "../../../../../styles.scss";
+
+:host ::ng-deep .mat-grid-tile {
+  $border-width: 4px;
+
+  cursor: pointer;
+
+  &:after {
+    content: ' ';
+    border: $border-width solid transparent;
+    position: absolute;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+    box-sizing: border-box;
+    pointer-events: none;
+    transition: background-color 200ms ease-in;
+  }
+
+  &.is-selected:after {
+    border: 4px solid mat.get-color-from-palette($accent, A100);
+  }
+
+  .mat-grid-tile-footer {
+    background-color: rgba(mat.get-color-from-palette($primary, 500), 0.5) ;
+    padding: 0 8px;
+
+    span {
+      overflow: hidden;
+      padding-right: 4px;
+      text-overflow: ellipsis;
+    }
+
+    mat-icon {
+      border: 2px solid #fff;
+      border-radius: 50%;
+      font-size: 32px;
+      height: 32px;
+      width: 32px;
+
+      /* adjust vertical flex centering of the checkmark in tile footer */
+      /* should not jump as checkmark is only visible when tile is selected */
+      margin-bottom: $border-width;
+    }
+  }
+}
+

package/app/plugins/room-planner/components/wall-length-input/wall-length-input.component.d.ts

@@ -0,0 +1,16 @@
+import { OnDestroy, OnInit } from '@angular/core';
+import { MessageBusService } from '../../../../core/service/message-bus.service';
+import * as i0 from "@angular/core";
+export declare class WallLengthInputComponent implements OnInit, OnDestroy {
+    private _messageService;
+    length: number;
+    show: boolean;
+    private _sub;
+    constructor(_messageService: MessageBusService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    onOkButtonClick(): void;
+    onCancelButtonClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WallLengthInputComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<WallLengthInputComponent, "wall-length-input", never, {}, {}, never, never>;
+}

package/app/plugins/room-planner/components/wall-length-input/wall-length-input.component.scss

@@ -0,0 +1,5 @@
+:host {
+  position: absolute;
+  top: 80px;
+  left: 100px;
+}

package/app/plugins/room-planner/const/key.d.ts

@@ -0,0 +1,10 @@
+export declare enum Key {
+    Esc = 27,
+    Space = 32,
+    S = 83,
+    D = 68,
+    C = 67,
+    A = 65,
+    V = 86,
+    Delete = 46
+}

package/app/plugins/room-planner/room-planner/room-planner.component.d.ts

@@ -0,0 +1,236 @@
+import { ChangeDetectorRef, EventEmitter, OnDestroy, OnInit, TemplateRef } from '@angular/core';
+import { MatDialog } from '@angular/material/dialog';
+import { PluginInterface } from '../../plugin-interface';
+import { FloorplannerComponent } from '../components/floorplanner/floorplanner.component';
+import { IconEnum } from '../../../core/enum/icon.enum';
+import { IconName } from '../../../core/enum/icon-name.enum';
+import { ViewMode } from '../../../core/enum/view-mode.enum';
+import { ThreedModel } from '../../core3d/model/threed-model';
+import { Category } from '../../../core/model/category';
+import { Corner, HalfEdge, Room, Wall } from '../../core3d/items/wall-objects';
+import { Item } from '../../core3d/items/item';
+import { ItemGroup } from '../../core3d/items/item-group';
+import { HomedecoratorIconCacheService } from '../../../core/service/homedecorator-icon-cache.service';
+import { ViewModeService } from '../../../core/service/view-mode.service';
+import { ModelsService } from '../../core3d/service/models.service';
+import { PresetsService } from '../../../core/service/presets.service';
+import { HomedecoratorAppService } from '../../../core/service/homedecorator-app.service';
+import { ScreenSizeAnalysisService } from '../../../shared/screen-size-analysis/screen-size-analysis.service';
+import { UtilsService } from '../../../core/service/utils.service';
+import { MessageBusService } from '../../../core/service/message-bus.service';
+import { ConfigurationService } from '../../../core/service/configuration.service';
+import { FloorplanService } from '../components/floorplanner/service/floorplan.service';
+import { SceneService } from '../../core3d/service/scene.service';
+import { HudService } from '../../core3d/service/hud.service';
+import { RoomService } from '../components/floorplanner/service/room.service';
+import { CameraService } from '../../core3d/service/camera.service';
+import { ItemService } from '../../core3d/service/item.service';
+import { ItemSerializationService } from '../../../core/service/item-serialization.service';
+import { LightsService } from '../../core3d/service/lights.service';
+import { ArService } from '../../core3d/service/ar.service';
+import { HomedecoratorSettingsService } from '../../../core/service/homedecorator-settings.service';
+import { SelectedWallEvent } from '../../../core/interface/selected-wall-event.interface';
+import { SelectedFloorEvent } from '../../../core/interface/selected-floor-event.interface';
+import { Texture } from '../../../core/model/texture';
+import { ModelInterface } from '../../core3d/interface/model.interface';
+import { FloorPlaneItem } from '../../core3d/items/floor-plane-item';
+import { GoogleTagManagerService } from '../../../service/google-tag-manager.service';
+import { PermanentStoreService } from '../../../core/service/permanent-store.service';
+import { CustomButton } from '../../../core/model/custom-button';
+import { HomedecoratorAppEventService } from '../../../core/service/homedecorator-app-event.service';
+import { HomedecoratorConnectorService } from '../../../core/service/homedecorator-connector.service';
+import * as i0 from "@angular/core";
+export declare class RoomPlannerComponent implements OnInit, OnDestroy, PluginInterface {
+    iconService: HomedecoratorIconCacheService;
+    viewModeService: ViewModeService;
+    modelsService: ModelsService;
+    private _presetsService;
+    private _appService;
+    private _screenAnalysis;
+    private _cd;
+    private _utilsService;
+    private _messageService;
+    private _dialog;
+    private _configurationService;
+    private _floorplanService;
+    private _sceneService;
+    private _hudService;
+    private _roomService;
+    private _cameraService;
+    private _itemService;
+    private _itemSerializationService;
+    private _lightsService;
+    private _arService;
+    itemService: ItemService;
+    settingsService: HomedecoratorSettingsService;
+    private _googleTagManager;
+    private _permanentStoreService;
+    private _appEventService;
+    private _connectorService;
+    floorplanner: FloorplannerComponent;
+    toolbarIconLibrary: TemplateRef<any>;
+    toolbarIconAccessoires: TemplateRef<any>;
+    toolbarIconSettings: TemplateRef<any>;
+    toolbarIcon2dView: TemplateRef<any>;
+    toolbarIcon3dView: TemplateRef<any>;
+    categoriesSidebar: TemplateRef<any>;
+    accessoiresCategoriesSidebar: TemplateRef<any>;
+    customShapeCreatorSideBar: TemplateRef<any>;
+    customCylinderCreatorSideBar: TemplateRef<any>;
+    settingsSidebar: TemplateRef<any>;
+    librarySidebar: TemplateRef<any>;
+    selectedObjectSidebar: TemplateRef<any>;
+    selectedWallSidebar: TemplateRef<any>;
+    selectedThreedObjectSidebar: TemplateRef<any>;
+    selectedFloorSidebar: TemplateRef<any>;
+    toolbarIconFaq: TemplateRef<any>;
+    toolbarIconFeedback: TemplateRef<any>;
+    toolbarIconCart: TemplateRef<any>;
+    layerClass: string;
+    isLoading: boolean;
+    done: EventEmitter<any>;
+    showPlugin: EventEmitter<any>;
+    focusControls: EventEmitter<any>;
+    readonly icon: typeof IconEnum;
+    readonly iconName: typeof IconName;
+    readonly viewModes: typeof ViewMode;
+    objects: ThreedModel[];
+    customObjects: ThreedModel[];
+    libraryObjects: ThreedModel[];
+    categories: Category[];
+    accessoireCategories: Category[];
+    selectedCategory: Category;
+    showContextMenu: boolean;
+    selectedWall: Wall;
+    selectedEdge: string;
+    selectedFloor: FloorPlaneItem;
+    selectedRoom: Room;
+    selectedObject: Item | ItemGroup;
+    wallLengthInfoDialogEnabled: boolean;
+    maxWallHeight: number;
+    maxWallThickness: number;
+    maxWallLength: number;
+    minWallLength: number;
+    desktopSizeScreen: boolean;
+    tabletSizeScreen: boolean;
+    phoneSizeScreen: boolean;
+    contextMenuMouseEvent: MouseEvent;
+    showSettingsButton: boolean;
+    showConfigurationButton: boolean;
+    showDeleteButton: boolean;
+    showLockButton: boolean;
+    showARButton: boolean;
+    showCopyButton: boolean;
+    showGroupMenu: boolean;
+    showGroupEditMenuButtons: boolean;
+    showIcon: boolean;
+    userIsGrouping: boolean;
+    showConversionButton: boolean;
+    addSelectedClass: boolean;
+    salableObject: boolean;
+    private _subs;
+    private _activeCategorySidebarTemplate;
+    private _mode;
+    private _catalogIsShown;
+    private _blockLeftSideBar;
+    constructor(iconService: HomedecoratorIconCacheService, viewModeService: ViewModeService, modelsService: ModelsService, _presetsService: PresetsService, _appService: HomedecoratorAppService, _screenAnalysis: ScreenSizeAnalysisService, _cd: ChangeDetectorRef, _utilsService: UtilsService, _messageService: MessageBusService, _dialog: MatDialog, _configurationService: ConfigurationService, _floorplanService: FloorplanService, _sceneService: SceneService, _hudService: HudService, _roomService: RoomService, _cameraService: CameraService, _itemService: ItemService, _itemSerializationService: ItemSerializationService, _lightsService: LightsService, _arService: ArService, itemService: ItemService, settingsService: HomedecoratorSettingsService, _googleTagManager: GoogleTagManagerService, _permanentStoreService: PermanentStoreService, _appEventService: HomedecoratorAppEventService, _connectorService: HomedecoratorConnectorService);
+    handleDocKeyDown(event: KeyboardEvent): void;
+    get selectedEdges(): any[];
+    ngOnInit(): Promise<void>;
+    ngOnDestroy(): void;
+    private _initScreenSizeHandling;
+    private _viewModeChanged;
+    objectSelected(object: Item | ItemGroup): void;
+    showSelectedObjectSidebar(): void;
+    handleConfigurationButtonClick(btn: CustomButton): void;
+    objectUnselected(): void;
+    updateSelectedObjectHud(): void;
+    handleDeleteObject(): void;
+    removeSelectedObject(): void;
+    toggleLockSelectedObject(): void;
+    private _removeObject;
+    private _removeItem;
+    copySelectedObject(): Promise<void>;
+    private _copyItem;
+    zoomReset(): void;
+    get cantZoomOut(): boolean;
+    get cantZoomIn(): boolean;
+    zoomOut(): void;
+    zoomIn(): void;
+    unselectAll(): void;
+    updateMode(value: ViewMode, sendUpdates?: boolean): void;
+    showLibraryCategories(): void;
+    showAccessoireCategories(): void;
+    showActiveCategorySidebar(): void;
+    showLibraryCategory(category: Category): Promise<void>;
+    showSettings(): void;
+    openFaq(url: string): Window;
+    showFaq(): boolean;
+    openFeedback(url: string): void;
+    addAllToCart(): void;
+    showFeedback(): boolean;
+    selected(): void;
+    findEdgeWallPlacement(wall: any, edge: any): string;
+    selectWall(selectedWallEvent: SelectedWallEvent): void;
+    showSelectedWallSidebar(): void;
+    showSelectedThreedObjectSidebar(): void;
+    selectFloor(selectedFloorEvent: SelectedFloorEvent): void;
+    showSelectedFloorSidebar(): void;
+    setFloorTexture(texture: Texture): Promise<void>;
+    setFloorColor(color: number): void;
+    removeWall(wall: Wall): void;
+    setWallLength({ length, atEnd, edge }: {
+        length: number;
+        atEnd: boolean;
+        edge?: HalfEdge;
+    }): void;
+    showWallLengthInfoDialog(): void;
+    setWallHeight(height: number): void;
+    setWallThickness(thickness: number): void;
+    setWallTexture(texture: Texture): Promise<void>;
+    setWallColor(color: number): Promise<void>;
+    selectCorner(corner: Corner): void;
+    getMinWallHeight(wall: Wall): number;
+    getMinGlobalWallHeight(): number;
+    wallsHeightUpdated(height: number): void;
+    setDragged(object: ModelInterface): void;
+    releaseDragged(): void;
+    loadFloorPlan(data: any): Promise<void>;
+    startARSession(): void;
+    addToCart(object: any): Promise<void>;
+    loadItems(data: any): Promise<void>;
+    loadObjects({ items, floorplan }: {
+        items: any;
+        floorplan: any;
+    }): Promise<any>;
+    copySceneInstance(saveAs: boolean): Promise<void>;
+    getObjects(): {
+        floorplan: {
+            corners: {};
+            walls: any[];
+            wallTextures: any[];
+            floorTextures: {};
+            newFloorTextures: {};
+            newFloorColors: {};
+        };
+        items: {}[];
+    };
+    hasCustomObjects(): boolean;
+    onObjectLibraryClick(object: ModelInterface): void;
+    onGroupClick(): void;
+    cancelGroupSelection(): void;
+    onUnGroupClick(): void;
+    closeContextMenu(): void;
+    startGroupSelection(): void;
+    sendConversionToTagManager(): void;
+    private _hasSettings;
+    private _isConfigurable;
+    private _isConversionItem;
+    private _isDeletable;
+    private _isCopyable;
+    private _reattachToItemGroup;
+    private handleKeyDown;
+    private _textInputActive;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RoomPlannerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RoomPlannerComponent, "rp-room-planner", never, { "isLoading": "isLoading"; }, { "done": "done"; "showPlugin": "showPlugin"; "focusControls": "focusControls"; }, never, never>;
+}