@roomle/web-sdk 3.9.0 → 3.10.0-alpha.2

package/lib/roomle-headless.d.ts

@@ -5,7 +5,7 @@ import { Camera } from 'three';
 import { Color } from 'three';
 import { ColorRepresentation } from 'three';
 import { CommunicationInterfaceCallback } from '../../../workers/src/communication-interface';
-import { ConstructionObjectDoorArchArray } from 'roomle-core-hsc/src/embind/plannerCoreInterface';
+import { ConstructionObjectDoorArch } from 'roomle-core-hsc/src/embind/plannerCoreInterface';
 import { createExtObjId } from '../../../../../common/src/utils/external-objects';
 import { Enumify } from '../../../../../../common/src/utils/types';
 import { Enumify as Enumify_2 } from '../../../../../common/src/utils/types';
@@ -33,7 +33,9 @@ import { Object3D } from 'three';
 import { Object3DEventMap } from 'three';
 import { OrthographicCamera } from 'three';
 import { ParametersGroup } from 'three/examples/jsm/inspector/tabs/Parameters.js';
+import { PartList } from 'roomle-core-hsc/src/embind/configuratorCoreInterface';
 import { PerspectiveCamera } from 'three';
+import { PlanInteractionHandler as PlanInteractionHandler_2 } from 'roomle-core-hsc/src/embind/plannerCoreInterface';
 import { PointLight } from 'three';
 import { Scene } from 'three';
 import { Texture } from 'three';
