@roomle/embedding-lib 5.24.0 → 5.25.0-alpha.2

package/packages/web-sdk/packages/planner-core/src/utils/map-to-ui-plan-objects.d.ts

@@ -0,0 +1,5 @@
+import { UiPlanObject } from '../../../typings/kernel';
+import { default as PlannerKernelAccess } from '../services/planner-kernel-access';
+import { default as RapiAccess } from '../../../common-core/src/rapi-access';
+
+export declare const mapToUiPlanObjects: (planObjects: any, plannerKernelAccess: PlannerKernelAccess, rapiAccess: RapiAccess) => Promise<UiPlanObject[]>;

package/packages/web-sdk/packages/planner-core/src/utils/measurements.d.ts

@@ -0,0 +1,120 @@
+import { Position2, Position3 } from '../../../common-core/src/common-interfaces';
+import { ConstructionPlanObject, LeftOrRightWallSide, ObjectToWallLine, WallPlanObject } from '../../../typings/planner';
+import { Vector3 } from 'three';
+import { EmsArray } from '../../../typings/ems';
+import { default as ConfigurableConstructionPlanObjectViewModel } from '../../../common-core/src/view-model/configurable-construction-plan-object-view-model';
+import { default as ConstructionPlanObjectViewModel } from '../view-model/construction-plan-object-view-model';
+import { Nullable } from '../../../typings/helper';
+
+export type ConstructionMeasurement = MeasurementBase<Vector3, Vector3>;
+export type ConstructionMeasurementTransferable = MeasurementBase<Position2, Position3>;
+export interface ConstructionMeasurements {
+    leftMeasurement: ConstructionMeasurement;
+    rightMeasurement: ConstructionMeasurement;
+    elementRange: ConstructionMeasurement;
+}
+export interface ConstructionMeasurementsTransferable {
+    leftMeasurement: ConstructionMeasurementTransferable;
+    rightMeasurement: ConstructionMeasurementTransferable;
+    elementRange: ConstructionMeasurementTransferable;
+}
+export declare const toConstructionMeasurementTransferable: (constructionMeasurements: ConstructionMeasurement) => ConstructionMeasurementTransferable;
+export interface MeasurementBase<Vector2Type = Vector3 | Position2, Vector3Type = Vector3 | Position3> {
+    /**  start position of the dimension in 3D **/
+    fromPosition3d: Vector3Type;
+    /**  end position of the dimension in 3D **/
+    toPosition3d: Vector3Type;
+    /**  3D position where the length/label should be shown **/
+    textPosition3d: Vector3Type;
+    /**  3D direction vector of the text **/
+    textDirection: Vector3Type;
+    /**  rotation of the text in radians **/
+    textRotation: number;
+    /**  length of the wall in millimeters **/
+    length: number;
+    /**  start position of the dimension in 2D **/
+    fromPosition2d: Vector2Type;
+    /**  end position of the dimension in 2D **/
+    toPosition2d: Vector2Type;
+    /**  2D position where the length/label should be shown **/
+    textPosition2d: Vector2Type;
+}
+export interface AtticDimension<Vector2Type = Vector3 | Position2, Vector3Type = Vector3 | Position3> {
+    /** Start position of the attic in 3D **/
+    fromPosition3d?: Vector3Type;
+    /** End position of the attic in 3D **/
+    toPosition3d?: Vector3Type;
+    /** Center position of the attic in 3D **/
+    atticCenterPosition3d?: Vector3Type;
+    /** Wall center position in 3D, representing the reference point for attic placement **/
+    wallCenterPosition3d: Vector3Type;
+    /** Start position of the attic in 2D (screen coordinates) **/
+    fromPosition2d?: Vector2Type;
+    /** End position of the attic in 2D (screen coordinates) **/
+    toPosition2d?: Vector2Type;
+    /** Center position of the attic in 2D, used for screen rendering **/
+    atticCenterPosition2d?: Vector2Type;
+    /** Wall center position in 2D, serving as the reference for attic placement in screen space **/
+    wallCenterPosition2d: Vector2Type;
+    /** Position of the attic text label in 3D space **/
+    textPosition3d: Vector3Type;
+    /** Position of the attic text label in 2D screen space **/
+    textPosition2d: Vector2Type;
+    /** Rotation angle of the attic text label in degrees **/
+    textRotation: number;
+    /** Rotation angle from attic start to end positions **/
+    atticFromToRotation: number;
+    /** Position of the attic label "C" in 3D space **/
+    labelCPosition3d?: Vector3Type;
+    /** Position of the attic label "C" in 2D screen space **/
+    labelCPosition2d?: Vector2Type;
+    /** Position indicating the height label of the attic in 2D space **/
+    labelHeightPosition2d?: Vector2Type;
+    /** Position indicating the height label of the attic in 3D space **/
+    labelHeightPosition3d?: Vector3Type;
+    /** Shifted wall center in 3D space, used as base for 2m attic line drawing **/
+    shiftedWallCenter3d?: Vector3Type;
+    /** Attic midpoint at 2m height, shifted perpendicular to the attic direction **/
+    heightAt2mPosition3d?: Vector3Type;
+    /** Shifted wall center in 2D space, mapped from 3D for line rendering **/
+    shiftedWallCenter2d?: Vector2Type;
+    /** Attic midpoint at 2m height in 2D space **/
+    heightAt2mPosition2d?: Vector2Type;
+    /** Start corner of the attic at 2m height in 3D space **/
+    attic2mCornerFrom3d?: Vector3Type;
+    /** End corner of the attic at 2m height in 3D space **/
+    attic2mCornerto3d?: Vector3Type;
+    /** Start corner of the attic at 2m height in 2D space **/
+    attic2mCornerFrom2d?: Vector2Type;
+    /** End corner of the attic at 2m height in 2D space **/
+    attic2mCornerto2d?: Vector2Type;
+}
+export interface DimensionDefinition<Vector2Type = Vector3 | Position2, Vector3Type = Vector3 | Position3> extends MeasurementBase<Vector2Type, Vector3Type> {
+    id: number;
+    lengthFormatted: string;
+    fromWithoutPadding?: Vector2Type;
+    toWithoutPadding?: Vector2Type;
+    isCurrentlyDrawn?: boolean;
+    attic?: AtticDimension<Vector2Type, Vector3Type>;
+}
+export declare const transformMeasurement: (measurement: MeasurementBase<Vector3, Vector3>) => MeasurementBase<Position2, Position3>;
+export declare const calculateWallPlanPoints: (planObject: WallPlanObject | ConstructionPlanObject, preferredSide: LeftOrRightWallSide) => {
+    from: Vector3;
+    to: Vector3;
+    middle: Vector3;
+};
+export declare const getConstructionElemMiddlePoints: (planObject: ConstructionPlanObject) => {
+    centerFrom: Vector3;
+    centerTo: Vector3;
+};
+export declare const getTextDirectionAndRotation: (direction: Vector3) => {
+    textDirection: Vector3;
+    textRotation: number;
+};
+export declare const calculateShiftingFactor: (zoomFactor: number, clientWidth: number, clientHeight: number, basePaddingPx?: number) => number;
+export declare const convertToStandardArray: (emscriptenArray: EmsArray<ObjectToWallLine>) => any[];
+export declare const calculateConstructionElementMeasurements: (planViewModel: ConstructionPlanObjectViewModel | ConfigurableConstructionPlanObjectViewModel, zoomFactor: number, clientWidth: number, clientHeight: number) => Nullable<ConstructionMeasurements>;
+export declare const getWallCenterPoints: (planViewModel: ConstructionPlanObjectViewModel | ConfigurableConstructionPlanObjectViewModel, wallFromPoint: Vector3, leftCorner: Vector3, wallToPoint: Vector3, rightCorner: Vector3) => {
+    wallFromCenterPoint: Vector3;
+    wallToCenterPoint: Vector3;
+};

