@roomle/web-sdk 2.91.0-alpha.1 → 2.91.0-alpha.2

package/lib/definitions/packages/planner-core/src/services/planner-kernel-access.d.ts

@@ -0,0 +1,107 @@
+import type { KernelComponent, KernelEnum, RuntimeId, PlanObject as ConfiguratorPlanObject } from '../../../typings/kernel';
+import type PlanObjectViewModel from '../../../common-core/src/view-model/plan-object-view-model';
+import type { KernelObject, Plan, PlanElement, PlanInteractionHandler, PlanModelViewHelper, PlanObject } from '../../../typings/planner';
+import type { RapiConfiguration, RapiItem, RapiPlanSnapshotPostData } from '../../../typings/rapi-types';
+import type RoomlePlannerUiCallback from '../roomle-planner-ui-callback';
+import type PlanElementViewModel from '../../../common-core/src/view-model/plan-element-view-model';
+import type { Position3 } from '../../../common-core/src/common-interfaces';
+import ConfiguratorKernelAccess from '../../../common-core/src/configurator-kernel-access';
+import type { ExternalObjectGroup, ExternalObjectGroupAndModules, ExternalObjectGroupPosition } from '../external-object-api-callbacks';
+export interface PlannerKernelCallbackI {
+    handlerSwitchedPlans(fromPlan: Plan, toPlan: Plan): void;
+    planCompletelyLoaded(plan: Plan): void;
+    beginPlanConstruction(plan: Plan): void;
+    addMesh(planElement: PlanElement, material: any, vertices: Float32Array, indices: Int32Array, uvCoords: Float32Array, normals: Float32Array): void;
+    addPlanMesh(plan: Plan, material: any, vertices: Float32Array, indices: Int32Array, uvCoords: Float32Array, normals: Float32Array, type: KernelEnum): void;
+    endPlanConstruction(plan: Plan): void;
+    addPlanObjectToScene(planElementViewModel: PlanObjectViewModel): void;
+    removePlanObjectFromScene(planElementViewModel: PlanObjectViewModel): void;
+    planElementChanged(plan: Plan, planObject: PlanElementViewModel): void;
+    planElementRemoved(element: PlanElement): void;
+    planObjectConfigurationLoaded(plan: Plan, element: PlanElement, success: boolean): void;
+    planBoundsChanged(): void;
+    planHistoryStateChanged(): void;
+    planCleared(): void;
+    startedDrawing(): void;
+    stoppedDrawing(): void;
+    requestCatalogItem(catalogItemId: string): void;
+}
+export default class PlannerKernelAccess extends ConfiguratorKernelAccess {
+    private _kernelAccessCallback;
+    private _roomlePlannerUiCallback;
+    private _planInteractionHandler;
+    private _plannerKernelCallbackListener;
+    get kernelContainer(): any;
+    constructor(creator: string);
+    protected _loadSuccess(): void;
+    protected _loadError(): void;
+    private _createPlanInteractionHandler;
+    addPlannerListener(listener: PlannerKernelCallbackI): void;
+    removePlannerListener(listener: PlannerKernelCallbackI): void;
+    isReady(): void;
+    protected _setupKernel(): void;
+    get callbacks(): RoomlePlannerUiCallback;
+    get planInteractionHandler(): PlanInteractionHandler;
+    get planModelViewHelper(): PlanModelViewHelper;
+    catalogItemLoaded(catalogItem: RapiItem): void;
+    insertItems(itemList: Array<RapiItem | RapiConfiguration>): Promise<RuntimeId[]>;
+    duplicateItems(planObjects: PlanObject[]): PlanObject[];
+    private _rapiItemToKernelItem;
+    planObjectDeleted(): void;
+    requestPlanObjectDimensions(): void;
+    cleanUpCallbacks(): void;
+    registerCallbacks(): void;
+    planElementRemoved(element: PlanElement): void;
+    handlerSwitchedPlans(fromPlan: Plan, toPlan: Plan): void;
+    planBoundsChanged(): void;
+    planCleared(): void;
+    planCompletelyLoaded(plan: Plan): void;
+    planElement3dMeshChanged(plan: Plan, element: PlanElement): void;
+    private _onStaticItemAdded;
+    private _onConfigurableItemAdded;
+    private _onConfigurableConstructionItemAdded;
+    planElementAdded(plan: Plan, element: PlanElement): Promise<void>;
+    planElementChanged(plan: Plan, element: KernelObject): void;
+    planHistoryStateChanged(): void;
+    planObjectConfigurationCreated(_plan: Plan, _element: PlanObject): void;
+    externalObjectConfigurationChanged(plan: Plan, planObject: PlanObject, configuration: string): void;
+    externalObjectConfigurationLoaded(plan: Plan, planObject: PlanObject, configuration: string): void;
+    externalObjectConfigurationDeleted(plan: Plan, planObject: PlanObject, uniqueId: string): void;
+    externalObjectComponentDeleted(plan: Plan, planObject: PlanObject, remainingGroupOrGroups: ExternalObjectGroupAndModules | ExternalObjectGroupAndModules[], deletedRootModuleId: string): void;
+    externalObjectConfigurationDuplicated(plan: Plan, planObject: PlanObject, sourceGroupId: string, newGroupPosition: ExternalObjectGroupPosition): void;
+    externalObjectConfigurationMoved(plan: Plan, planObject: PlanObject, movedGroup: ExternalObjectGroup): void;
+    externalObjectConfigurationsMerged(plan: Plan, planObject: PlanObject, mergedGroup: ExternalObjectGroupAndModules, sourceGroupId: string): void;
+    externalObjectComponentSplitOff(plan: Plan, planObject: PlanObject, splitGroups: ExternalObjectGroupAndModules[]): void;
+    planObjectConfigurationLoaded(plan: Plan, element: PlanElement, success: boolean): Promise<void>;
+    requestCatalogItem(catalogItemId: string): void;
+    startedDrawing(): void;
+    stoppedDrawing(): void;
+    updateMesh2d(): void;
+    beginConstruction(): void;
+    addMesh(planElement: PlanElement, material: any, vertices: Float32Array, indices: Int32Array, uvCoords: Float32Array, normals: Float32Array): void;
+    endConstruction(): 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;
+    addPlanObjectFromItem(rapiElement: RapiItem | RapiConfiguration, position?: Position3, rotation?: number): Promise<RuntimeId>;
+    coupleReferences(jsObject: any, coreReference: KernelObject): void;
+    private _decoupleReferences;
+    isConstructionPlanElement(planElement: PlanElement): boolean;
+    planObjectSelectionChanged(configurationRuntimeId: number, elementRuntimeId: number): void;
+    protected _componentSelectionChanged(planObject: ConfiguratorPlanObject, component: KernelComponent, planComponentSelection: boolean): void;
+    protected _externalObjectParameterChanged(objectOrComponentId: number, parameterKey: string, value: string): void;
+    protected _externalObjectConfigurationChanged(objectId: number, configuration: string): void;
+    protected _externalObjectConfigurationLoaded(objectId: number, configuration: string): void;
+    protected _externalObjectConfigurationDeleted(groupId: string): void;
+    protected _externalObjectComponentDeleted(remainingGroupOrGroups: ExternalObjectGroupAndModules | ExternalObjectGroupAndModules[], deletedRootModuleId: string): void;
+    _externalObjectConfigurationDuplicated(sourceGroupId: string, newGroupPosition: ExternalObjectGroupPosition): void;
+    _externalObjectConfigurationsMoved(movedGroup: ExternalObjectGroup): void;
+    _externalObjectConfigurationsMerged(mergedGroup: ExternalObjectGroupAndModules, sourceGroupId: string): void;
+    _externalObjectComponentSplitOff(splitGroups: ExternalObjectGroupAndModules[]): void;
+    planSnapshotCreated(planSnapshot: RapiPlanSnapshotPostData): void;
+    requestDeleteComponents(componentIds: number[]): void;
+    requestDeleteComponent(componentId: number): void;
+    requestDeletePlanComponent(componentId: number): void;
+    private _externalPlanComponentDeleted;
+    dockExternalObjectComponent(parentId: number, parentDockId: number, childId: number, childDockId: number): void;
+}