@@ -1292,6 +1294,7 @@ export declare class ConfiguratorKernelAccess extends CommonKernelAccess {
     changeCommonComponentParameter(componentIds: number[], parameterKey: string, type: string, value: string, resolve: () => void, reject: () => void): void;
     changeComponentParameter(componentId: number, parameterKey: string, type: string, value: string, resolve: () => void, reject: () => void): void;
     changePlanObjectParameter(runtimeId: number, parameterKey: string, type: string, value: string, resolve: () => void, reject: () => void): void;
+    changePlanObjectsParameter(runtimeIds: number[], parameterKey: string, type: string, value: string, resolve: () => void, reject: () => void): void;
     protected _getAnimationLevelForObject(_runtimeId: number, animation: KernelAnimation | undefined): AnimationLevelType;
     updateAnimationParameters(elementId: number | number[], parameters: KernelParameter[]): void;
     changeAnimationValue(elementId: number, parameterKey: string, value: string, level: number, animationLevel: AnimationLevelType, animate: boolean): void;
@@ -1601,6 +1604,7 @@ export declare class ConfiguratorSceneManager extends SceneManager implements Co
     private _sceneEventHandler;
     private _isComponentDimensionsVisible;
     private _dimensionUpdateDebounced;
+    private _sceneSetupReady;
     constructor(creator: string, offset: CanvasOffset, mode: Enumify_2<typeof CAMERA_TYPE>);
     /**
      * Single point for deciding whether to push HTML label positions to the UI.
@@ -2174,6 +2178,11 @@ export declare abstract class ConstructionObject extends PlanObjectPtr {
 export declare class ConstructionObjectSet extends EmsSet<ConstructionObject> {
 }
 
+export declare interface ConstructionOverview {
+    objects: KernelPlanObjectList;
+    parts: PartList;
+}
+
 export declare interface ConstructionPlanObject extends PlanObject {
     getAttachedWall(): WallPlanObject;
     getPreferredSide(): LeftOrRightWallSide;
@@ -2181,7 +2190,7 @@ export declare interface ConstructionPlanObject extends PlanObject {
     getCornerFromRight(): KernelVector3;
     getCornerToLeft(): KernelVector3;
     getCornerToRight(): KernelVector3;
-    getDoorArches(): ConstructionObjectDoorArchArray;
+    getDoorArches(): EmsArray<ConstructionObjectDoorArch>;
 }
 
 export declare class ConstructionPlanObjectViewModel extends StaticPlanObjectViewModel {
@@ -2574,6 +2583,8 @@ export declare class DraggableNode extends Object3D {
     getSize(): Vector3;
     hoverOn(): void;
     hoverOff(): void;
+    setSphereColor(color: number): void;
+    setInnerRingColor(color: number): void;
     select(color: number): void;
     deselect(color: number): void;
 }
@@ -3110,6 +3121,8 @@ export declare interface ExternalObjectDockedRootModule {
     dockingVector: string;
     dockingVectorIndex: number;
     id: string;
+    mode: string;
+    offset: number[];
 }
 
 export declare interface ExternalObjectGroup {
@@ -3159,6 +3172,7 @@ export declare interface ExternalObjectGroupLayoutSide {
 export declare interface ExternalObjectLoadConfiguration {
     applyGlobalChildMode: boolean;
     correctArrangement: boolean;
+    applyGroupPosition: boolean;
     findFreeSpaceInPlan: boolean;
     isVisible: boolean;
     respondWithPositionInPlan: boolean;
@@ -3339,6 +3353,8 @@ export declare interface FetchOptions {
     embed?: RAPI_PATHS[];
 }
 
+export declare type FinalizeMode = 'immediate' | 'on-signal';
+
 export declare abstract class Floor extends PlanElement {
     area: number;
     material: FloorMaterial;
@@ -3359,6 +3375,12 @@ export declare interface FloorAreaData<Vector2Type = Vector3, Vector3Type = Vect
 
 export declare type FloorAreaDataTransferable = FloorAreaData<Position2, Position3>;
 
+export declare interface FloorCluster {
+    floors: Floor[];
+    area: number;
+    labelPosition: KernelVector3f;
+}
+
 export declare class FloorMaterial extends BaseMaterial {
     uvScale(): KernelVector3f;
     rotation(): KernelVector3f;
@@ -3628,6 +3650,140 @@ export declare interface GlueLogic {
     getMaterialUrl(materialId: string, groupOrModuleId?: string): string | null;
 }
 
+/**
+ * Hand-typed overrides of core handler methods, re-typed against our model types
+ * (PlanObject, KernelObject, …) which differ from core's. Everything not listed here
+ * is inherited from the real core type — see PlanInteractionHandler below.
+ */
+export declare interface HandWrittenPlanInteractionHandler {
+    /** embind cleanup — frees the underlying C++ instance. */
+    delete(): void;
+    init(reference: HandWrittenPlanInteractionHandler, zoomFactor: number, viewSnapDist: number, wallSnapMode: any, objectSnapMode: any, shouldSnap: boolean, drawingType: any): void;
+    getConfiguratorKernel(): ConfiguratorKernelClass;
+    loadPlanXML(xml: string): Plan_2;
+    createPlanWithObjectFromItem(object: KernelObject, position: KernelVector3, rotationInRad: number): Plan_2;
+    getPlan(): Plan_2;
+    moveElementTo(planObject: KernelObject, targetPosition: KernelVector3, dragging: boolean, cameraPosition?: KernelVector3): void;
+    moveElementToIn2d(planObject: KernelObject, targetPosition: KernelVector3, dragging: boolean): void;
+    moveElementBy(planObject: KernelObject, distance: KernelVector3, dragging: boolean): void;
+    duplicatePlanObject(object: PlanObject, count: number, findFreeSpaceInPlan: boolean): PlanObject[];
+    duplicatePlanObjects(objects: PlanObjectList, count: number, findFreeSpaceInPlan: boolean): PlanObject[];
+    setElementVisibility(element: PlanElement_2, isVisible: boolean): void;
+    moveObjectsBy(planObjects: KernelObjectPtrList, distance: KernelVector3): void;
+    rotateObjectTo(planObject: KernelObject, angleInRad: number): void;
+    setObjectRotation(planObject: KernelObject, angleInRad: number): void;
+    addPlanObjects(list: KernelObjectPtrList, findFreeSpaceInPlan: boolean): PlanObject[];
+    addPlanObjectFromItem(object: KernelObject, position: KernelVector3, type: number, findFreeSpaceInPlan: boolean): PlanObject;
+    addOrUpdateExternalPlanObjects(serializedConfiguration: string | string[], position: KernelVector3, rotationInRad: number, updateConfiguration: ExternalObjectLoadConfiguration, mergedGroupIds: string | string[]): PlanObject[];
+    createPreviewGeometryForAddOn(objectId: string, objectConfiguration: string, articleId: string, groupDefinitions: string, validContainerModules: ExternalValidContainerModule[]): void;
+    catalogItemLoaded(catalogItem: KernelCatalogItem): void;
+    removeElement(planObject: KernelObject): void;
+    removeObjectWithId(objectId: string): void;
+    mergeObjects(objects: PlanObjectList): void;
+    groupObjects(planObjectPtrList: PlanObjectList): ObjectGroupPtr;
+    rotateObjectsBy(planObjectPtrList: PlanObjectList, anAngleInRad: number, aroundPoint: KernelVector3): void;
+    rotateGroupBy(group: ObjectGroupPtr, anAngleInRad: number, aroundPoint: KernelVector3): void;
+    deactivateAllSnappingActivity(): void;
+    reactivateAllSnappingActivity(): void;
+    isUndoPossible(): boolean;
+    isRedoPossible(): boolean;
+    clearHistory(): void;
+    startInteraction(): void;
+    resumeInteraction(): void;
+    endInteraction(): void;
+    undo(): void;
+    redo(): void;
+    isVectorPreviewModeEnabled(): boolean;
+    getDrawingMode(): DrawingMode;
+    beginDrawing(point: {
+        x: number;
+        y: number;
+        z: number;
+    }, drawingMode: DrawingMode, createUnclosedSpace: boolean): void;
+    endDrawing(point: {
+        x: number;
+        y: number;
+        z: number;
+    }): void;
+    cancelDrawing(): void;
+    addNode(point: {
+        x: number;
+        y: number;
+        z: number;
+    }): PlanNode;
+    addWall(from: PlanNode, to: PlanNode): KernelWall;
+    setWallHeight(wall: KernelWall, height: number): void;
+    setLengthOfEdge2D(wall: KernelWall, length: number, preferredSide: WallSide, direction: EMSConstant, moveOrthogonalWalls: boolean): void;
+    setLengthOfSlopingEdge(wall: KernelWall, slopingLength: number, preferredSide: WallSide, direction: EMSConstant, moveOrthogonalWalls: boolean): void;
+    setWallThickness(wall: KernelWall, thickness: number): void;
+    addAttic(wall: KernelWall, kneeHeight: number, width: number, side: WallSide | null | undefined): KernelAttic;
+    setAtticSide(attic: KernelAttic, side: WallSide): void;
+    setAtticKneeHeight(attic: KernelAttic, kneeHeight: number): void;
+    setAtticWidth(attic: KernelAttic, width: number): void;
+    currentDrawingPosition(point: {
+        x: number;
+        y: number;
+        z: number;
+    }): void;
+    forceNode(point: {
+        x: number;
+        y: number;
+        z: number;
+    }): void;
+    setDrawingType(aNewDrawingType: DrawingType): void;
+    setZoomFactor(pxPerMM: number): void;
+    setViewSnapDist(aDist: number): void;
+    setRotationSnapAngle(angleInRadians: number): void;
+    setDefaultWallThickness(wallThickness: number, applyToAll: boolean): void;
+    setDefaultWallHeight(wallHeight: number, applyToAll: boolean): void;
+    setDefaultParapetHeight(parapetHeight: number, applyToAll: boolean): void;
+    setRoomParapetHeight(floor: KernelFloor, parapetHeight: number): void;
+    getDefaultExteriorWallMaterial(): KernelWallMaterial;
+    setDefaultExteriorWallMaterial(wallMaterial: KernelWallMaterial): void;
+    getDefaultInteriorWallMaterial(): KernelWallMaterial;
+    setDefaultInteriorWallMaterial(wallMaterial: KernelWallMaterial): void;
+    getDefaultFloorMaterial(): KernelFloorMaterial;
+    setDefaultFloorMaterial(floorMaterial: KernelFloorMaterial): void;
+    setElementCustomDataJson(element: PlanElement_2, customDataJson: string): void;
+    setWallLeftMaterial(wall: KernelWall, material: KernelWallMaterial): void;
+    setWallRightMaterial(wall: KernelWall, material: KernelWallMaterial): void;
+    setFloorMaterial(floor: KernelFloor, material: KernelFloorMaterial): void;
+    setFloorLabelObject(floor: KernelFloor, serializedLabelObject: string): void;
+    setFloorType(floor: KernelFloor, floorType: FloorType): void;
+    setEdgeType(wall: KernelWall, edgeType: EdgeType): void;
+    getContinuousDrawingManager(): ContinuousDrawingManager;
+    setSnapFeedbackWhileDrawing(enabled: boolean): void;
+    consistsOfMergedComponents(object: KernelObject): boolean;
+    setObjectSize(anObject: KernelObject, aNewSize: KernelVector3, anAnchor: Anchor): void;
+    setObjectFlipX(anObject: KernelObject, shouldFlipX: boolean): void;
+    setObjectFlipY(anObject: KernelObject, shouldFlipY: boolean): void;
+    setObjectCustomColor(object: PlanObject, rgbColor: number, useCustomColor: boolean): void;
+    setObjectCustomLabel(object: PlanObject, label: string): void;
+    setObjectFixedZ(anObject: KernelObject, shouldFlipZ: boolean): void;
+    setMeasurePoint1(measure: PlanMeasure_2, point: KernelVector3f, snapToWalls: boolean, snapToObjects: boolean): void;
+    setMeasurePoint2(measure: PlanMeasure_2, point: KernelVector3f, snapToWalls: boolean, snapToObjects: boolean): void;
+    addMeasure(startPosition: KernelVector3f, endPosition: KernelVector3f): PlanMeasure_2;
+    setDiscardExternalObjectsOnLoad(discard: boolean): void;
+    isChildObjectModePossible(object: KernelObject): boolean;
+    isEnabledChildObjectMode(object: KernelObject): boolean;
+    enableChildObjects(object: KernelObject, switchChildModeOffForAllOtherObjects: boolean): KernelObject;
+    disableChildObjects(object: KernelObject): KernelObject;
+    enableChildObjectsOfExternalObject(objectId: string, switchChildModeOffForAllOtherObjects: boolean): KernelObject;
+    disableChildObjectsOfExternalObject(objectId: string): KernelObject;
+    disableChildObjectsOfAllPlanObjects(): void;
+    setAutomatedWallHeight(wall: KernelWall, value: boolean): void;
+    unit: string;
+    enableRaster: boolean;
+    customRaster: number;
+    enableSnap: boolean;
+    enableDrawingSnap: boolean;
+    objectToWallSnapMode: SnapMode;
+    objectToObjectSnapMode: SnapMode;
+    dockWhenSnap: boolean;
+    unDockOnMove: boolean;
+    enableTerrain: boolean;
+}
+
 export declare class HdrEnvironmentLoader implements Context {
     _creator_: string;
     private _environmentMap;
@@ -3889,6 +4045,14 @@ export declare type HiAttributeOptionsResult = CheckDropDownResult | CheckDropDo
 
 export declare type HiContextAction = (typeof HI_CONTEXT_ACTION)[keyof typeof HI_CONTEXT_ACTION];
 
+/**
+ * Lifecycle methods internal to PlanInteractionManager — it drives them itself,
+ * external code must not. Single source for both the runtime guard (HIDDEN_LIFECYCLE)
+ * and the compile-time Omit in the PlanInteractionManager type. `satisfies` keeps
+ * every entry a real handler method.
+ */
+export declare const HIDDEN_INTERACTION_LIFECYCLE_METHODS: readonly ["startInteraction", "resumeInteraction", "endInteraction"];
+
 export declare interface HighlightHelper {
     init(object: Object3D, camera: PerspectiveCamera): void;
     setCamera(camera: PerspectiveCamera): void;
@@ -4305,6 +4469,8 @@ export declare class IntArray extends EmsArray<number> {
 export declare class IntArray_2 extends EmsArray<number> {
 }
 
+export declare type InteractionMethodName = Exclude<keyof PlanInteractionManager, keyof UndoRedoHandler>;
+
 export declare interface InteractionOptions {
     keepInteractionOpen?: boolean;
 }
@@ -4318,6 +4484,8 @@ export declare const isExternalObject: (someThing: unknown) => someThing is Exte
 
 export declare const isExtObjId: (id: unknown) => id is ExtObjId_2;
 
+export declare const isFirefox: () => boolean;
+
 export declare const isSafari: () => boolean;
 
 export declare const KERNEL_MESSAGE_TYPE: {
@@ -4632,7 +4800,7 @@ export declare interface KernelParameter {
     viewType: KernelViewType;
     source: 'external' | 'internal';
     level?: number;
-    objectIds: number[];
+    objectIds?: number[];
 }
 
 export declare interface KernelParameterGroup {
@@ -5276,19 +5444,23 @@ export declare interface NodeDimensionTransferable {
 }
 
 export declare class NodePlanElementViewModel extends PlanElementViewModel {
-    private _nodeUiMesh;
+    protected _nodeUiMesh: DraggableNode;
+    protected _defaultRingColor: number;
     constructor(planObject: PlanObject);
     update(): void;
     setTopView(enabled: boolean): void;
     getSize(): Vector3;
     show(): void;
     hide(): void;
+    protected getSelectionRingColor(): number;
     select(): void;
     deselect(): void;
     hoverOn(): void;
     hoverOff(): void;
     protected _generateBoundingBox(): RoomleEventedMesh;
     setZoom(zoom: number): void;
+    setFillColor(color: number): void;
+    setDefaultRingColor(color: number): void;
 }
 
 export declare interface NodePlanObject extends PlanObject {
@@ -5627,133 +5799,33 @@ export declare abstract class PlanImage extends PlanElement {
     center: KernelVector3f;
 }
 
-export declare interface PlanInteractionHandler {
-    init(reference: PlanInteractionHandler, zoomFactor: number, viewSnapDist: number, wallSnapMode: any, objectSnapMode: any, shouldSnap: boolean, drawingType: any): PlanInteractionHandler;
-    getConfiguratorKernel(): ConfiguratorKernelClass;
-    loadPlanXML(xml: string): Plan_2;
-    createPlanWithObjectFromItem(object: KernelObject, position: KernelVector3, rotationInRad: number): Plan_2;
-    getPlan(): Plan_2;
-    moveElementTo(planObject: KernelObject, targetPosition: KernelVector3, dragging: boolean, cameraPosition?: KernelVector3): void;
-    moveElementToIn2d(planObject: KernelObject, targetPosition: KernelVector3, dragging: boolean): void;
-    moveElementBy(planObject: KernelObject, distance: KernelVector3, dragging: boolean): void;
-    duplicatePlanObject(object: PlanObject, count: number, findFreeSpaceInPlan: boolean): PlanObject[];
-    duplicatePlanObjects(objects: PlanObjectList, count: number, findFreeSpaceInPlan: boolean): PlanObject[];
-    setElementVisibility(element: PlanElement_2, isVisible: boolean): void;
-    moveObjectsBy(planObjects: KernelObjectPtrList, distance: KernelVector3): void;
-    rotateObjectTo(planObject: KernelObject, angleInRad: number): void;
-    setObjectRotation(planObject: KernelObject, angleInRad: number): void;
-    addPlanObjects(list: KernelObjectPtrList, findFreeSpaceInPlan: boolean): PlanObject[];
-    addPlanObjectFromItem(object: KernelObject, position: KernelVector3, type: number, findFreeSpaceInPlan: boolean): PlanObject;
-    addOrUpdateExternalPlanObjects(serialzedConfiguration: string | string[], position: KernelVector3, rotationInRad: number, updateConfiguration: ExternalObjectLoadConfiguration, mergedGroupIds: string | string[]): PlanObject[];
-    createPreviewGeometryForAddOn(objectId: string, objectConfiguration: string, articleId: string, groupDefinitions: string, validContainerModules: ExternalValidContainerModule[]): void;
-    catalogItemLoaded(catalogItem: KernelCatalogItem): void;
-    removeElement(planObject: KernelObject): void;
-    removeObjectWithId(objectId: string): void;
-    mergeObjects(objects: PlanObjectList): void;
-    groupObjects(planObjectPtrList: PlanObjectList): ObjectGroupPtr;
-    rotateObjectsBy(planObjectPtrList: PlanObjectList, anAngleInRad: number, aroundPoint: KernelVector3): void;
-    rotateGroupBy(group: ObjectGroupPtr, anAngleInRad: number, aroundPoint: KernelVector3): void;
-    deactivateAllSnappingActivity(): void;
-    reactivateAllSnappingActivity(): void;
-    isUndoPossible(): boolean;
-    isRedoPossible(): boolean;
-    clearHistory(): void;
-    startInteraction(): void;
-    resumeInteraction(): void;
-    endInteraction(): void;
-    undo(): void;
-    redo(): void;
-    isVectorPreviewModeEnabled(): boolean;
-    getDrawingMode(): DrawingMode;
-    sCreateUnclosedSpaceEnabled(): boolean;
-    beginDrawing(point: {
-        x: number;
-        y: number;
-        z: number;
-    }, drawingMode: DrawingMode, createUnclosedSpace: boolean): void;
-    endDrawing(point: {
-        x: number;
-        y: number;
-        z: number;
-    }): void;
-    cancelDrawing(): void;
-    addNode(point: {
-        x: number;
-        y: number;
-        z: number;
-    }): PlanNode;
-    addWall(from: PlanNode, to: PlanNode): KernelWall;
-    setWallHeight(wall: KernelWall, height: number): void;
-    setLengthOfEdge2D(wall: KernelWall, length: number, preferredSide: WallSide, direction: EMSConstant, moveOrthogonalWalls: boolean): void;
-    setLengthOfSlopingEdge(wall: KernelWall, slopingLength: number, preferredSide: WallSide, direction: EMSConstant, moveOrthogonalWalls: boolean): void;
-    setWallThickness(wall: KernelWall, thickness: number): void;
-    addAttic(wall: KernelWall, kneeHeight: number, width: number, side: WallSide | null | undefined): KernelAttic;
-    setAtticSide(attic: KernelAttic, side: WallSide): void;
-    setAtticKneeHeight(attic: KernelAttic, kneeHeight: number): void;
-    setAtticWidth(attic: KernelAttic, width: number): void;
-    currentDrawingPosition(point: {
-        x: number;
-        y: number;
-        z: number;
-    }): void;
-    forceNode(point: {
-        x: number;
-        y: number;
-        z: number;
-    }): void;
-    setDrawingType(aNewDrawingType: DrawingType): void;
-    setZoomFactor(pxPerMM: number): void;
-    setViewSnapDist(aDist: number): void;
-    setRotationSnapAngle(angleInRadians: number): void;
-    setDefaultWallThickness(wallThickness: number, applyToAll: boolean): void;
-    setDefaultWallHeight(wallHeight: number, applyToAll: boolean): void;
-    setDefaultParapetHeight(parapetHeight: number, applyToAll: boolean): void;
-    setRoomParapetHeight(floor: KernelFloor, parapetHeight: number): void;
-    getDefaultExteriorWallMaterial(): KernelWallMaterial;
-    setDefaultExteriorWallMaterial(wallMaterial: KernelWallMaterial): void;
-    getDefaultInteriorWallMaterial(): KernelWallMaterial;
-    setDefaultInteriorWallMaterial(wallMaterial: KernelWallMaterial): void;
-    getDefaultFloorMaterial(): KernelFloorMaterial;
-    setDefaultFloorMaterial(floorMaterial: KernelFloorMaterial): void;
-    setElementCustomDataJson(element: PlanElement_2, customDataJson: string): void;
-    setWallLeftMaterial(wall: KernelWall, material: KernelWallMaterial): void;
-    setWallRightMaterial(wall: KernelWall, material: KernelWallMaterial): void;
-    setFloorMaterial(floor: KernelFloor, material: KernelFloorMaterial): void;
-    setFloorLabelObject(floor: KernelFloor, serializedLabelObject: string): void;
-    setFloorType(floor: KernelFloor, floorType: FloorType): void;
-    setEdgeType(wall: KernelWall, edgeType: EdgeType): void;
-    getContinuousDrawingManager(): ContinuousDrawingManager;
-    setSnapFeedbackWhileDrawing(enabled: boolean): void;
-    consistsOfMergedComponents(object: KernelObject): boolean;
-    setObjectSize(anObject: KernelObject, aNewSize: KernelVector3, anAnchor: Anchor): void;
-    setObjectFlipX(anObject: KernelObject, shouldFlipX: boolean): void;
-    setObjectFlipY(anObject: KernelObject, shouldFlipY: boolean): void;
-    setObjectCustomColor(object: PlanObject, rgbColor: number, useCustomColor: boolean): void;
-    setObjectCustomLabel(object: PlanObject, label: string): void;
-    setObjectFixedZ(anObject: KernelObject, shouldFlipZ: boolean): void;
-    setMeasurePoint1(measure: PlanMeasure_2, point: KernelVector3f, snapToWalls: boolean, snapToObjects: boolean): void;
-    setMeasurePoint2(measure: PlanMeasure_2, point: KernelVector3f, snapToWalls: boolean, snapToObjects: boolean): void;
-    addMeasure(startPosition: KernelVector3f, endPosition: KernelVector3f): PlanMeasure_2;
-    setDiscardExternalObjectsOnLoad(discard: boolean): void;
-    isChildObjectModePossible(object: KernelObject): boolean;
-    isEnabledChildObjectMode(object: KernelObject): boolean;
-    enableChildObjects(object: KernelObject, switchChildModeOffForAllOtherObjects: boolean): KernelObject;
-    disableChildObjects(object: KernelObject): KernelObject;
-    enableChildObjectsOfExternalObject(objectId: string, switchChildModeOffForAllOtherObjects: boolean): KernelObject;
-    disableChildObjectsOfExternalObject(objectId: string): KernelObject;
-    disableChildObjectsOfAllPlanObjects(): void;
-    unit: string;
-    enableRaster: boolean;
-    customRaster: number;
-    enableSnap: boolean;
-    enableDrawingSnap: boolean;
-    objectToWallSnapMode: SnapMode;
-    objectToObjectSnapMode: SnapMode;
-    dockWhenSnap: boolean;
-    unDockOnMove: boolean;
-    enableTerrain: boolean;
+export declare type PlanInteractionHandler = Omit<PlanInteractionHandler_2, keyof HandWrittenPlanInteractionHandler> & HandWrittenPlanInteractionHandler;
+
+export declare class PlanInteractionHandlerExtension extends UndoRedoHandler {
+    addOrUpdateExternalPlanObjects(serializedConfiguration: string | string[], position: KernelVector3, rotationInRad: number, updateConfiguration: any, mergedGroupIds: string | string[]): PlanObject[];
+    applyKernelParameterChange<T>(callback: () => T, parameterKey: string, elementId?: string | number): T;
+    /**
+     * Track a construction element position adjustment from bubble/dimension editing.
+     * Creates an immediate undo/redo step. Used when users edit dimension bubbles
+     * attached to construction elements (doors, windows, etc.) in walls.
+     */
+    adjustConstructionElementPosition(element: KernelObject, offset: any): void;
+    /**
+     * Track an object position adjustment from bubble/dimension editing on the floor.
+     * Creates an immediate undo/redo step. Used when users edit dimension bubbles
+     * for floor objects.
+     */
+    adjustObjectPosition(element: KernelObject, offset: any): void;
+    /**
+     * Track an object-to-wall distance adjustment from bubble/dimension editing.
+     * Creates an immediate undo/redo step. Used when users edit object-to-wall
+     * dimension bubbles on the floor.
+     */
+    adjustObjectToWallDistance(element: KernelObject, position: any, dragging: boolean): void;
 }
 
+export declare type PlanInteractionManager = Omit<Omit<PlanInteractionHandler, keyof PlanInteractionHandlerExtension> & PlanInteractionHandlerExtension, (typeof HIDDEN_INTERACTION_LIFECYCLE_METHODS)[number]>;
+
 export declare abstract class PlanMeasure extends PlanElement {
     getPoint1(): KernelVector3f;
     getPoint2(): KernelVector3f;
@@ -5770,6 +5842,7 @@ export declare abstract class PlanModelViewHelper {
     static requestWallMesh2d(aWall: Wall): void;
     static requestFloorMesh2d(aFloor: Floor): void;
     static getCeilingHeight(aFloor: Floor): number;
+    static getFloorClusters(plan: Plan): FloorCluster[];
     static getMaxDistToBorderForPlanObject(aPlanObject: PlanObjectPtr): number;
     static getDistToNextWallOnSide(anObject: PlanObjectPtr, aSide: PlanObjectSide, maxDist: number): number;
     static getDistAlongWallOnSide(anObject: ConstructionObject, aSide: PlanObjectSide, aWallSide: WallSide): number;
@@ -5777,7 +5850,8 @@ export declare abstract class PlanModelViewHelper {
 }
 
 export declare interface PlanModelViewHelper_2 {
-    getPlanOverview(planObject: KernelObject): PlanOverview;
+    getPlanOverview(plan: Plan_2): PlanOverview;
+    getConstructionOverview(plan: Plan_2): ConstructionOverview;
     getPlanObject(plan: Plan_2, aRuntimeId: number): KernelPlanObject;
     isChildObjectRootComponent(plan: Plan_2, componentRuntimeId: number): boolean;
     isAnimationRootComponent(plan: Plan_2, componentRuntimeId: number): boolean;
@@ -5905,7 +5979,12 @@ export declare interface PlannerInitData {
 
 export declare class PlannerKernelAccess extends ConfiguratorKernelAccess {
     private _roomlePlannerUiCallback;
-    private _planInteractionHandler;
+    /**
+     * Stores the PlanInteractionManager — NOT typed as PlanInteractionHandler.
+     * This is a manager that composes and enhances the kernel handler with
+     * smart action grouping, NOT a 1:1 implementation of the handler interface.
+     */
+    private _planInteractionManager;
     private _plannerKernelCallbackListener;
     private _plannerReadyListeners;
     private _plannerReady;
@@ -5919,19 +5998,25 @@ export declare class PlannerKernelAccess extends ConfiguratorKernelAccess {
     get homagIntelligence(): HomagIntelligence | null;
     setHomagIntelligence(homagIntelligence: HomagIntelligence | null): void;
     get isDockingInPlannerEnabled(): boolean;
+    /**
+     * Returns the PlanInteractionManager — a composition-based wrapper that adds
+     * smart action grouping to kernel interactions. NOT a strict implementation
+     * of PlanInteractionHandler, but compatible with it for backward compatibility.
+     */
+    get planInteractionManager(): PlanInteractionManager;
     private _createPlanInteractionHandler;
     addPlannerListener(listener: PlannerKernelCallbackI): void;
     removePlannerListener(listener: PlannerKernelCallbackI): void;
     isReady(): void;
     protected _setupKernel(): void;
     get callbacks(): RoomlePlannerUiCallback;
-    get planInteractionHandler(): PlanInteractionHandler;
     get planModelViewHelper(): PlanModelViewHelper_2;
     protected _validateParameters(parameters: KernelParameter[], getVerifiedOptions: (keys: string[]) => Promise<Record<string, CheckDropDownResult> | undefined>, errorMessage: string): Promise<KernelParameter[]>;
     protected _validateExternalComponentParameters(componentId: number, parameters: KernelParameter[]): Promise<KernelParameter[]>;
     protected _validateExternalPlanObjectParameters(objectId: number, parameters: KernelParameter[]): Promise<KernelParameter[]>;
     catalogItemLoaded(catalogItem: RapiItem): void;
     insertItems(itemList: Array<RapiItem | RapiConfiguration>, newUndoRedoStep?: boolean): Promise<RuntimeId[]>;
+    private _performInsertItems;
     duplicateItems(planObjects: PlanObject[]): PlanObject[];
     mergeItems(planObjects: PlanObject[]): void;
     private _rapiItemToKernelItem;
@@ -5978,7 +6063,8 @@ export declare class PlannerKernelAccess extends ConfiguratorKernelAccess {
     addPlanMesh(plan: Plan_2, material: any, vertices: Float32Array, indices: Int32Array, uvCoords: Float32Array, normals: Float32Array, type: KernelEnum): void;
     endPlanConstruction(plan: Plan_2): void;
     createPlanFromObject(rapiElement: RapiItem | RapiConfiguration, position?: Position3, rotation?: number): Plan_2;
-    addPlanObjectFromItem(rapiElement: RapiItem | RapiConfiguration, newUndoRedoStep: boolean, position?: Position3, rotation?: number): Promise<RuntimeId>;
+    addPlanObjectFromItem(rapiElement: RapiItem | RapiConfiguration, newUndoRedoStep: boolean, position?: Position3, rotation?: number, keepInteractionOpen?: boolean): Promise<RuntimeId>;
+    private _performAddPlanObjectFromItem;
     coupleReferences(jsObject: any, coreReference: KernelObject): void;
     private _decoupleReferences;
     isConstructionPlanElement(planElement: PlanElement_2): boolean;
@@ -6005,6 +6091,9 @@ export declare class PlannerKernelAccess extends ConfiguratorKernelAccess {
     getObjectComponent(runtimeId: number, typeOfId: Enumify_2<typeof CORE_TYPE_OF_CORE_ID>): KernelPlanObjectComponent | null;
     isChildObjectRootComponent(roomleComponent: RoomleComponent): boolean;
     isAnimationRootComponent(roomleComponent: RoomleComponent): boolean;
+    changePlanObjectParameter(runtimeId: number, parameterKey: string, type: string, value: string, resolve: () => void, reject: () => void): void;
+    changePlanObjectsParameter(runtimeIds: number[], parameterKey: string, type: string, value: string, resolve: () => void, reject: () => void): void;
+    changeComponentParameter(componentId: number, parameterKey: string, type: string, value: string, resolve: () => void, reject: () => void): void;
 }
 
 export declare interface PlannerKernelCallbackI {
@@ -6127,7 +6216,7 @@ export declare class PlannerSceneEventHandler extends SceneEventHandler<SceneEve
     private _currentPlanMeasure;
     constructor(creator: string, scene: Scene, camera: Camera, inputManager: InputManager);
     disable(): void;
-    get planInteractionHandler(): PlanInteractionHandler;
+    get planInteractionManager(): PlanInteractionManager;
     get planModelViewHelper(): PlanModelViewHelper_2;
     get hoveredObjectId(): number | null;
     get isCurrentlyDrawing(): boolean;
@@ -6400,6 +6489,8 @@ export declare class PlannerSceneManager extends ConfiguratorSceneManager implem
     private _hideAllNodeIfThereAreNoSelections;
     protected _onCameraMove(): boolean;
     private _showWallNodes;
+    private _applyFenceNodeStyle;
+    private _shouldKeepFenceNodesVisible;
     private _updateNodeSize;
     private _sendPlanObjectPositions;
     private _sendMultiSelectionPosition;
@@ -6694,6 +6785,7 @@ export declare class PlanViewModel extends ConfiguratorViewModel implements Plan
     private commonHandlerForEditableAndTopView;
     isChildObjectRootComponent(roomleComponent: RoomleComponent): boolean;
     protected dockComponent(componentDocking: KernelComponentDocking): void;
+    private _isConstructionElement;
     protected _addComponent(component: RoomleComponent): void;
     private _getPlanObjectViewModelForRuntimeId;
     getConfigurablePlanObjectForId(id: number): ConfiguratorPlanObjectViewModel | null;
@@ -6871,6 +6963,8 @@ export declare interface PosDockedContextRoot {
     id: string;
     dockingVector: PosDock | string;
     dockingVectorIndex: number;
+    mode?: PosDockMode | string;
+    offset?: number[];
 }
 
 export declare interface PosDockInfo {
@@ -6879,6 +6973,8 @@ export declare interface PosDockInfo {
     end: number[];
 }
 
+export declare type PosDockMode = 'StartStart' | 'EndEnd' | 'StartEnd' | 'EndStart';
+
 export declare interface PosErrorMsg {
     category: LogMessageCategoryType;
     msg: string;
@@ -6943,6 +7039,19 @@ export declare interface PosGroup {
      * Optional the attributes of this group
      */
     attributes?: PosModuleAttribute[];
+    /**
+     * Optional repositioning data created by the group orchestrator's
+     * groupAdjust; used to recalculate pos/rotationY after arranging
+     */
+    repositioningData?: PosGroupPositioningData;
+}
+
+export declare interface PosGroupPositioningData {
+    posGroup: number[];
+    posRotationY?: number;
+    rootId: string;
+    rootRelPos?: number[];
+    rootRelRotationY?: number;
 }
 
 export declare interface PosInsertLevelInfo {
@@ -9003,8 +9112,8 @@ export declare class RoomlePlanner<P extends readonly PluginName[] = readonly []
     private _globalInitData;
     private _globalCallback;
     private _unitFormatter;
+    private _planInteractionManager;
     private _elevationPlan2dGenerator;
-    private _planInteractionHandler;
     private _sceneManager;
     private _plan;
     private _preloadPlanId;
@@ -9126,7 +9235,7 @@ export declare class RoomlePlanner<P extends readonly PluginName[] = readonly []
     pauseTest(): void;
     syncCatalog(catalogId: string): Promise<void>;
     loadError(error?: any): void;
-    getPlanInteractionHandler(): Promise<PlanInteractionHandler>;
+    getPlanInteractionManager(): Promise<PlanInteractionManager>;
     getPlanModelViewHelper(): Promise<PlanModelViewHelper_2>;
     /**
      * Inserts the object into the scene (at a given position and rotation)
@@ -9171,6 +9280,12 @@ export declare class RoomlePlanner<P extends readonly PluginName[] = readonly []
      * get all info available for the current plan, including objects, rooms and walls
      */
     getPlanOverview(): Promise<PlanOverview>;
+    /**
+     * get the construction overview of the current plan, including the
+     * construction objects (construction, doors and windows) and their combined
+     * bill of materials
+     */
+    getConstructionOverview(): Promise<ConstructionOverview>;
     /**
      * Generates a top image (birds eye view) and returns it as base64
      * @param options
@@ -9411,12 +9526,6 @@ export declare class RoomlePlanner<P extends readonly PluginName[] = readonly []
      */
     selectProduct(planElementId: number, configurationId: number | null, contextAction: HiContextAction): Promise<void>;
     /* Excluded from this release type: globalCallbacks */
-    /**
-     * Handles interaction with the planner kernel, ensuring start and end interaction are tracked.
-     * @param action A function representing the action to perform.
-     * @returns The result of the action, if any.
-     */
-    private _executeWithInteraction;
     /**
      * Creates a sloping roof attic on a given wall.
      * @param wall The wall to add an attic to.
@@ -9455,8 +9564,7 @@ export declare class RoomlePlanner<P extends readonly PluginName[] = readonly []
      */
     updateAtticWidth(attic: KernelAttic, width: number): void;
     /**
-     * Runs a given function with a call to start and end interaction in the planInteractionHandler,
-     *  this should be used when you want to add a history step after interacting with the plan.
+     * Runs a callback as one atomic interaction step.
      * @param callback any function.
      */
     executeWithInteraction<T>(callback: MaybePromise<T>): Promise<T>;
@@ -9557,7 +9665,7 @@ export declare class RoomlePlannerUiCallback extends UiCallback implements Exter
     onCameraChanged: (type: Enumify_4<typeof CAMERA_TYPE>) => void;
     onCameraIdle: () => void;
     onTotalFloorAreaChanged: (totalFloorArea: number) => void;
-    onPlanInteractionHandlerCreated: (planInteractionHandler: PlanInteractionHandler) => void;
+    onPlanInteractionManagerCreated: (planInteractionManager: PlanInteractionManager) => void;
     /**
      * is called when the planner kernel is ready. It returns the container and the instance
      * @param kernelContainer
@@ -10218,6 +10326,197 @@ export declare class StaticPlanObjectViewModel extends PlanObjectViewModel {
     update(): void;
 }
 
+export declare const STEP_GROUPS: {
+    readonly move: {
+        readonly finalize: "on-signal";
+        readonly methods: ["moveElementTo", "moveElementToIn2d", "moveElementBy", "moveObjectsBy"];
+    };
+    readonly rotate: {
+        readonly finalize: "immediate";
+        readonly methods: ["rotateObjectTo", "setObjectRotation", "rotateObjectsBy", "rotateGroupBy"];
+    };
+    readonly wallHeight: {
+        readonly finalize: "on-signal";
+        readonly methods: ["setWallHeight"];
+    };
+    readonly wallLength: {
+        readonly finalize: "on-signal";
+        readonly methods: ["setLengthOfEdge2D"];
+    };
+    readonly wallThickness: {
+        readonly finalize: "on-signal";
+        readonly methods: ["setWallThickness"];
+    };
+    readonly objectSize: {
+        readonly finalize: "immediate";
+        readonly methods: ["setObjectSize"];
+    };
+    readonly floorLabelObject: {
+        readonly finalize: "immediate";
+        readonly methods: ["setFloorLabelObject"];
+    };
+    readonly roomParapetHeight: {
+        readonly finalize: "on-signal";
+        readonly methods: ["setRoomParapetHeight"];
+    };
+    readonly measure: {
+        readonly finalize: "on-signal";
+        readonly methods: ["setMeasurePoint1", "setMeasurePoint2"];
+    };
+    readonly remove: {
+        readonly finalize: "immediate";
+        readonly methods: ["removeElement", "removeObjectWithId"];
+    };
+    readonly duplicate: {
+        readonly finalize: "immediate";
+        readonly methods: ["duplicatePlanObject", "duplicatePlanObjects"];
+    };
+    readonly visibility: {
+        readonly finalize: "immediate";
+        readonly methods: ["setElementVisibility"];
+    };
+    readonly addObjects: {
+        readonly finalize: "immediate";
+        readonly methods: ["addPlanObjects"];
+    };
+    readonly addObjectFromItem: {
+        readonly finalize: "immediate";
+        readonly methods: ["addPlanObjectFromItem"];
+    };
+    readonly merge: {
+        readonly finalize: "immediate";
+        readonly methods: ["mergeObjects"];
+    };
+    readonly group: {
+        readonly finalize: "immediate";
+        readonly methods: ["groupObjects"];
+    };
+    readonly drawing: {
+        readonly finalize: "on-signal";
+        readonly methods: ["beginDrawing", "addNode", "addWall"];
+    };
+    readonly addAttic: {
+        readonly finalize: "immediate";
+        readonly methods: ["addAttic"];
+    };
+    readonly atticSide: {
+        readonly finalize: "immediate";
+        readonly methods: ["setAtticSide"];
+    };
+    readonly atticKneeHeight: {
+        readonly finalize: "immediate";
+        readonly methods: ["setAtticKneeHeight"];
+    };
+    readonly atticWidth: {
+        readonly finalize: "immediate";
+        readonly methods: ["setAtticWidth"];
+    };
+    readonly defaultWallThickness: {
+        readonly finalize: "on-signal";
+        readonly methods: ["setDefaultWallThickness"];
+    };
+    readonly defaultWallHeight: {
+        readonly finalize: "on-signal";
+        readonly methods: ["setDefaultWallHeight"];
+    };
+    readonly defaultParapetHeight: {
+        readonly finalize: "on-signal";
+        readonly methods: ["setDefaultParapetHeight"];
+    };
+    readonly defaultExteriorWallMaterial: {
+        readonly finalize: "on-signal";
+        readonly idleCommitMs: 3000;
+        readonly methods: ["setDefaultExteriorWallMaterial"];
+    };
+    readonly defaultInteriorWallMaterial: {
+        readonly finalize: "on-signal";
+        readonly idleCommitMs: 3000;
+        readonly methods: ["setDefaultInteriorWallMaterial"];
+    };
+    readonly defaultFloorMaterial: {
+        readonly finalize: "on-signal";
+        readonly idleCommitMs: 3000;
+        readonly methods: ["setDefaultFloorMaterial"];
+    };
+    readonly customDataJson: {
+        readonly finalize: "immediate";
+        readonly methods: ["setElementCustomDataJson"];
+    };
+    readonly wallLeftMaterial: {
+        readonly finalize: "on-signal";
+        readonly idleCommitMs: 3000;
+        readonly methods: ["setWallLeftMaterial"];
+    };
+    readonly wallRightMaterial: {
+        readonly finalize: "on-signal";
+        readonly idleCommitMs: 3000;
+        readonly methods: ["setWallRightMaterial"];
+    };
+    readonly floorMaterial: {
+        readonly finalize: "on-signal";
+        readonly idleCommitMs: 3000;
+        readonly methods: ["setFloorMaterial"];
+    };
+    readonly floorType: {
+        readonly finalize: "immediate";
+        readonly methods: ["setFloorType"];
+    };
+    readonly edgeType: {
+        readonly finalize: "immediate";
+        readonly methods: ["setEdgeType"];
+    };
+    readonly objectFlipX: {
+        readonly finalize: "immediate";
+        readonly methods: ["setObjectFlipX"];
+    };
+    readonly objectFlipY: {
+        readonly finalize: "immediate";
+        readonly methods: ["setObjectFlipY"];
+    };
+    readonly objectCustomColor: {
+        readonly finalize: "immediate";
+        readonly methods: ["setObjectCustomColor"];
+    };
+    readonly objectCustomLabel: {
+        readonly finalize: "immediate";
+        readonly methods: ["setObjectCustomLabel"];
+    };
+    readonly objectFixedZ: {
+        readonly finalize: "immediate";
+        readonly methods: ["setObjectFixedZ"];
+    };
+    readonly addMeasure: {
+        readonly finalize: "immediate";
+        readonly methods: ["addMeasure"];
+    };
+    readonly parameterChange: {
+        readonly finalize: "on-signal";
+        readonly idleCommitMs: 3000;
+        readonly methods: ["applyKernelParameterChange"];
+    };
+    readonly addOrUpdateExternal: {
+        readonly finalize: "immediate";
+        readonly methods: ["addOrUpdateExternalPlanObjects"];
+    };
+    readonly constructionBubbleEdit: {
+        readonly finalize: "immediate";
+        readonly methods: ["adjustConstructionElementPosition"];
+    };
+    readonly objectBubbleEdit: {
+        readonly finalize: "immediate";
+        readonly methods: ["adjustObjectPosition"];
+    };
+    readonly objectToWallDistanceBubbleEdit: {
+        readonly finalize: "immediate";
+        readonly methods: ["adjustObjectToWallDistance"];
+    };
+};
+
+/** The label recorded for an open/held step — what the policy compares. A step-group
+ *  name (from run()/transaction()) or a synthetic label. Method names are dispatch
+ *  INPUT, not labels; run() maps them to a group (buildDispatchTable). */
+export declare type StepLabel = keyof typeof STEP_GROUPS | SyntheticStepLabel;
+
 export declare class StringArray extends EmsArray<string> {
 }
 
@@ -10226,6 +10525,10 @@ export declare interface SubComponentWaiter {
     partId: number;
 }
 
+/** Step labels not derived from a dispatched method: held-phase / transaction labels
+ *  plus 'adhoc' (the run() fallback). Recorded only, never called on the handler. */
+export declare type SyntheticStepLabel = 'txn' | 'drawingMode' | 'configuratorMode' | 'externalObjectLoadStart' | 'insertItems' | 'replaceObject' | 'wallHeightBatch' | 'wallThicknessBatch' | 'wallMaterialBatch' | 'adhoc';
+
 export declare type ThreeJsColorsIn3dScene = Record<keyof typeof ROOMLE_COLORS, Color>;
 
 /**
@@ -10342,6 +10645,78 @@ export declare interface UiPossibleChildTag extends RapiTag {
     possibleChildren: UiPossibleChild[];
 }
 
+/**
+ * Two-class split, and the source of truth for `InteractionMethodName`: everything on
+ * UndoRedoHandler is Excluded from it (see types.ts).
+ *
+ * Where does a method go? Does its body wrap a core call in `this.run(...)`?
+ *   • Yes → PlanInteractionHandlerExtension (subclass): opens a tracked step, so it
+ *     may be classified in STEP_GROUPS and dispatched (adjust*,
+ *     applyKernelParameterChange, addOrUpdateExternalPlanObjects).
+ *   • No  → UndoRedoHandler (here): step machinery (run, commit, transaction, held-
+ *     phase controls, dispose) and boundary ops that only reset/commit around a core
+ *     call (undo/redo, loadPlanXML, endDrawing, …). Never dispatched.
+ */
+export declare class UndoRedoHandler {
+    private _disposed;
+    protected _handler: PlanInteractionHandler;
+    private _state;
+    private _pendingContinuations;
+    private _commitWhenSettled;
+    private _idleCommitTimer;
+    constructor(handler: PlanInteractionHandler);
+    dispose(): void;
+    private _scheduleIdleCommit;
+    private _clearIdleCommit;
+    get isDisposed(): boolean;
+    run<T>(methodName: InteractionMethodName, args: unknown[], apply: () => T): T;
+    commit(): void;
+    clearHistory(): void;
+    private reset;
+    undo(): void;
+    redo(): void;
+    loadPlanXML(xml: string): Plan_2;
+    createPlanWithObjectFromItem(object: KernelObject, position: KernelVector3, rotationInRad: number): Plan_2;
+    endDrawing(point: {
+        x: number;
+        y: number;
+        z: number;
+    }): void;
+    cancelDrawing(): void;
+    private _hold;
+    private _release;
+    manageExternalObjectLoadingStart(reason?: string): void;
+    resumeExternalObjectLoading(reason?: string): void;
+    manageExternalObjectLoadingEnd(shouldEnd?: boolean): void;
+    startConfiguringMode(): void;
+    endConfiguringMode(): void;
+    beginContinuousOperation(): void;
+    endContinuousOperation(): void;
+    endContinuousOperationIfHeld(): void;
+    transaction<T>(fn: () => T | Promise<T>, opts?: {
+        newStep?: boolean;
+        label?: StepLabel;
+        id?: string | number;
+        finalize?: FinalizeMode;
+        idleCommitMs?: number;
+    }): Promise<T>;
+    manageItemInsertion<T>(callback: () => T | Promise<T>, newUndoRedoStep?: boolean, finalize?: FinalizeMode): Promise<T>;
+    /**
+     * Explicit product-swap primitive: pins one interaction across a remove
+     * followed by an add so the pair always lands as a single undo/redo step,
+     * regardless of either half's own finalize policy. `perform` is expected to
+     * end with an operation that owns its own release (e.g. the catalog flow's
+     * `manageItemInsertion`, or the HI flow's reason-driven
+     * `manageExternalObjectLoadingEnd`) — that release performs the actual
+     * commit. The `finally` below is a safety net: it only fires if `perform`
+     * never reached that release (it threw, or simply never triggered one),
+     * so the manager can't get stuck held.
+     */
+    replaceObject<T>(elementId: string | number, perform: () => T | Promise<T>): Promise<T>;
+    expectContinuation(): void;
+    onCoreLoad(reason: HiLoadObjectReason): void;
+}
+
 export declare const enum Unit {
     InchFeet = 0,
     MM = 1,
@@ -10559,7 +10934,7 @@ export declare class WallPlanElementViewModel extends PlanElementViewModel {
     constructor(planObject: PlanObject);
     get isSelected(): boolean;
     private _checkHasAttachedAttic;
-    getWallDimension(zoomFactor: number, clientWidth: number, clientHeight: number): WallDimension;
+    getWallDimension(zoomFactor: number, clientWidth: number, clientHeight: number, preferredSideOverride?: LeftOrRightWallSide): WallDimension;
     private calculateNormalVector;
     private calculateShiftingFactor;
     private calculateAtticInfo;