package/packages/web-sdk/packages/planner-core/src/utils/planner-scene-utils.d.ts

@@ -0,0 +1,11 @@
+import { default as PplanObjectViewModel } from '../../../common-core/src/view-model/plan-object-view-model';
+import { PlanObjectPosition } from '../../../typings/planner';
+import { Camera } from 'three';
+import { default as PlanElementViewModel } from '../../../common-core/src/view-model/plan-element-view-model';
+import { default as PlanViewModel } from '../view-model/plan-view-model';
+import { default as StaticPlanObjectViewModel } from '../view-model/static-plan-object-view-model';
+
+export declare const createTransferableObjectPosition: (planViewModel: PplanObjectViewModel | PlanElementViewModel, camera: Camera, clientWidth: number, clientHeight: number) => PlanObjectPosition;
+export type CallbackObjectType = 'static' | 'configuration' | 'wall' | 'measure' | 'attic' | 'door' | 'floor' | 'window' | 'unknown' | 'external-configuration';
+export declare const getCallbackObjectType: (planElementViewModel: PlanElementViewModel) => CallbackObjectType;
+export declare const addDemoLights: (planObjectViewModel: StaticPlanObjectViewModel, planViewModel: PlanViewModel, active: boolean) => void;

package/packages/web-sdk/packages/planner-core/src/utils/planner-selection-handler.d.ts