package/lib/definitions/packages/planner-core/src/utils/global-definitions.d.ts

@@ -0,0 +1,13 @@
+import '../../../typings/global-definitions';
+import type RoomleGLBViewer from '../../../glb-viewer-core/src/roomle-glb-viewer';
+import type RoomleConfigurator from '../../../configurator-core/src/roomle-configurator';
+import type RoomlePlanner from '../roomle-planner';
+declare global {
+    interface Window {
+        RoomleCore: any;
+        ConfiguratorKernel: any;
+        RoomlePlanner: RoomlePlanner;
+        RoomleGLBViewer: RoomleGLBViewer;
+        RoomleConfigurator: RoomleConfigurator;
+    }
+}

package/lib/definitions/packages/planner-core/src/utils/injectables.d.ts

@@ -0,0 +1,2 @@
+import { DependencyInjectionAssignment } from '../../../common-core/src/di/container';
+export declare const INJECTABLES: DependencyInjectionAssignment[];

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

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

package/lib/definitions/packages/planner-core/src/utils/measurements.d.ts

@@ -0,0 +1,68 @@
+import type { Position2, Position3 } from '../../../common-core/src/common-interfaces';
+import type { ConstructionPlanObject, LeftOrRightWallSide, ObjectToWallLine, WallPlanObject } from '../../../typings/planner';
+import { Vector3 } from 'three';
+import type { EmsArray } from '../../../typings/ems';
+import type ConfigurableConstructionPlanObjectViewModel from '../../../common-core/src/view-model/configurable-construction-plan-object-view-model';
+import type ConstructionPlanObjectViewModel from '../view-model/construction-plan-object-view-model';
+import type { 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 DimensionDefinition<Vector2Type = Vector3 | Position2, Vector3Type = Vector3 | Position3> extends MeasurementBase<Vector2Type, Vector3Type> {
+    id: number;
+    lengthFormatted: string;
+    fromWithoutPadding?: Vector2Type;
+    toWithoutPadding?: Vector2Type;
+    isCurrentlyDrawn?: boolean;
+}
+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>) => ObjectToWallLine[];
+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/lib/definitions/packages/planner-core/src/utils/planner-scene-manager.d.ts