@@ -0,0 +1,41 @@
+import { default as EventDispatcher } from '../../../configurator-core/src/utils/event-dispatcher';
+import { default as PlanElementViewModel } from '../../../common-core/src/view-model/plan-element-view-model';
+import { CancelSelectionReasons } from '../../../typings/planner';
+import { SELECTION_MODE } from '../../../configurator-core/src/utils/selection-handler';
+
+export declare const enum SELECTION_EVENT {
+    SELECT_PLAN_ELEMENT = 0,
+    DESELECT_PLAN_ELEMENT = 1,
+    SELECT_PLAN_ELEMENT_MULTI = 2,
+    SELECTION_MODE_CHANGED = 3
+}
+export declare const isWallOrFloor: (planElementViewModel: PlanElementViewModel) => boolean;
+export declare class PlannerSelectionHandlerEvent {
+    planElementViewModel: PlanElementViewModel;
+    planElementViewModels: PlanElementViewModel[];
+    selectionMode: SELECTION_MODE;
+    reason: CancelSelectionReasons;
+    constructor(data: {
+        planElementViewModel?: PlanElementViewModel;
+        planElementViewModels?: PlanElementViewModel[];
+        selectionMode?: SELECTION_MODE;
+        reason?: CancelSelectionReasons;
+    });
+}
+export default class PlannerSelectionHandler extends EventDispatcher<PlannerSelectionHandlerEvent> {
+    private _selectionMode;
+    protected _selectedPlanElementViewModels: Map<number, PlanElementViewModel>;
+    check(planElementViewModel: PlanElementViewModel): void;
+    removeSelection(): void;
+    cancelSelection(reason: CancelSelectionReasons): void;
+    private _checkStandard;
+    private _checkMulti;
+    private _deselectWallAndFloorElements;
+    setSelectionMode(mode: SELECTION_MODE): void;
+    getSelectionMode(): SELECTION_MODE;
+    hasSelection(): boolean;
+    hasMultiSelection(): boolean;
+    getSelectedPlanElementViewModels(): PlanElementViewModel[];
+    getSelectedIds(): number[];
+    isSelected(id: number): boolean;
+}

package/packages/web-sdk/packages/planner-core/src/view-model/ceiling-plan-element-view-model.d.ts

@@ -0,0 +1,8 @@
+import { PlanObject } from '../../../typings/planner';
+import { default as PlanElementViewModel } from '../../../common-core/src/view-model/plan-element-view-model';
+import { Mesh } from 'three';
+
+export default class CeilingPlanElementViewModel extends PlanElementViewModel {
+    constructor(planObject: PlanObject);
+    addMesh(mesh: Mesh): void;
+}

package/packages/web-sdk/packages/planner-core/src/view-model/construction-plan-object-view-model.d.ts

@@ -0,0 +1,20 @@
+import { ConstructionPlanObject, PlanObject } from '../../../typings/planner';
+import { default as StaticPlanObjectViewModel } from './static-plan-object-view-model';
+import { RoomleEventedMesh } from '../../../common-core/src/utils/threejs-utils';
+import { Vector3 } from 'three';
+import { Nullable } from '../../../typings/helper';
+import { ConstructionMeasurements } from '../utils/measurements';
+import { default as ConstructionTopView } from '../webgl/construction-top-view';
+
+export default class ConstructionPlanObjectViewModel extends StaticPlanObjectViewModel {
+    private _constructionTopView;
+    constructor(planObject: PlanObject);
+    setTopView(enabled: boolean): Promise<void>;
+    getPlanElement(): ConstructionPlanObject;
+    protected _generateBoundingBox(): RoomleEventedMesh;
+    protected _updateBoundingBox(): void;
+    getTopViewContainer(): ConstructionTopView;
+    getConstructionElementMeasurements(zoomFactor: number, clientWidth: number, clientHeight: number): Nullable<ConstructionMeasurements>;
+    update(): void;
+    protected _setPositionOfBoundingBox(size: Vector3, mesh: RoomleEventedMesh): void;
+}

package/packages/web-sdk/packages/planner-core/src/view-model/floor-plan-element-view-model.d.ts

@@ -0,0 +1,22 @@
+import { PlanObject } from '../../../typings/planner';
+import { default as PlanElementViewModel } from '../../../common-core/src/view-model/plan-element-view-model';
+import { Mesh, Vector3 } from 'three';
+import { Position2, Position3 } from '../../../common-core/src/common-interfaces';
+import { Nullable } from '../../../typings/helper';
+
+export interface FloorAreaData<Vector2Type = Vector3, Vector3Type = Vector3> {
+    area: number;
+    formattedArea: Nullable<string>;
+    textPosition3d: Vector3Type;
+    textPosition2d: Vector2Type;
+    isTextVisible: boolean;
+    roomLabel?: string;
+}
+export type FloorAreaDataTransferable = FloorAreaData<Position2, Position3>;
+export declare const toFloorAreaDataTransferable: (floorAreaData: FloorAreaData) => FloorAreaDataTransferable;
+export default class FloorPlanElementViewModel extends PlanElementViewModel {
+    constructor(planObject: PlanObject);
+    addMesh(mesh: Mesh): void;
+    getFloorData(zoomFactor: number): FloorAreaData;
+    private calculateTextVisibility;
+}

package/packages/web-sdk/packages/planner-core/src/view-model/measurement-line-plan-element-view-model.d.ts

@@ -0,0 +1,83 @@
+import { PlanObject } from '../../../typings/planner';
+import { default as PlanElementViewModel } from '../../../common-core/src/view-model/plan-element-view-model';
+import { BufferGeometry, Material, Mesh, Vector3 } from 'three';
+import { DimensionDefinition } from '../utils/measurements';
+import { Position2, Position3 } from '../../../common-core/src/common-interfaces';
+import { RoomleEventedMesh } from '../../../common-core/src/utils/threejs-utils';
+import { default as DraggableNode } from '../webgl/draggable-node';
+import { ValuesFromObject } from '../../../common-core/src/utils/common-utils';
+
+export type MeasurementLineDimension = DimensionDefinition<Vector3, Vector3>;
+export type MeasurementLineDimensionTransferable = DimensionDefinition<Position2, Position3>;
+export declare const toMeasurementLineDimensionToTransferable: (measurementLineDimension: MeasurementLineDimension) => MeasurementLineDimensionTransferable;
+export declare const MEASUREMENT_LINE_CONFIG: {
+    lineColor: number;
+    boundingBoxPadding: number;
+    measurementLineBoxYPos: number;
+    defaultMaterial: {
+        color: string;
+        opacity: number;
+        transparent: boolean;
+    };
+};
+export declare const MEASUREMENTS_LINE_DRAGGABLE_POINTS_NAME: {
+    readonly POINT1: "point1";
+    readonly POINT2: "point2";
+};
+export type MeasurementLineDraggablePoints = ValuesFromObject<typeof MEASUREMENTS_LINE_DRAGGABLE_POINTS_NAME>;
+export default class MeasurementLinePlanElementViewModel extends PlanElementViewModel {
+    private _lineMesh;
+    private _subLine1;
+    private _subLine2;
+    private _point1Draggable;
+    private _point2Draggable;
+    private _point1BoundingBox;
+    private _point2BoundingBox;
+    currentPoint: string;
+    constructor(planObject: PlanObject);
+    private _initializeContainer;
+    private _initializeLines;
+    private _createDraggableNodeBoundBox;
+    private _initializeDraggables;
+    private _createLine;
+    getMeasurementLineDimension(): MeasurementLineDimension;
+    show(): void;
+    hide(): void;
+    hideAllSubLines(): void;
+    showAllSubLines(): void;
+    hideDraggableNodes(): void;
+    showDraggableNodes(): void;
+    showPoint1DraggableNode(): void;
+    showPoint2DraggableNode(): void;
+    hidePoint1DraggableNode(): void;
+    hidePoint2DraggableNode(): void;
+    setTopView(enabled: boolean): void;
+    update(): void;
+    protected _generateBoundingBox(): RoomleEventedMesh;
+    private _getGeometry;
+    private _getMainLinePoints;
+    private _calculateNormalVector;
+    private _updateSubLineGeometry;
+    private updatePointDraggableGeometry;
+    getPoint1Draggable(): DraggableNode;
+    getPoint2Draggable(): DraggableNode;
+    getPoint1DraggableBoundingBox(): Mesh<BufferGeometry<import('three').NormalBufferAttributes>, Material | Material[], import('three').Object3DEventMap>;
+    getPoint2DraggableBoundingBox(): Mesh<BufferGeometry<import('three').NormalBufferAttributes>, Material | Material[], import('three').Object3DEventMap>;
+    hidePreviewBox(): void;
+    selectPoint1Draggable(): void;
+    selectPoint2Draggable(): void;
+    deselectPoint1Draggable(): void;
+    deselectPoint2Draggable(): void;
+    selectAllDraggablePoints(): void;
+    deselectAllDraggablePoints(): void;
+    hoverOnDragPoint1(): void;
+    hoverOnDragPoint2(): void;
+    hoverOffDragPoint1(): void;
+    hoverOffDragPoint2(): void;
+    selectPointOnDragStart(planElementViewModel: MeasurementLinePlanElementViewModel): void;
+    hideDraggablePointsOnDragStart(planElementViewModel: MeasurementLinePlanElementViewModel, point: MeasurementLineDraggablePoints): void;
+    showDraggablePointsOnDragEnd(planElementViewModel: MeasurementLinePlanElementViewModel, point: MeasurementLineDraggablePoints): void;
+    handleDraggablePointsSelection(planElementViewModel: MeasurementLinePlanElementViewModel): void;
+    showDraggablePointsOnHoverOn(planElementViewModel: MeasurementLinePlanElementViewModel): void;
+    showDraggablePointsOnHoverOff(planElementViewModel: MeasurementLinePlanElementViewModel): void;
+}