@@ -0,0 +1,7 @@
+import type PlanObjectViewModel from '../../../common-core/src/view-model/plan-object-view-model';
+import type { PlanObjectPosition } from '../../../typings/planner';
+import type { Camera } from 'three';
+import type PlanElementViewModel from '../../../common-core/src/view-model/plan-element-view-model';
+export declare const createTransferableObjectPosition: (planViewModel: PlanObjectViewModel | PlanElementViewModel, camera: Camera, clientWidth: number, clientHeight: number) => PlanObjectPosition;
+export type CallbackObjectType = 'static' | 'configuration' | 'wall' | 'measure' | 'door' | 'floor' | 'window' | 'unknown';
+export declare const getCallbackObjectType: (planElementViewModel: PlanElementViewModel) => CallbackObjectType;

package/lib/definitions/packages/planner-core/src/utils/planner-selection-handler.d.ts

@@ -0,0 +1,39 @@
+import EventDispatcher from '../../../configurator-core/src/utils/event-dispatcher';
+import type PlanElementViewModel from '../../../common-core/src/view-model/plan-element-view-model';
+import type { 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
+}
+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, isDragIn: boolean): 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/lib/definitions/packages/planner-core/src/view-model/ceiling-plan-element-view-model.d.ts

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

package/lib/definitions/packages/planner-core/src/view-model/construction-plan-object-view-model.d.ts

@@ -0,0 +1,19 @@
+import type { ConstructionPlanObject, PlanObject } from '../../../typings/planner';
+import StaticPlanObjectViewModel from './static-plan-object-view-model';
+import { type RoomleEventedMesh } from '../../../common-core/src/utils/threejs-utils';
+import { type Vector3 } from 'three';
+import type { Nullable } from '../../../typings/helper';
+import { type ConstructionMeasurements } from '../utils/measurements';
+import 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/lib/definitions/packages/planner-core/src/view-model/floor-plan-element-view-model.d.ts

@@ -0,0 +1,21 @@
+import type { PlanObject } from '../../../typings/planner';
+import PlanElementViewModel from '../../../common-core/src/view-model/plan-element-view-model';
+import type { Mesh } from 'three';
+import { Vector3 } from 'three';
+import type { Position2, Position3 } from '../../../common-core/src/common-interfaces';
+import type { Nullable } from '../../../typings/helper';
+export interface FloorAreaData<Vector2Type = Vector3, Vector3Type = Vector3> {
+    area: number;
+    formattedArea: Nullable<string>;
+    textPosition3d: Vector3Type;
+    textPosition2d: Vector2Type;
+    isTextVisible: boolean;
+}
+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/lib/definitions/packages/planner-core/src/view-model/measurement-line-plan-element-view-model.d.ts