package/packages/web-sdk/packages/planner-core/src/view-model/node-plan-element-view-model.d.ts

@@ -0,0 +1,20 @@
+import { PlanObject } from '../../../typings/planner';
+import { default as PlanElementViewModel } from '../../../common-core/src/view-model/plan-element-view-model';
+import { Vector3 } from 'three';
+import { RoomleEventedMesh } from '../../../common-core/src/utils/threejs-utils';
+
+export default class NodePlanElementViewModel extends PlanElementViewModel {
+    private _nodeUiMesh;
+    constructor(planObject: PlanObject);
+    update(): void;
+    setTopView(enabled: boolean): void;
+    getSize(): Vector3;
+    show(): void;
+    hide(): void;
+    select(): void;
+    deselect(): void;
+    hoverOn(): void;
+    hoverOff(): void;
+    protected _generateBoundingBox(): RoomleEventedMesh;
+    setZoom(zoom: number): void;
+}

package/packages/web-sdk/packages/planner-core/src/view-model/plan-view-model.d.ts

@@ -0,0 +1,174 @@
+import { Plan, PlanElement } from '../../../typings/planner';
+import { PlannerKernelCallbackI } from '../services/planner-kernel-access';
+import { RoomleComponent } from '../../../common-core/src/webgl/roomle-component-factory';
+import { default as PlannerSceneEventHandler } from '../webgl/planner-scene-event-handler';
+import { default as ConfiguratorPlanObjectViewModel } from '../../../common-core/src/view-model/configurator-plan-object-view-model';
+import { default as StaticPlanObjectViewModel } from './static-plan-object-view-model';
+import { default as ConfiguratorViewModel } from '../../../common-core/src/view-model/configurator-view-model';
+import { KernelEnum, KernelVector3 } from '../../../typings/kernel';
+import { default as WallPlanElementViewModel } from './wall-plan-element-view-model';
+import { default as PlanElementViewModel } from '../../../common-core/src/view-model/plan-element-view-model';
+import { default as FloorPlanElementViewModel } from './floor-plan-element-view-model';
+import { default as MeshGenerator } from '../../../common-core/src/webgl/mesh-generator';
+import { CAMERA_TYPE } from '../../../common-core/src/cameracontrol/camera-type';
+import { default as NodePlanElementViewModel } from './node-plan-element-view-model';
+import { Enumify } from '../../../common-core/src/types';
+import { Mesh, Box3, Group } from 'three';
+import { default as ConstructionPlanObjectViewModel } from './construction-plan-object-view-model';
+import { default as MeasurementLinePlanElementViewModel } from './measurement-line-plan-element-view-model';
+import { LightGroup } from '../lights/light-group';
+import { QualityLevel } from '../../../common-core/src/webgl/renderer/scene-renderer';
+import { default as LampLight } from '../lights/lamp-light';
+import { Point } from 'roomle-core-hsc/src/embind/configuratorCoreInterface';
+import { default as WallAtticPlanElementViewModel } from './wall-attic-plan-element-view-model';
+
+export declare const GROUP_CONSTRUCTION = "Construction";
+export declare const GROUP_CEILING = "Ceiling";
+export declare const GROUP_FLOOR = "Floor";
+export declare const MAX_LIGHTS = 1;
+export declare const GROUP_CEILING_LIGHTS = "Ceiling Lights";
+export declare const GROUP_MEASUREMENT_LINE = "Measurement Line";
+export declare const GROUP_WALL_ATTICS = "Wall Attics";
+export default class PlanViewModel extends ConfiguratorViewModel implements PlannerKernelCallbackI {
+    private _plannerMeshGenerator;
+    private _roomlePlannerUiCallback;
+    private _coreReference;
+    private _configurablePlanObjectViewModels;
+    private _configurableConstructionPlanObjectViewModels;
+    private _staticPlanObjectViewModels;
+    private _constructionPlanObjectViewModels;
+    private _wallPlanObjectViewModels;
+    private _measurementLinePlanObjectViewModels;
+    private _wallAtticsPlanObjectViewModels;
+    private _floorPlanObjectViewModels;
+    private _nodePlanObjectViewModels;
+    private _constructionGroup;
+    private _ceilingGroup;
+    private _floorGroup;
+    private _ceilingLightsGroup;
+    private _measurementLineGroup;
+    private _wallAtticsGroup;
+    private _plannerSceneEventHandler;
+    private _cameraType;
+    private _nodeZoom;
+    private _latestWallPlanObjectViewModel;
+    private _latestNodePlanObjectViewModel;
+    constructor(creator: string);
+    get latestWallPlanObjectViewModel(): WallPlanElementViewModel;
+    get latestNodePlanObjectViewModel(): NodePlanElementViewModel;
+    startedDrawing(): void;
+    stoppedDrawing(): void;
+    planBoundsChanged(): void;
+    setReference(plan: Plan): void;
+    clearReference(): void;
+    getCorePlan(): Plan;
+    addPlanElementViewModel(planElementViewModel: PlanElementViewModel): void;
+    private _handleConfiguratorPlanObjectViewModel;
+    private _linkPlanObjectViewModelAndComponent;
+    private _detachPlanObjectViewModelFromComponent;
+    private _handleConfiguratorConstructionPlanObjectViewModel;
+    private _handleConstructionPlanObjectViewModel;
+    private _handleStaticPlanObjectViewModel;
+    private _handleMeasurementLinePlanElementViewModel;
+    private _handleWallAtticPlanElementViewModel;
+    private _handleWallPlanElementViewModel;
+    private _handleFloorPlanElementViewModel;
+    private _handleCeilingPlanElementViewModel;
+    private _handleNodePlanElementViewModel;
+    private _getCeilingLightsDistribution;
+    handleInitialLights(_maxTextures: number, qualityLevel: QualityLevel): void;
+    handleCeilingLights(): void;
+    handleLampLight(lamp: StaticPlanObjectViewModel, options: {
+        targetPos: Point;
+        lightPos: Point;
+        color?: number;
+        decay?: number;
+        intensity?: number;
+        active?: boolean;
+    }): void;
+    handleRectLampLight(lamp: StaticPlanObjectViewModel, options: {
+        dimensions: {
+            width: number;
+            height: number;
+        };
+        lightPos: Point;
+        color?: number;
+        rotation?: Point;
+        active?: boolean;
+    }): void;
+    toggleCeilingLights(on: boolean, isInteriorLightsActive: boolean): void;
+    private commonHandlerForEditableAndTopView;
+    protected dockComponent(componentId: number, isRootComponent: boolean, parentId: number, componentPosition: KernelVector3, componentRotation: KernelVector3): void;
+    protected _addComponent(component: RoomleComponent): void;
+    private _getPlanObjectViewModelForRuntimeId;
+    getConfigurablePlanObjectForId(id: number): ConfiguratorPlanObjectViewModel;
+    getStaticPlanObjectForId(id: number): StaticPlanObjectViewModel;
+    getConstructionObjectForId(id: number): ConstructionPlanObjectViewModel;
+    getStaticPlanObjectViewModelForId(id: number): StaticPlanObjectViewModel;
+    getPlanObjectForId(id: number): PlanElementViewModel;
+    getPlanObjectViewModelsFromRapiId(): (StaticPlanObjectViewModel | ConfiguratorPlanObjectViewModel)[];
+    getPlanObjectCount(): number;
+    getConstructionGroup(): Group;
+    getCeilingGroup(): Group;
+    getFloorGroup(): Group;
+    getMeasurementLineGroup(): Group;
+    getCeilingLightsGroup(): LightGroup;
+    getLampLightsArray(): LampLight[];
+    getWallAtticsGroup(): Group;
+    getBoundingBox(): Box3;
+    getBoundingBoxOfGeometry(): Box3;
+    /**
+     * Merges geometries on the fly when creating them
+     *
+     * @param runtimeComponentId
+     * @param meshId
+     * @param materialId
+     * @param transform
+     * @param vertices
+     * @param indices
+     * @param uvCoords
+     * @param normals
+     * @private
+     */
+    setPlannerSceneEventHandler(plannerSceneEventHandler: PlannerSceneEventHandler): void;
+    getStaticPlanObjectViewModels(): StaticPlanObjectViewModel[];
+    getConfigurablePlanObjectViewModels(): ConfiguratorPlanObjectViewModel[];
+    getConfigurableConstructionPlanObjectViewModels(): ConfiguratorPlanObjectViewModel[];
+    getConstructionPlanObjectViewModels(): ConstructionPlanObjectViewModel[];
+    getWallPlanObjectViewModels(): WallPlanElementViewModel[];
+    getNodePlanObjectViewModels(): NodePlanElementViewModel[];
+    getFloorPlanObjectViewModels(): FloorPlanElementViewModel[];
+    getMeasurementLineObjectViewModels(): MeasurementLinePlanElementViewModel[];
+    getWallAtticsObjectViewModels(): WallAtticPlanElementViewModel[];
+    protected _generateMesh(runtimeComponentId: number, geometryId: string, material: any, vertices: Float32Array, indices: Int32Array, uvCoords: Float32Array, normals: Float32Array, type?: KernelEnum, newGeometryInstance?: boolean, materialAttributes?: Record<string, string>): Mesh;
+    protected _setMaterial(mesh: Mesh, material: any, _type?: KernelEnum, materialAttributes?: Record<string, string>): void;
+    Editor3dComponentCreated(id: number, position: KernelVector3, eulerAngles: KernelVector3, isRootComponent: boolean, parentObjectRuntimeId: number): void;
+    addPlanObjectToScene(_planViewModel: PlanElementViewModel): void;
+    handlerSwitchedPlans(_fromPlan: Plan, _toPlan: Plan): void;
+    planCompletelyLoaded(_plan: Plan): void;
+    beginPlanConstruction(_plan: Plan): void;
+    addPlanMesh(_plan: Plan, _material: any, _vertices: Float32Array, _indices: Int32Array, _uvCoords: Float32Array, _normals: Float32Array, _type: KernelEnum): void;
+    endPlanConstruction(_plan: Plan): void;
+    planElementChanged(_plan: Plan, _planObject: PlanElementViewModel): void;
+    planObjectConfigurationLoaded(_plan: Plan, planElement: PlanElement, success: boolean): void;
+    planObjectConfigurationChanged(_plan: Plan, _element: PlanElementViewModel): void;
+    addMesh(planElement: PlanElement, material: any, vertices: Float32Array, indices: Int32Array, uvCoords: Float32Array, normals: Float32Array): void;
+    removePlanObjectFromScene(planElementViewModel: PlanElementViewModel): void;
+    private _isConstructionType;
+    planElementRemoved(element: PlanElement): void;
+    private _removeObject;
+    protected getMeshGenerator(): MeshGenerator;
+    componentConfigurationUpdated(runtimeComponentId: number, geometryChanged: boolean): void;
+    getBoundingBoxFromRuntimeIds(runtimeIds: number[]): Box3;
+    hideAllExceptRuntimeIds(runtimeIds: number[]): void;
+    hideAllExcept(planObjectId: number): void;
+    showAll(): void;
+    planHistoryStateChanged(): void;
+    setNodeVisibility(visible: boolean): void;
+    setCameraType(cameraType: Enumify<typeof CAMERA_TYPE>): Promise<void>;
+    get cameraType(): Enumify<typeof CAMERA_TYPE>;
+    setNodeZoom(zoom: number): void;
+    planCleared(): void;
+    requestCatalogItem(_catalogItemId: string): void;
+    turnLightsOnOrOff(onOrOff: boolean): void;
+}

package/packages/web-sdk/packages/planner-core/src/view-model/static-plan-object-view-model.d.ts

@@ -0,0 +1,17 @@
+import { PlanObject } from '../../../typings/planner';
+import { default as PlanObjectViewModel } from '../../../common-core/src/view-model/plan-object-view-model';
+import { RapiItem } from '../../../typings/rapi-types';
+
+export default class StaticPlanObjectViewModel extends PlanObjectViewModel {
+    private _staticItemLoader;
+    private _glbUrl;
+    private _rapiItem;
+    private _originalSize;
+    constructor(planObject: PlanObject);
+    setRapiItem(rapiItem: RapiItem): Promise<void>;
+    private _addStaticItem;
+    getRapiItem(): RapiItem;
+    needsRapiItem(): boolean;
+    getGLBUrl(): string;
+    update(): void;
+}

package/packages/web-sdk/packages/planner-core/src/view-model/wall-attic-plan-element-view-model.d.ts

@@ -0,0 +1,10 @@
+import { Mesh } from 'three';
+import { KernelAttic, PlanObject } from '../../../typings/planner';
+import { default as PlanElementViewModel } from '../../../common-core/src/view-model/plan-element-view-model';
+
+export default class WallAtticPlanElementViewModel extends PlanElementViewModel {
+    constructor(planObject: PlanObject);
+    addMesh(mesh: Mesh): void;
+    getKernelAttic(): KernelAttic;
+    update(): void;
+}