@@ -0,0 +1,82 @@
+import type { PlanObject } from '../../../typings/planner';
+import PlanElementViewModel from '../../../common-core/src/view-model/plan-element-view-model';
+import { BufferGeometry, type Material, Mesh, Vector3 } from 'three';
+import type { DimensionDefinition } from '../utils/measurements';
+import type { Position2, Position3 } from '../../../common-core/src/common-interfaces';
+import type { RoomleEventedMesh } from '../../../common-core/src/utils/threejs-utils';
+import DraggableNode from '../webgl/draggable-node';
+import type { 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/lib/definitions/packages/planner-core/src/view-model/node-plan-element-view-model.d.ts

@@ -0,0 +1,19 @@
+import type { PlanObject } from '../../../typings/planner';
+import PlanElementViewModel from '../../../common-core/src/view-model/plan-element-view-model';
+import { Vector3 } from 'three';
+import type { 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/lib/definitions/packages/planner-core/src/view-model/plan-view-model.d.ts

@@ -0,0 +1,130 @@
+import type { Plan, PlanElement } from '../../../typings/planner';
+import type { PlannerKernelCallbackI } from '../services/planner-kernel-access';
+import type { RoomleComponent } from '../../../common-core/src/webgl/roomle-component-factory';
+import type PlannerSceneEventHandler from '../webgl/planner-scene-event-handler';
+import ConfiguratorPlanObjectViewModel from '../../../common-core/src/view-model/configurator-plan-object-view-model';
+import StaticPlanObjectViewModel from './static-plan-object-view-model';
+import ConfiguratorViewModel from '../../../common-core/src/view-model/configurator-view-model';
+import type { KernelEnum, KernelVector3 } from '../../../typings/kernel';
+import WallPlanElementViewModel from './wall-plan-element-view-model';
+import type PlanElementViewModel from '../../../common-core/src/view-model/plan-element-view-model';
+import FloorPlanElementViewModel from './floor-plan-element-view-model';
+import type MeshGenerator from '../../../common-core/src/webgl/mesh-generator';
+import { CAMERA_TYPE } from '../../../common-core/src/cameracontrol/camera-type';
+import NodePlanElementViewModel from './node-plan-element-view-model';
+import type { Enumify } from '../../../common-core/src/types';
+import type { Mesh } from 'three';
+import { Box3, Group } from 'three';
+import ConstructionPlanObjectViewModel from './construction-plan-object-view-model';
+import MeasurementLinePlanElementViewModel from './measurement-line-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 GROUP_MEASUREMENT_LINE = "Measurement Line";
+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 _floorPlanObjectViewModels;
+    private _nodePlanObjectViewModels;
+    private _constructionGroup;
+    private _ceilingGroup;
+    private _floorGroup;
+    private _measurementLineGroup;
+    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 _handleConfiguratorConstructionPlanObjectViewModel;
+    private _handleConstructionPlanObjectViewModel;
+    private _handleStaticPlanObjectViewModel;
+    private _handleMeasurementLinePlanElementViewModel;
+    private _handleWallPlanElementViewModel;
+    private _handleFloorPlanElementViewModel;
+    private _handleCeilingPlanElementViewModel;
+    private _handleNodePlanElementViewModel;
+    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;
+    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[];
+    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;
+    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;
+    hideAllExcept(planObjectId: number): void;
+    showAll(): void;
+    planHistoryStateChanged(): void;
+    setCameraType(cameraType: Enumify<typeof CAMERA_TYPE>): void;
+    get cameraType(): Enumify<typeof CAMERA_TYPE>;
+    setNodeZoom(zoom: number): void;
+    planCleared(): void;
+    requestCatalogItem(_catalogItemId: string): void;
+}

package/lib/definitions/packages/planner-core/src/view-model/static-plan-object-view-model.d.ts

@@ -0,0 +1,16 @@
+import type { PlanObject } from '../../../typings/planner';
+import PlanObjectViewModel from '../../../common-core/src/view-model/plan-object-view-model';
+import type { 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/lib/definitions/packages/planner-core/src/view-model/wall-plan-element-view-model.d.ts

@@ -0,0 +1,29 @@
+import type { KernelWall, PlanObject } from '../../../typings/planner';
+import PlanElementViewModel from '../../../common-core/src/view-model/plan-element-view-model';
+import type { Position2, Position3 } from '../../../common-core/src/common-interfaces';
+import { type RoomleEventedMesh } from '../../../common-core/src/utils/threejs-utils';
+import { Mesh, type MeshPhysicalMaterial, Vector3 } from 'three';
+import { type 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: () => MeshPhysicalMaterial;
+export default class WallPlanElementViewModel extends PlanElementViewModel {
+    constructor(planObject: PlanObject);
+    get isSelected(): boolean;
+    getWallDimension(zoomFactor: number, clientWidth: number, clientHeight: number): WallDimension;
+    addMesh(mesh: Mesh): void;
+    show(): void;
+    hide(): void;
+    private _enableTopView;
+    private _setTopMaterial;
+    private _disableTopView;
+    setTopView(enabled: boolean): void;
+    getKernelObject(): KernelWall;
+    private _setMaterial;
+    select(): void;
+    deselect(): void;
+    protected _updateBoundingBox(): void;
+    private _setBoundingBoxValues;
+    protected _generateBoundingBox(): RoomleEventedMesh;
+}

package/lib/definitions/packages/planner-core/src/webgl/construction-top-view.d.ts

@@ -0,0 +1,29 @@
+import { Object3D, MeshStandardMaterial } from 'three';
+import { type RapiItem } from '../../../typings/rapi-types';
+import { type 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/lib/definitions/packages/planner-core/src/webgl/continuous-drawing-helper.d.ts

@@ -0,0 +1,15 @@
+import type { ContinuousDrawingManager } from '../../../typings/planner';
+import type { 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;
+}