package/packages/web-sdk/packages/planner-core/src/view-model/wall-plan-element-view-model.d.ts

@@ -0,0 +1,48 @@
+import { KernelWall, PlanObject } from '../../../typings/planner';
+import { default as PlanElementViewModel } from '../../../common-core/src/view-model/plan-element-view-model';
+import { Position2, Position3 } from '../../../common-core/src/common-interfaces';
+import { RoomleEventedMesh } from '../../../common-core/src/utils/threejs-utils';
+import { Mesh, MeshPhysicalMaterial, Vector3 } from 'three';
+import { DimensionDefinition } from '../utils/measurements';
+
+export type WallDimension = DimensionDefinition<Vector3, Vector3>;
+export type WallDimensionTransferable = DimensionDefinition<Position2, Position3>;
+export declare const wallDimensionToTransferable: (wallDimension: WallDimension) => WallDimensionTransferable;
+export declare const getTopViewMaterial: (hasAttic?: boolean) => MeshPhysicalMaterial;
+export default class WallPlanElementViewModel extends PlanElementViewModel {
+    private _lineForInvisibleWall?;
+    private _hasAttachedAttic;
+    private _visible;
+    constructor(planObject: PlanObject);
+    get isSelected(): boolean;
+    private _checkHasAttachedAttic;
+    getWallDimension(zoomFactor: number, clientWidth: number, clientHeight: number): WallDimension;
+    private calculateNormalVector;
+    private calculateShiftingFactor;
+    private calculateAtticInfo;
+    private calculateAtticTextRotation;
+    private calculateAtticFromToRotation;
+    addMesh(mesh: Mesh): void;
+    show(): void;
+    hide(): void;
+    setContainerVisibility(isVisible: boolean): void;
+    private _enableTopView;
+    private _setTopMaterial;
+    private _disableTopView;
+    setTopView(enabled: boolean): void;
+    getKernelObject(): KernelWall;
+    private _setMaterial;
+    select(): void;
+    deselect(): void;
+    protected _updateBoundingBox(): void;
+    private _setBoundingBoxValues;
+    isVisible(): boolean;
+    protected _generateBoundingBox(): RoomleEventedMesh;
+    private _computeLineVertices;
+    private _createLineForInvisibleWall;
+    private _updateLineGeometry;
+    private _addThinLineForInvisibleWall;
+    private _updateThinLine;
+    private _removeThinLineForInvisibleWall;
+    update(): void;
+}

package/packages/web-sdk/packages/planner-core/src/webgl/construction-top-view.d.ts

@@ -0,0 +1,30 @@
+import { Object3D, MeshStandardMaterial } from 'three';
+import { RapiItem } from '../../../typings/rapi-types';
+import { ConstructionPlanObject } from '../../../typings/planner';
+
+export declare const TOP_GREY_MESH_HEIGHT = 0.01;
+export declare const TOP_BLACK_MESH_HEIGHT = 0.02;
+export declare const TOP_BLACK_MESH_DEPTH = 0.03;
+export declare const MAX_ROOM_HEIGHT = 5;
+export declare const TOP_BLACK_MATERIAL: MeshStandardMaterial;
+export default class ConstructionTopView extends Object3D {
+    private _topGreyMesh;
+    private _topGreyMeshOutline;
+    private _topDoorMeshes;
+    private _topDoorOutlines;
+    private _topBlackMesh;
+    private _topSlidingBar1;
+    private _topSlidingBar2;
+    private _debugCircles;
+    private _planElement;
+    private _rapiItem;
+    constructor(planElement: ConstructionPlanObject, rapiItem?: RapiItem);
+    private _init;
+    setTopView(enabled: boolean): void;
+    private _createSlidingBars;
+    private _createDoorArchesOnUpdate;
+    _updateDoor(): void;
+    private _updateSlidingBars;
+    private _resetTopDoorMesh;
+    update(): void;
+}

package/packages/web-sdk/packages/planner-core/src/webgl/continuous-drawing-helper.d.ts

@@ -0,0 +1,16 @@
+import { ContinuousDrawingManager } from '../../../typings/planner';
+import { Group } from 'three';
+
+export default class ContinuousDrawingHelper {
+    private _drawingGroup;
+    private _continuousDrawingManager;
+    private _circleMesh;
+    private _kernelZoomFactor;
+    private _currentInnerRadius;
+    init(drawingGroup: Group, continuousDrawingManager: ContinuousDrawingManager, kernelZoomFactor: number): void;
+    update(): void;
+    private _initCircle;
+    private _updateCircle;
+    setKernelZoomFactor(kernelZoomFactor: number): void;
+    endDrawing(): void;
+}