@roomle/web-sdk 5.1.0-alpha.6 → 5.1.0-typestest.1

package/lib/roomle-sdk.d.ts

@@ -6,26 +6,9 @@ import { Camera as Camera_2 } from 'three/webgpu';
 import { Color } from 'three';
 import { ColorRepresentation } from 'three';
 import { ColorRepresentation as ColorRepresentation_2 } from 'three/webgpu';
-import { CommunicationInterfaceCallback } from '../../../workers/src/communication-interface';
-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';
-import { Enumify as Enumify_3 } from '../../../../../common/src/utils/types';
-import { Enumify as Enumify_4 } from '../../../../common/src/utils/types';
 import { Euler } from 'three';
-import { ExtObjId } from '../../../common/src/utils/external-objects';
-import { ExtObjId as ExtObjId_2 } from '../../../../../common/src/utils/external-objects';
 import { Group } from 'three';
-import { HiCallbacks } from '../../../../common/src/hi/hi-types';
-import { HiOrderData } from '../../../../common/src/hi/hi-types';
-import { HiOrderHeader } from '../../../../common/src/hi/hi-types';
 import { Intersection } from 'three';
-import { isIdAComponent } from '../../common/src/utils/id-inferrer';
-import { isIdAConfigurationString } from '../../common/src/utils/id-inferrer';
-import { isIdAnItem } from '../../common/src/utils/id-inferrer';
-import { isIdAPlan } from '../../common/src/utils/id-inferrer';
-import { isPlanSnapshotId } from '../../common/src/utils/id-inferrer';
 import { Layers } from 'three';
 import { Light } from 'three';
 import { Material } from 'three';
@@ -34,32 +17,33 @@ import { Mesh } from 'three';
 import { MeshPhysicalMaterial } from 'three';
 import { MeshStandardMaterial } from 'three';
 import { NormalBufferAttributes } from 'three';
-import { Nullable } from '../../common/src/utils/types';
-import { Nullable as Nullable_2 } from '../../../../../common/src/utils/types';
 import { Object3D } from 'three';
 import { Object3D as Object3D_2 } from 'three/webgpu';
 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 { Scene as Scene_2 } from 'three/webgpu';
 import { Texture } from 'three';
 import { TextureLoader } from 'three';
 import { Vector2 } from 'three';
-import { Vector3 } from 'three';
+import { Vector3 as Vector3_2 } from 'three';
 import { WebGLRenderer } from 'three';
 import { WebGPURenderer } from 'three/webgpu';
-import { WORKER_MESSAGE } from '../../../workers/src/communication-interface';
 
 export declare abstract class AbstractModel {
     extRef: number;
     abstract getId(): number;
 }
 
+export declare interface AbstractModel_2 {
+    new (): AbstractModel_2;
+    getId(): number;
+    extRef: ExternalReference_2;
+}
+
 export declare class AbstractModelWrapper extends AbstractModel {
     getId(): number;
 }
@@ -85,16 +69,23 @@ export declare interface AddOnSpot {
     mask: string;
 }
 
+export declare interface AddOnSpot_2 {
+    mask: string;
+    position: Vector3;
+}
+
 export declare class AddOnSpotArray extends EmsArray<KernelAddOnSpot> {
 }
 
-export declare class AddOnSpotArray_2 extends EmsArray<KernelAddOnSpot> {
+export declare type AddOnSpotArray_2 = EmscriptenArray<AddOnSpot_2>;
+
+export declare class AddOnSpotArray_3 extends EmsArray<KernelAddOnSpot> {
 }
 
 export declare class AdjustableCameraControl3D extends CameraControl3D {
     shouldIgnoreStandardBehavior: boolean;
-    adjust(bounds: Vector3, position: Vector3, yaw: number, pitch: number, _fov: number): void;
-    protected _update(overrideTarget?: Vector3): void;
+    adjust(bounds: Vector3_2, position: Vector3_2, yaw: number, pitch: number, _fov: number): void;
+    protected _update(overrideTarget?: Vector3_2): void;
     animateCamera(delta: number): boolean;
 }
 
@@ -102,12 +93,33 @@ export declare interface Anchor {
     value: ResizingAnchor;
 }
 
+export declare interface Animation_2 {
+    actions: AnimationAction[];
+    animate?: boolean;
+    applyToChildren?: boolean;
+    enabled: boolean;
+    group: string;
+    key: string;
+    label: string;
+    level: number;
+    sort: number;
+    visibleInPlanner: boolean;
+}
+
 export declare const ANIMATION_LEVEL: {
     readonly COMPONENT: 0;
     readonly OBJECT_COMPONENT: 1;
     readonly OBJECT: 2;
 };
 
+export declare interface AnimationAction {
+    key: string;
+    label: string;
+    type: string;
+}
+
+export declare type AnimationArray = EmscriptenArray<Animation_2>;
+
 export declare interface AnimationKeyAndValue {
     key: string;
     value: string;
@@ -120,6 +132,11 @@ export declare interface AnimationTransformation {
     key: string;
 }
 
+export declare interface AnimationTransformation_2 {
+    animationMatrix: Matrix4;
+    key: string;
+}
+
 export declare interface AnimationTransition {
     from: string;
     to: string;
@@ -158,6 +175,11 @@ export declare interface AppState {
 
 export declare type ArticleNumber = string;
 
+export declare interface AssembledObjectBounds {
+    boundingBox: Box;
+    parts: ObjectBoundsArray;
+}
+
 export declare interface Asset {
     format: string;
     url: string;
@@ -180,13 +202,39 @@ export declare interface AssetResponse {
     value?: number;
 }
 
+export declare interface AssetResponse_2 {
+    data: any;
+    id: string;
+    type: AssetType_2;
+    value?: number;
+}
+
 export declare interface AssetType {
     value: Enumify<typeof CORE_ASSET_TYPE>;
 }
 
+export declare interface AssetType_2 {
+    value: Enumify_3<typeof CORE_ASSET_TYPE_2>;
+}
+
 export declare type AssetUrl = string;
 
-export declare interface AtticDimension<Vector2Type = Vector3 | Position2, Vector3Type = Vector3 | Position3> {
+export declare interface Attic extends PlanElement_2 {
+    new (): Attic;
+    getFrom(): Node_3;
+    getTo(): Node_3;
+    getAssociatedWall(): Wall_2;
+    get2dPolygon(): PointArray_2;
+    getRidgePoints(): PointArray_2;
+    getPointsWithHeight(height: number): PointArray_2;
+    readonly side: WallSide_2;
+    readonly kneeHeight: number;
+    readonly width: number;
+}
+
+export declare type AtticArray = EmscriptenArray<Attic>;
+
+export declare interface AtticDimension<Vector2Type = Vector3_2 | Position2, Vector3Type = Vector3_2 | Position3> {
     /** Start position of the attic in 3D **/
     fromPosition3d?: Vector3Type;
     /** End position of the attic in 3D **/
@@ -270,6 +318,16 @@ export declare abstract class BaseMaterial {
     getSourceType(): KernelEnum;
 }
 
+export declare interface BaseMaterial_2 extends AbstractModel_2 {
+    new (): BaseMaterial_2;
+    getCatalogItemId(): string;
+    getSourceType(): MaterialSourceType_2;
+    catalogItemId: string;
+    materialId: string;
+    rgbValue: number;
+    useCustomColor: boolean;
+}
+
 export declare interface BaseMDAttributeInfo {
     id: string;
     name: string;
@@ -292,6 +350,11 @@ export declare interface BatchPaintMaterial {
     catalogItemId?: RapiId;
 }
 
+export declare interface Box {
+    origin: Vector3;
+    size: Vector3;
+}
+
 export declare class CacheHolder {
     private _componentCache;
     private _geometryCache;
@@ -345,7 +408,7 @@ export declare class CameraBehaviourState implements Context {
     _creator_: string;
     private _lastPlanBounds;
     constructor(creator: string);
-    isWithinPlanBounds(position: Vector3, updatedBounds?: Box3): boolean;
+    isWithinPlanBounds(position: Vector3_2, updatedBounds?: Box3): boolean;
 }
 
 export declare abstract class CameraControl extends EventDispatcher<CameraEventMap> implements Context {
@@ -356,8 +419,8 @@ export declare abstract class CameraControl extends EventDispatcher<CameraEventM
     protected _width: number;
     protected _height: number;
     protected _boundingBox: Box3;
-    protected _cameraPosition: Vector3;
-    protected _targetPosition: Vector3;
+    protected _cameraPosition: Vector3_2;
+    protected _targetPosition: Vector3_2;
     protected _tweenEnd: CameraParameter | null;
     private _stateSaved;
     private _cameraStandingStill;
@@ -395,14 +458,14 @@ export declare abstract class CameraControl extends EventDispatcher<CameraEventM
     lock(): void;
     unlock(): void;
     isLocked(): boolean;
-    getTargetPosition(): Vector3;
+    getTargetPosition(): Vector3_2;
     protected _saveYawAndPitch(): void;
-    getInputPosition(position: Position2): Vector3;
+    getInputPosition(position: Position2): Vector3_2;
     addLightContainer(container: Object3D): void;
-    checkNearFarDistance(point: Vector3): void;
+    checkNearFarDistance(point: Vector3_2): void;
     setBounds(boundingBox: Box3): void;
     get domHelper(): DomHelper;
-    protected abstract _update(overrideTarget?: Vector3, ignoreChecks?: boolean | undefined, keepVariables?: boolean | undefined): void;
+    protected abstract _update(overrideTarget?: Vector3_2, ignoreChecks?: boolean | undefined, keepVariables?: boolean | undefined): void;
     abstract getKernelZoomFactor(): number;
 }
 
@@ -425,7 +488,7 @@ export declare class CameraControl2D extends CameraControl {
     private _zoomTo;
     private _move;
     zoomToFitBounds(bounds: Box3, zoomInAllowed: boolean, force?: boolean): void;
-    protected _update(_overrideTarget?: Vector3, _ignoreChecks?: boolean | undefined, _keepVariables?: boolean | undefined): void;
+    protected _update(_overrideTarget?: Vector3_2, _ignoreChecks?: boolean | undefined, _keepVariables?: boolean | undefined): void;
     animateCamera(delta: number): boolean;
     getKernelZoomFactor(): number;
 }
@@ -474,16 +537,16 @@ export declare class CameraControl3D extends CameraControl {
     checkBoundsAndPlaceCamera(boundingBox: Box3, reset?: boolean): void;
     adjustToBoundsWithoutChangingDistance(boundingBox: Box3): void;
     zoomToFitBounds(boundingBox: Box3, reset?: boolean): void;
-    updateToBounds(boundingBox: Box3, isPreview: boolean, changeCamera?: boolean, target?: Vector3): void;
+    updateToBounds(boundingBox: Box3, isPreview: boolean, changeCamera?: boolean, target?: Vector3_2): void;
     protected _checkZoomDistance(boundingBox: Box3, idealDistance: number): void;
-    protected _setDistanceAndRangesBasedOnBounds(bounds: Vector3, updateDistance?: boolean): number;
+    protected _setDistanceAndRangesBasedOnBounds(bounds: Vector3_2, updateDistance?: boolean): number;
     private _getIdealDistance;
     private _getOffset;
     private _getMargin;
-    reset(bounds: Box3, target?: Vector3, yaw?: number, pitch?: number, animate?: boolean): void;
+    reset(bounds: Box3, target?: Vector3_2, yaw?: number, pitch?: number, animate?: boolean): void;
     updateDistanceAndRangesBasedOnBounds(boundingBox: Box3, updateDistance?: boolean): void;
     updateAndReset(boundingBox: Box3, animate?: boolean): Promise<void>;
-    protected _update(overrideTarget?: Vector3, ignoreChecks?: boolean, keepVariables?: boolean): void;
+    protected _update(overrideTarget?: Vector3_2, ignoreChecks?: boolean, keepVariables?: boolean): void;
     private _zoomChanged;
     zoomTo(cameraParameters: CameraParameter): Promise<void>;
     private _getCameraSphere;
@@ -533,7 +596,7 @@ export declare class CameraControlFirstPerson extends CameraControl {
     private _move;
     private _up;
     private _onLongDown;
-    protected _update(_overrideTarget?: Vector3): void;
+    protected _update(_overrideTarget?: Vector3_2): void;
     updateCamera(): void;
     private _onKeyChanged;
     private _processKeyMap;
@@ -603,8 +666,8 @@ export declare interface CameraParameter {
 }
 
 export declare interface CameraTarget {
-    center: Vector3;
-    bounds: Vector3;
+    center: Vector3_2;
+    bounds: Vector3_2;
     diagonal: number;
 }
 
@@ -650,9 +713,23 @@ export declare class CatalogItem extends AbstractModelWrapper {
     flipable: boolean;
 }
 
+export declare interface CatalogItem_2 extends AbstractModel_2 {
+    new (id: string): CatalogItem_2;
+    size: Vector3;
+    layer: number;
+    type: string;
+    detailType: string;
+    configuration: string;
+    orderable: boolean;
+    scaleable: boolean;
+    flipable: boolean;
+}
+
 export declare class CatalogItemPtrList extends EmsList<CatalogItem> {
 }
 
+export declare type CatalogItemPtrList_2 = EmscriptenList_2<CatalogItem_2>;
+
 export declare class CeilingLight extends PointLight {
     private _container;
     private _shouldCastShadow;
@@ -980,6 +1057,43 @@ export declare abstract class CommonKernelAccess implements LifeCycleCallbacks,
     requestPartListAndUpdatePricesOfParts(uniqueId?: ConfigurationHash, _prices?: Map<ArticleNumber, RapiPrice>): Promise<void>;
 }
 
+export declare interface CommunicationInterfaceCallback {
+    onCommand(command: WORKER_MESSAGE, conversationId: number, data: any): void;
+}
+
+export declare interface Component {
+    addOnSpots: AddOnSpot_2[];
+    animations: Animation_2[];
+    boxForMeasurement: Box;
+    childAnimationTransformations: ComponentAnimationTransformation_2[];
+    childIds: number[];
+    componentId: string;
+    dimensioningAxes: DimensioningAxis_2[];
+    dimensionings: Dimensioning_2[];
+    draggingIsLocked: boolean;
+    externalComponent: boolean;
+    geometryBounds: AssembledObjectBounds;
+    globalTransform: Matrix4;
+    hash: string;
+    id: number;
+    label: string;
+    labelIsCalculated: boolean;
+    objectId: number;
+    parameterGroups: ParameterGroup[];
+    parameters: Parameter[];
+    parentId: number;
+    permissionToDelete: PermissionToDelete;
+    permissionToDeleteInIsolation: PermissionToDelete;
+    position: Vector3;
+    possibleChildren: PossibleChild[];
+    rootId: number;
+    rootModuleIds: number[];
+    rootSiblingIds: number[];
+    rotation: Vector3;
+    type: PlanComponentType;
+    valid: boolean;
+}
+
 export declare type ComponentAction = 'edit' | 'add';
 
 export declare interface ComponentAnimationTransformation {
@@ -987,12 +1101,22 @@ export declare interface ComponentAnimationTransformation {
     componentRuntimeId: number;
 }
 
+export declare interface ComponentAnimationTransformation_2 {
+    animations: AnimationTransformation_2[];
+    componentRuntimeId: number;
+}
+
 export declare class ComponentArray extends EmsArray<KernelComponent> {
 }
 
 export declare class ComponentArray_2 extends EmsArray<KernelComponent> {
 }
 
+export declare interface ComponentBounds {
+    boxForMeasurement: Box;
+    geometryBounds: AssembledObjectBounds;
+}
+
 export declare type ComponentType = 'preview' | 'component';
 
 export declare type ConfigForPlugin<P extends PluginName> = PluginConfigMap[P];
@@ -1025,6 +1149,18 @@ export declare interface ConfigurationLoadedResponse {
     rootComponentLabel: string;
 }
 
+export declare interface ConfigurationPlanView {
+    dimensioningColor?: string;
+    dimensioningLineWidth?: number;
+    label: string;
+    lineColor?: string;
+    lineOfSight: Vector3;
+    lineWidth?: number;
+    viewType: PlanViewType_2;
+}
+
+export declare type ConfigurationPlanViewArray = EmscriptenArray<ConfigurationPlanView>;
+
 export declare type ConfigurationString = string;
 
 export declare interface ConfigurationUniqueIdAndHash {
@@ -1092,7 +1228,7 @@ export declare interface ConfiguratorInitData {
      * @description Sets the behavior of the highlighting of a hovered component.
      * usage: highlighting=smart
      */
-    highlighting?: Enumify_3<typeof ROOMLE_HIGHLIGHTNG>;
+    highlighting?: Enumify<typeof ROOMLE_HIGHLIGHTNG>;
     /**
      * @description Set the floor material which is used when loading the configurator
      * For different options see {@link @roomle/web-sdk/configurator-core/src/environment/dynamic-environment-setting-loader#EnvironmentSetting}
@@ -1212,6 +1348,8 @@ export declare interface ConfiguratorInitData {
     meshRaycasting?: boolean;
 }
 
+export declare type ConfiguratorKernel = Kernel;
+
 export declare class ConfiguratorKernelAccess extends CommonKernelAccess {
     private _memoryManager;
     private _configuratorKernelAccessCallback;
@@ -1540,7 +1678,7 @@ export declare class ConfiguratorSceneEventHandler extends SceneEventHandler<Sce
     private _dragEnd;
     protected _interaction(forceRender?: boolean): void;
     hasSelection(): boolean;
-    update(bounds: Vector3 | null, rootComponentPosition: Vector3 | null, backgroundScene: Scene | null): void;
+    update(bounds: Vector3_2 | null, rootComponentPosition: Vector3_2 | null, backgroundScene: Scene | null): void;
     isDragIn(): boolean;
     isDragging(): boolean;
     setRootComponentId(rootComponentId: number): void;
@@ -1576,7 +1714,7 @@ export declare class ConfiguratorSceneManager extends SceneManager implements Co
     private _isComponentDimensionsVisible;
     private _dimensionUpdateDebounced;
     private _sceneSetupReady;
-    constructor(creator: string, offset: CanvasOffset, mode: Enumify_3<typeof CAMERA_TYPE>);
+    constructor(creator: string, offset: CanvasOffset, mode: Enumify<typeof CAMERA_TYPE>);
     /**
      * Single point for deciding whether to push HTML label positions to the UI.
      * the scene manager must push screen positions after any change.
@@ -1649,7 +1787,7 @@ export declare class ConfiguratorSceneManager extends SceneManager implements Co
     private _cancelSelection;
     private _selectComponent;
     private _deselectComponent;
-    getScreenXY(position: Vector3): Vector3;
+    getScreenXY(position: Vector3_2): Vector3_2;
     setSelectionMode(mode: SELECTION_MODE): void;
     changeFloorMaterial(material: RapiMaterial): Promise<void>;
     zoomIn(value?: number): void;
@@ -1693,7 +1831,7 @@ export declare class ConfiguratorSceneManager extends SceneManager implements Co
     private _shouldHighlightComponent;
     saveConfigToIdb(): void;
     protected _getInputManager(): InputManager;
-    protected createCameraControl(_mode: Enumify_3<typeof CAMERA_TYPE>, offset: CanvasOffset): void;
+    protected createCameraControl(_mode: Enumify<typeof CAMERA_TYPE>, offset: CanvasOffset): void;
     getBounds(): Box3 | null;
     getGeometryBounds(): Box3 | null;
     sceneChanged(): void;
@@ -2130,7 +2268,7 @@ export declare interface ConfiguratorViewModelCallbackI {
     addPreviewHandlers(previewComponent: PreviewComponent): void;
 }
 
-export declare type ConstructionMeasurement = MeasurementBase<Vector3, Vector3>;
+export declare type ConstructionMeasurement = MeasurementBase<Vector3_2, Vector3_2>;
 
 export declare interface ConstructionMeasurements {
     leftMeasurement: ConstructionMeasurement;
@@ -2150,9 +2288,32 @@ export declare abstract class ConstructionObject extends PlanObjectPtr {
     getAttachedWall(): Wall;
 }
 
+export declare interface ConstructionObject_2 extends PlanObject_2 {
+    new (): ConstructionObject_2;
+    getAttachedWall(): Wall_2;
+    getPreferredSide(): WallSide_2;
+    getCornerFromLeft(): Vector3;
+    getCornerFromRight(): Vector3;
+    getCornerToLeft(): Vector3;
+    getCornerToRight(): Vector3;
+    getDoorArches(): ConstructionObjectDoorArchArray;
+}
+
+export declare interface ConstructionObjectDoorArch {
+    getStartPoint(): Vector3;
+    getEndPoint(): Vector3;
+    getStartPointRelativeToObject(): Vector3;
+    getEndPointRelativeToObject(): Vector3;
+    getOpeningDirection(): OpeningDirection;
+}
+
+export declare type ConstructionObjectDoorArchArray = EmscriptenArray<ConstructionObjectDoorArch>;
+
 export declare class ConstructionObjectSet extends EmsSet<ConstructionObject> {
 }
 
+export declare type ConstructionObjectSet_2 = EmscriptenSet<ConstructionObject_2>;
+
 export declare interface ConstructionOverview {
     objects: KernelPlanObjectList;
     parts: PartList;
@@ -2176,9 +2337,9 @@ export declare class ConstructionPlanObjectViewModel extends StaticPlanObjectVie
     protected _generateBoundingBox(): RoomleEventedMesh;
     protected _updateBoundingBox(): void;
     getTopViewContainer(): ConstructionTopView;
-    getConstructionElementMeasurements(zoomFactor: number, clientWidth: number, clientHeight: number): Nullable_2<ConstructionMeasurements>;
+    getConstructionElementMeasurements(zoomFactor: number, clientWidth: number, clientHeight: number): Nullable<ConstructionMeasurements>;
     update(): void;
-    protected _setPositionOfBoundingBox(size: Vector3, mesh: RoomleEventedMesh): void;
+    protected _setPositionOfBoundingBox(size: Vector3_2, mesh: RoomleEventedMesh): void;
 }
 
 export declare class ConstructionTopView extends Object3D {
@@ -2208,13 +2369,27 @@ export declare interface Context {
 }
 
 export declare interface ContinuousDrawingManager {
+    new (): ContinuousDrawingManager;
+    getStartPoint(): Vector3;
+    getDrawingAngle(): number;
+    getCircleRotation(): number;
+    shouldShowCircle(): boolean;
+    isCorridorValid(): boolean;
+    getCorridor(): Line;
+    getDrawnPoints(): PointArray_2;
+    getModelCircleRadius(): number;
+    readonly CIRCLE_RADIUS: number;
+    circleRadius: number;
+}
+
+export declare interface ContinuousDrawingManager_2 {
     getStartPoint(): KernelVector3;
     getDrawingAngle(): number;
     getCircleRotation(): number;
     shouldShowCircle(): boolean;
     isCorridorValid(): boolean;
     getCorridor(): any;
-    getDrawnPoints(): PointArray_2;
+    getDrawnPoints(): PointArray_3;
     CIRCLE_RADIUS: number;
 }
 
@@ -2228,6 +2403,22 @@ export declare const CORE_ASSET_TYPE: {
     readonly EXTERNAL_SVG_URL: 6;
 };
 
+export declare const CORE_ASSET_TYPE_2: {
+    readonly ITEM: 0;
+    readonly COMPONENT: 1;
+    readonly EXTERNAL_MESH: 2;
+    readonly MATERIAL_PROPERTIES: 3;
+    readonly MATERIAL_GROUP: 4;
+    readonly EXTERNAL_OBJ_URL: 5;
+    readonly EXTERNAL_SVG_URL: 6;
+};
+
+export declare const CORE_DIMENSION_TYPE: {
+    readonly X: 0;
+    readonly Y: 1;
+    readonly Z: 2;
+};
+
 export declare const CORE_DOCK_PAIR_TYPE: {
     readonly POINT: 0;
     readonly LINE: 1;
@@ -2239,17 +2430,40 @@ export declare const CORE_DRAWING_MODE: {
     readonly CONTOUR: 2;
 };
 
+export declare const CORE_DRAWING_MODE_2: {
+    readonly WALL: 0;
+    readonly ROOM_CONTOUR: 1;
+    readonly CONTOUR: 2;
+    readonly CONSTRUCTION_CONTOUR: 3;
+};
+
+export declare const CORE_DRAWING_TYPE: {
+    readonly CONTINOUS: 0;
+    readonly CLICK_PER_CLICK: 1;
+};
+
 export declare const CORE_EDGE_TYPE: {
     readonly WALL: 0;
     readonly EDGE: 1;
     readonly CONSTRUCTION: 2;
 };
 
+export declare const CORE_EDGE_TYPE_2: {
+    readonly WALL: 0;
+    readonly EDGE: 1;
+    readonly CONSTRUCTION: 2;
+};
+
 export declare const CORE_FLOOR_TYPE: {
     readonly DEFAULT: 0;
     readonly TERRAIN: 1;
 };
 
+export declare const CORE_FLOOR_TYPE_2: {
+    readonly DEFAULT: 0;
+    readonly TERRAIN: 1;
+};
+
 export declare const CORE_HELP_LINE_TYPE: {
     readonly NONE: 0;
     readonly WALL_SNAP_LEVEL: 1;
@@ -2261,11 +2475,23 @@ export declare const CORE_HELP_LINE_TYPE: {
     readonly WALL_ALIGNMENT_SNAPPED: 7;
 };
 
+export declare const CORE_MATERIAL_SOURCE_TYPE: {
+    readonly NONE: 0;
+    readonly CATALOGITEM: 1;
+    readonly MATERIAL: 2;
+    readonly RGBVALUE: 3;
+};
+
 export declare const CORE_NODE_TYPE: {
     readonly DEFAULT: 0;
     readonly CONSTRUCTION: 1;
 };
 
+export declare const CORE_NODE_TYPE_2: {
+    readonly DEFAULT: 0;
+    readonly CONSTRUCTION: 1;
+};
+
 export declare const CORE_OBJECT_CATEGORY: {
     readonly OBJECT: 0;
     readonly DOOR: 1;
@@ -2275,12 +2501,44 @@ export declare const CORE_OBJECT_CATEGORY: {
     readonly EXTERNAL_CONSTRUCTION: 5;
 };
 
+export declare const CORE_OBJECT_TYPE_CATEGORY: {
+    readonly OBJECT: 0;
+    readonly DOOR: 1;
+    readonly WINDOW: 2;
+    readonly CONSTRUCTION: 3;
+    readonly UNKNOWN: 4;
+    readonly EXTERNAL_CONSTRUCTION: 5;
+};
+
+export declare const CORE_OPENING_DIRECTION: {
+    readonly LEFT_CLOCKWISE: 0;
+    readonly LEFT_COUNTERCLOCKWISE: 1;
+    readonly RIGHT_CLOCKWISE: 2;
+    readonly RIGHT_COUNTERCLOCKWISE: 3;
+};
+
+export declare const CORE_PARAMETER_TYPE_STRING: {
+    readonly UNKNOWN: "";
+    readonly INTEGER: "Integer";
+    readonly DECIMAL: "Decimal";
+    readonly STRING: "String";
+    readonly BOOLTYPE: "Boolean";
+    readonly MATERIAL: "Material";
+    readonly COLOR: "Color";
+};
+
 export declare const CORE_PERMISSION_TO_DELETE: {
     readonly NEVER: 0;
     readonly REDOCK_CHILDREN: 1;
     readonly ALWAYS: 2;
 };
 
+export declare const CORE_PERMISSION_TO_DELETE_2: {
+    readonly NEVER: 0;
+    readonly REDOCK_CHILDREN: 1;
+    readonly ALWAYS: 2;
+};
+
 export declare const CORE_PLAN_COMPONENT_TYPE: {
     readonly ROOT_COMPONENT: 0;
     readonly COMPONENT: 1;
@@ -2289,6 +2547,27 @@ export declare const CORE_PLAN_COMPONENT_TYPE: {
     readonly SUB_ARTICLE: 4;
 };
 
+export declare const CORE_PLAN_COMPONENT_TYPE_2: {
+    readonly ROOT_COMPONENT: 0;
+    readonly COMPONENT: 1;
+    readonly ROOT_MODULE: 2;
+    readonly SUB_MODULE: 3;
+    readonly SUB_ARTICLE: 4;
+};
+
+export declare const CORE_PLAN_ELEMENT_TYPE: {
+    readonly NODE: 0;
+    readonly WALL: 1;
+    readonly OBJECT: 2;
+    readonly FLOOR: 3;
+    readonly CEILING: 4;
+    readonly TEXT: 5;
+    readonly MEASURE: 6;
+    readonly IMAGE: 7;
+    readonly GROUP: 8;
+    readonly ATTIC: 9;
+};
+
 export declare const CORE_PLAN_ROOM_GEOMETRY_MODE: {
     readonly FLOOR: 0;
     readonly ROOM: 1;
@@ -2300,6 +2579,30 @@ export declare const CORE_PLAN_VIEW_TYPE: {
     readonly ELEVATION: 1;
 };
 
+export declare const CORE_PLAN_VIEW_TYPE_2: {
+    readonly FLOOR: 0;
+    readonly ELEVATION: 1;
+};
+
+export declare const CORE_RESIZING_ANCHOR: {
+    readonly CENTER: 0;
+    readonly BACKLEFT: 1;
+    readonly BACKRIGHT: 2;
+    readonly FRONTLEFT: 3;
+    readonly FRONTRIGHT: 4;
+    readonly BACK: 5;
+    readonly FRONT: 6;
+    readonly LEFT: 7;
+    readonly RIGHT: 8;
+};
+
+export declare const CORE_SNAP_MODE: {
+    readonly OFF: 0;
+    readonly ON_COLLISION: 1;
+    readonly ON_COLLISION_ROTATE_WITHIN_DISTANCE: 2;
+    readonly WITHIN_SNAP_DISTANCE: 3;
+};
+
 export declare const CORE_SNAP_STATE: {
     readonly DEFAULT: 0;
     readonly DOCKING: 1;
@@ -2311,9 +2614,48 @@ export declare const CORE_TYPE_OF_CORE_ID: {
     readonly PLANNER: 1;
 };
 
+export declare const CORE_UNIT_TYPE_STRING: {
+    readonly UNKNOWN_UNIT: "unknown";
+    readonly LENGTH: "length";
+    readonly AREA: "area";
+    readonly ANGLE: "angle";
+    readonly COUNT: "count";
+};
+
+export declare const CORE_VIEW_TYPE: {
+    readonly EMPTY: 0;
+    readonly TOGGLE: 1;
+    readonly IMAGELIST: 2;
+    readonly IMAGEBIG: 3;
+    readonly IMAGESMALL: 4;
+    readonly INPUTFIELD: 5;
+    readonly DROPDOWN: 6;
+    readonly SLIDER: 7;
+    readonly BUTTON: 8;
+};
+
+export declare const CORE_WALL_EXTENSION_TYPE: {
+    readonly EXTENDBEGIN: 0;
+    readonly EXTENDEND: 1;
+    readonly EXTENDBOTH: 2;
+};
+
+export declare const CORE_WALL_SIDE: {
+    readonly LEFT: 0;
+    readonly RIGHT: 1;
+    readonly MIDDLE: 2;
+};
+
+export declare const CORE_WALL_TYPE: {
+    readonly STANDALONEWALL: 0;
+    readonly OUTERWALLLEFT: 1;
+    readonly OUTERWALLRIGHT: 2;
+    readonly INNERWALL: 3;
+};
+
 export declare const createExtObj: (data: Record<string, unknown>) => Record<string, unknown>;
 
-export { createExtObjId }
+export declare const createExtObjId: (id: string) => ExtObjId;
 
 export declare interface CSS2DOverlayRenderer {
     renderSnapshot(camera: Camera, width: number, height: number): Promise<HTMLElement | null> | HTMLElement | null;
@@ -2395,16 +2737,39 @@ export declare class DataSyncer implements Context, CommunicationInterfaceCallba
     preFillAssetCache(key: string, url: string): void;
 }
 
+export declare interface Debug {
+    raycaster?: boolean;
+    camera?: boolean;
+    boundingBox?: boolean;
+    PlannerKernelContainer?: any;
+    ConfiguratorKernel?: any;
+    Kernel?: any;
+    KernelContainer?: any;
+    Helper?: any;
+    SceneManager?: unknown;
+    interactionTimingMs?: number;
+}
+
 export declare interface DebugClient {
     debugValueMapChange(changes: DebugValueMapChange): void;
 }
 
+export declare interface DebugClient_2 {
+    debugValueMapChange(changes: DebugValueMapChange_2): void;
+}
+
 export declare interface DebugValueMapChange {
     sourceId: number;
     sourceInfo: string;
     valueMaps: Record<string, DebugValueMapDump>;
 }
 
+export declare interface DebugValueMapChange_2 {
+    sourceId: number;
+    sourceInfo: string;
+    valueMaps: Record<string, DebugValueMapDump_2>;
+}
+
 export declare interface DebugValueMapDump {
     type: string;
     componentId: string;
@@ -2414,6 +2779,15 @@ export declare interface DebugValueMapDump {
     values: Record<string, string>;
 }
 
+export declare interface DebugValueMapDump_2 {
+    type: string;
+    componentId: string;
+    internalId: string;
+    id: number;
+    parentId: number;
+    values: Record<string, string>;
+}
+
 export declare const DEFAULT_ENVIRONMENT_SCENE_TYPES: {
     readonly ALL_AROUND: "all_around";
     readonly FRONT: "front";
@@ -2426,9 +2800,9 @@ export declare const DEFAULT_RENDER_OPTIONS: {
     useCurrentPerspective: boolean;
 };
 
-export declare type DefaultEnvironmentSceneType = Enumify_2<typeof DEFAULT_ENVIRONMENT_SCENE_TYPES> | null;
+export declare type DefaultEnvironmentSceneType = Enumify<typeof DEFAULT_ENVIRONMENT_SCENE_TYPES> | null;
 
-export declare interface DimensionDefinition<Vector2Type = Vector3 | Position2, Vector3Type = Vector3 | Position3> extends MeasurementBase<Vector2Type, Vector3Type> {
+export declare interface DimensionDefinition<Vector2Type = Vector3_2 | Position2, Vector3Type = Vector3_2 | Position3> extends MeasurementBase<Vector2Type, Vector3Type> {
     id: number;
     lengthFormatted: string;
     fromWithoutPadding?: Vector2Type;
@@ -2448,6 +2822,20 @@ export declare interface Dimensioning {
     interactionKey?: string;
 }
 
+export declare interface Dimensioning_2 {
+    axis: string;
+    from: number;
+    interactionKey: string;
+    label: string;
+    level: number;
+    maxLevel: number;
+    to: number;
+    type: {
+        value: DimensionType;
+    };
+    visible: boolean;
+}
+
 export declare interface DimensioningAxis {
     direction: KernelVector3;
     key: string;
@@ -2456,6 +2844,14 @@ export declare interface DimensioningAxis {
     alternativeOrigin?: KernelVector3;
 }
 
+export declare interface DimensioningAxis_2 {
+    alternativeOrigin?: Vector3;
+    direction: Vector3;
+    key: string;
+    labelDirection: Vector3;
+    origin: Vector3;
+}
+
 export declare class DimensioningHelper {
     _creator_: string;
     private _unitFormatter;
@@ -2503,7 +2899,7 @@ export declare class DimensioningHelper {
     enableTopDimensions(): void;
     disableTopDimensions(): void;
     getBoundingBox(): Box3;
-    setCameraPosition(position: Vector3): void;
+    setCameraPosition(position: Vector3_2): void;
     private _performUpdate;
     private _clear;
 }
@@ -2534,6 +2930,10 @@ export declare interface DimensionLabelsTransferable {
     componentId: number;
 }
 
+export declare interface DimensionType {
+    value: Enumify_3<typeof CORE_DIMENSION_TYPE>;
+}
+
 export declare interface DockingLineSegment {
     from: number;
     to: number;
@@ -2576,7 +2976,7 @@ export declare class DraggableNode extends Object3D {
     private _outerRingRadius;
     constructor(name: string, sphereSize?: number);
     private _initNodeMesh;
-    getSize(): Vector3;
+    getSize(): Vector3_2;
     hoverOn(): void;
     hoverOff(): void;
     setSphereColor(color: number): void;
@@ -2612,11 +3012,19 @@ export declare interface DrawingMode {
     value: Enumify<typeof CORE_DRAWING_MODE>;
 }
 
+export declare interface DrawingMode_2 {
+    value: Enumify_2<typeof CORE_DRAWING_MODE_2>;
+}
+
 export declare const enum DrawingType {
     CONTINOUS = 0,
     CLICK_PER_CLICK = 1
 }
 
+export declare interface DrawingType_2 {
+    value: Enumify_2<typeof CORE_DRAWING_TYPE>;
+}
+
 /**
  * Description of fields:
  - type: 'ambient'/'rectarea'/'spot'/'directional'
@@ -2637,8 +3045,8 @@ export declare interface DynamicLight {
     name?: string;
     intensity?: number;
     color?: string;
-    position?: Vector3;
-    target?: Vector3;
+    position?: Vector3_2;
+    target?: Vector3_2;
     castShadow?: boolean;
     angle?: number;
     penumbra?: number;
@@ -2660,6 +3068,10 @@ export declare interface EdgeDeflection {
 }
 
 export declare interface EdgeType {
+    value: Enumify_2<typeof CORE_EDGE_TYPE_2>;
+}
+
+export declare interface EdgeType_2 {
     value: Enumify<typeof CORE_EDGE_TYPE>;
 }
 
@@ -2707,11 +3119,38 @@ export declare class EMSConstant {
     value: number;
 }
 
+export declare interface EmscriptenArray<T> {
+    new (): EmscriptenArray<T>;
+    get(index: number): T;
+    push_back(element: T): void;
+    resize(from: number, to: number): void;
+    set(index: number, element: T): T;
+    size(): number;
+    clone(index: number): EmscriptenArray<T>;
+    delete(index: number): void;
+    deleteLater(index: number): void;
+    isAliasOf(index: number): boolean;
+    isDeleted(index: number): boolean;
+}
+
 export declare interface EmscriptenList {
     size: () => number;
     length: number;
 }
 
+export declare class EmscriptenList_2<T> {
+    new(): EmscriptenList_2<T>;
+    push_back(element: T): void;
+    size(): number;
+    get(index: number): T;
+}
+
+export declare interface EmscriptenSet<T> {
+    new (): EmscriptenSet<T>;
+    insert: (element: T) => void;
+    size: () => number;
+}
+
 export declare type EmscriptenString = any;
 
 export declare class EmsList<T> {
@@ -2740,9 +3179,15 @@ export declare class EmsSet<T> {
     size(): number;
 }
 
+export declare type Enumify<T> = T[keyof T];
+
+export declare type Enumify_2<T> = T[keyof T];
+
+export declare type Enumify_3<T> = T[keyof T];
+
 export declare abstract class Environment {
     protected _scene: Scene | null;
-    protected _bounds: Vector3;
+    protected _bounds: Vector3_2;
     constructor(scene: Scene, oldEnvironment?: Environment);
     abstract needsBounds(): boolean;
     abstract needsCamera(): boolean;
@@ -2751,7 +3196,7 @@ export declare abstract class Environment {
     abstract removeFromScene(): void;
     abstract showGUI(sceneParameters: GenericGUIParamFolder): void;
     reload(): void;
-    updateBounds(bounds: Vector3, _force?: boolean): void;
+    updateBounds(bounds: Vector3_2, _force?: boolean): void;
     cleanUp(): void;
 }
 
@@ -2879,6 +3324,8 @@ export declare const enum ExportType {
     HOMAGiX = 2
 }
 
+export declare const EXTERNAL_ID_PREFIX = "__ext__obj__#";
+
 export declare interface ExternalAttributeInformation {
     groupId: string;
     moduleIds: ExternalModuleInformation[];
@@ -2886,6 +3333,13 @@ export declare interface ExternalAttributeInformation {
     value: string;
 }
 
+export declare interface ExternalAttributeInformation_2 {
+    attributeId: string;
+    groupId: string;
+    moduleIds: ExternalModuleInformationArray;
+    value: string;
+}
+
 export declare type ExternalConfiguration = Partial<RapiConfigurationEnhanced> & Pick<RapiConfigurationEnhanced, keyof Element_2 | 'configurationHash'> & ExternalElement;
 
 export declare interface ExternalDataResponse<T> {
@@ -2903,6 +3357,12 @@ export declare interface ExternalEmbeddable<T = any> {
     callbacks: T;
 }
 
+export declare interface ExternalEnv {
+    assetPath?: string;
+    initData?: InitDataDefinition;
+    locale?: string;
+}
+
 export declare type ExternalGroupData = object | object[] | string | string[];
 
 export declare type ExternalItem = Partial<RapiItem> & Pick<RapiItem, keyof Element_2> & ExternalElement;
@@ -2918,11 +3378,19 @@ export declare interface ExternalModuleInformation {
 }
 
 export declare interface ExternalModuleInformation_2 {
+    groupId: string;
+    rootModuleId: string;
+    subModuleId: string;
+}
+
+export declare interface ExternalModuleInformation_3 {
     groupId: string;
     rootModuleId: string;
     subModuleId: string | null;
 }
 
+export declare type ExternalModuleInformationArray = EmscriptenArray<ExternalModuleInformation_2>;
+
 export declare type ExternalObject = ExternalItem | ExternalConfiguration;
 
 export declare interface ExternalObjectAPI {
@@ -3185,6 +3653,17 @@ export declare interface ExternalObjectGroupLayoutSide {
 }
 
 export declare interface ExternalObjectLoadConfiguration {
+    applyGlobalChildMode: boolean;
+    applyGroupPosition: boolean;
+    calculationUpdate: boolean;
+    findFreeSpaceInPlan: boolean;
+    isVisible: boolean;
+    lockCallbacks: boolean;
+    respondWithPositionInPlan: boolean;
+    tryToMergeNewGroups: boolean;
+}
+
+export declare interface ExternalObjectLoadConfiguration_2 {
     applyGlobalChildMode: boolean;
     applyGroupPosition: boolean;
     findFreeSpaceInPlan: boolean;
@@ -3308,6 +3787,10 @@ export declare class ExternalReference {
     clearSelfRef(): void;
 }
 
+export declare interface ExternalReference_2 {
+    new (): ExternalReference_2;
+}
+
 export declare type ExternalResponseValidator = (type: 'rapi-access', response: Response) => Promise<boolean>;
 
 export declare interface ExternalRoomInformation {
@@ -3324,7 +3807,22 @@ export declare interface ExternalValidContainerModule {
     rootId: string;
 }
 
-export { ExtObjId }
+export declare interface ExternalValidContainerModule_2 {
+    containerModuleId: string;
+    parentModuleId: string;
+    rootId: string;
+}
+
+export declare type ExtObjId = `${typeof EXTERNAL_ID_PREFIX}${string}`;
+
+export declare interface ExtrudedRectangle {
+    angle: number;
+    bottomCenter: Vector3;
+    readonly cornerPoints: PointArray_2;
+    readonly eulerRotation: Vector3;
+    readonly referencePoints: RectangleReferencePoints;
+    size: Vector3;
+}
 
 export declare interface FeatureFlags {
     pulsePreview?: boolean;
@@ -3350,7 +3848,7 @@ export declare class FeatureFlagsImplementation implements FeatureFlags {
     reDock: boolean;
     advancedDocking: boolean;
     mergeOnInsert: boolean;
-    drawPreviewMode: Enumify_3<typeof DRAW_PREVIEW_MODES>;
+    drawPreviewMode: Enumify<typeof DRAW_PREVIEW_MODES>;
     interiorLights: boolean;
     advancedDimensioning: boolean;
     enableSnapping: boolean;
@@ -3389,9 +3887,24 @@ export declare abstract class Floor extends PlanElement {
     getRandomPointInside(): KernelVector3f;
 }
 
-export declare interface FloorAreaData<Vector2Type = Vector3, Vector3Type = Vector3> {
+export declare interface Floor_2 extends PlanElement_2 {
+    new (): Floor_2;
+    getCorners(): PointArray_2;
+    getTriangulationIndices(): SizeTArray_2;
+    getNumberOfTriangles(): number;
+    getRandomPointInside(): Vector3;
+    getLabelPosition(): Vector3;
+    getWallsOfRoom(): RoomWall[];
+    getLabelObject(): string;
+    readonly area: number;
+    readonly material: FloorMaterial_2;
+    readonly parapetHeight: number;
+    readonly floorType: FloorType;
+}
+
+export declare interface FloorAreaData<Vector2Type = Vector3_2, Vector3Type = Vector3_2> {
     area: number;
-    formattedArea: Nullable_2<string>;
+    formattedArea: Nullable<string>;
     textPosition3d: Vector3Type;
     textPosition2d: Vector2Type;
     isTextVisible: boolean;
@@ -3411,6 +3924,12 @@ export declare class FloorMaterial extends BaseMaterial {
     rotation(): KernelVector3f;
 }
 
+export declare interface FloorMaterial_2 extends BaseMaterial_2 {
+    new (): FloorMaterial_2;
+    readonly uvScale: Vector3;
+    readonly rotation: number;
+}
+
 export declare interface FloorPlanEdge {
     id: number;
     start: KernelVector3f;
@@ -3431,7 +3950,11 @@ export declare class FloorPlanElementViewModel extends PlanElementViewModel {
 }
 
 export declare interface FloorType {
-    value: Enumify<typeof CORE_FLOOR_TYPE>;
+    value: Enumify_2<typeof CORE_FLOOR_TYPE>;
+}
+
+export declare interface FloorType_2 {
+    value: Enumify<typeof CORE_FLOOR_TYPE_2>;
 }
 
 /**
@@ -3503,13 +4026,13 @@ export declare class GLBViewerSceneManager extends SceneManager implements GLBRe
     private _standardSceneBackgroundColor;
     private _itemsCount;
     constructor(creator: string, offset: CanvasOffset);
-    protected createCameraControl(_mode: Enumify_3<typeof CAMERA_TYPE>, _offset: CanvasOffset): void;
+    protected createCameraControl(_mode: Enumify<typeof CAMERA_TYPE>, _offset: CanvasOffset): void;
     protected _getInputManager(): InputManager;
     loadStaticItem(id: string, callback?: (percent: number) => void): Promise<void>;
-    loadGLB(url: string, automaticallyAdjustCamera?: boolean, scaling?: Vector3, callback?: (percent: number) => void): Promise<void>;
+    loadGLB(url: string, automaticallyAdjustCamera?: boolean, scaling?: Vector3_2, callback?: (percent: number) => void): Promise<void>;
     preparePerspectiveImage(options?: PrepareImageOptions, providedRenderer?: WebGLRenderer): Promise<Base64Image>;
     private _prepareWebGpuPerspectiveImage;
-    adjustCamera(position: Vector3, yaw: number, pitch: number, fov: number): void;
+    adjustCamera(position: Vector3_2, yaw: number, pitch: number, fov: number): void;
     onStart(count: number): void;
     onElementFinished(itemsFinished: number): void;
     onFinished(_zip: any): void;
@@ -3555,7 +4078,7 @@ export declare interface GlobalAPI {
     getUnitFormatter(): UnitFormatter;
     getStorage(): IdbManager;
     setEnvironmentMap(params: EnvMapParams): void;
-    get globalCallbacks(): GlobalCallback;
+    /* Excluded from this release type: globalCallbacks */
 }
 
 export declare class GlobalCallback extends UiCallback {
@@ -3582,7 +4105,7 @@ export declare class GlobalCallback extends UiCallback {
      * @param _json the JSON response
      * @returns void
      */
-    onApiJsonReceived: (_url: string, _rapiPath: RAPI_PATHS, _json: any) => Promise<Nullable_2<RapiJsonBox> | undefined>;
+    onApiJsonReceived: (_url: string, _rapiPath: RAPI_PATHS, _json: any) => Promise<Nullable<RapiJsonBox> | undefined>;
     /**
      * is called the scene is ready for rendering it as an image
      */
@@ -3657,7 +4180,7 @@ export declare interface GlueLogic {
     duplicateGroup(duplicatedGroup: ExternalObjectGroup): Promise<void>;
     adjustGroup(groupId: string): Promise<void>;
     swapRootModule(groupId: string, rootModuleId: string, articleId: string): Promise<void>;
-    modifyAttribute(groupId: string, moduleIdObjects: ExternalModuleInformation_2[], attributeName: string, value: string): Promise<void>;
+    modifyAttribute(groupId: string, moduleIdObjects: ExternalModuleInformation_3[], attributeName: string, value: string): Promise<void>;
     updateAttribute(rootModuleId: string, moduleId: string | null, attributeId: string, attributeValue: string | boolean): Promise<void>;
     getVerifiedAttributeOptions(moduleId: string, attributeIds?: string | string[]): Promise<Record<string, CheckDropDownResult> | undefined>;
     getVerifiedGroupAttributeOptions(groupId: string, attributeIds?: string | string[]): Promise<Record<string, CheckDropDownResult> | undefined>;
@@ -3693,22 +4216,22 @@ export declare interface HandWrittenPlanInteractionHandler {
     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;
+    loadPlanXML(xml: string): Plan_3;
+    createPlanWithObjectFromItem(object: KernelObject, position: KernelVector3, rotationInRad: number): Plan_3;
+    getPlan(): Plan_3;
     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;
+    setElementVisibility(element: PlanElement_3, 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;
+    addOrUpdateExternalPlanObjects(serializedConfiguration: string | string[], position: KernelVector3, rotationInRad: number, updateConfiguration: ExternalObjectLoadConfiguration_2, mergedGroupIds: string | string[]): PlanObject[];
+    createPreviewGeometryForAddOn(objectId: string, objectConfiguration: string, articleId: string, groupDefinitions: string, validContainerModules: ExternalValidContainerModule_2[]): void;
     catalogItemLoaded(catalogItem: KernelCatalogItem): void;
     removeElement(planObject: KernelObject): void;
     removeObjectWithId(objectId: string): void;
@@ -3777,14 +4300,14 @@ export declare interface HandWrittenPlanInteractionHandler {
     setDefaultInteriorWallMaterial(wallMaterial: KernelWallMaterial): void;
     getDefaultFloorMaterial(): KernelFloorMaterial;
     setDefaultFloorMaterial(floorMaterial: KernelFloorMaterial): void;
-    setElementCustomDataJson(element: PlanElement_2, customDataJson: string): void;
+    setElementCustomDataJson(element: PlanElement_3, 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;
+    setFloorType(floor: KernelFloor, floorType: FloorType_2): void;
+    setEdgeType(wall: KernelWall, edgeType: EdgeType_2): void;
+    getContinuousDrawingManager(): ContinuousDrawingManager_2;
     setSnapFeedbackWhileDrawing(enabled: boolean): void;
     consistsOfMergedComponents(object: KernelObject): boolean;
     setObjectSize(anObject: KernelObject, aNewSize: KernelVector3, anAnchor: Anchor): void;
@@ -3793,9 +4316,9 @@ export declare interface HandWrittenPlanInteractionHandler {
     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;
+    setMeasurePoint1(measure: PlanMeasure_3, point: KernelVector3f, snapToWalls: boolean, snapToObjects: boolean): void;
+    setMeasurePoint2(measure: PlanMeasure_3, point: KernelVector3f, snapToWalls: boolean, snapToObjects: boolean): void;
+    addMeasure(startPosition: KernelVector3f, endPosition: KernelVector3f): PlanMeasure_3;
     setDiscardExternalObjectsOnLoad(discard: boolean): void;
     isChildObjectModePossible(object: KernelObject): boolean;
     isEnabledChildObjectMode(object: KernelObject): boolean;
@@ -3810,8 +4333,8 @@ export declare interface HandWrittenPlanInteractionHandler {
     customRaster: number;
     enableSnap: boolean;
     enableDrawingSnap: boolean;
-    objectToWallSnapMode: SnapMode;
-    objectToObjectSnapMode: SnapMode;
+    objectToWallSnapMode: SnapMode_2;
+    objectToObjectSnapMode: SnapMode_2;
     dockWhenSnap: boolean;
     unDockOnMove: boolean;
     enableTerrain: boolean;
@@ -3866,6 +4389,12 @@ export declare const HI_LOAD_OBJECT_REASON: {
     readonly UNDO_REDO: "undo_redo";
 };
 
+export declare const HI_PANEL_ACTION: {
+    readonly HIDE: "hide";
+    readonly SHOW_ATTRIBUTES: "attributes";
+    readonly SHOW_ARTICLES: "articles";
+};
+
 export declare interface HiApiOptions extends HomagIntelligenceSubscription {
     om?: HomagIntelligenceSubscription;
     baseUrl?: string;
@@ -3876,6 +4405,91 @@ export declare interface HiApiOptions extends HomagIntelligenceSubscription {
 
 export declare type HiAttributeOptionsResult = CheckDropDownResult | CheckDropDownEntry[] | undefined;
 
+export declare interface HiCallbacks {
+    /**
+     * Requests the calculation script for the given library ID.
+     * @param libraryId the ID of the library for which the calculation script is requested
+     * @returns the calculation script as a string
+     */
+    onLoadJavascript: (libraryId: string) => Promise<string>;
+    /**
+     * Requests the master data for the given library ID.
+     * @param libraryId the ID of the library for which the master data is requested
+     * @returns the master data as a Promise
+     */
+    onLoadMasterData: (libraryId: string) => Promise<MasterData>;
+    /**
+     * Requests the article catalog for the given library ID.
+     * @param libraryId the ID of the library for which the article catalog is requested
+     * @returns the article catalog as a Promise
+     */
+    onLoadArticleCatalog: (libraryId: string) => Promise<any>;
+    /**
+     * Notifies the host application that a price calculation should be performed.
+     * @param posGroups all groups in the plan
+     */
+    onPriceCalc?: (posGroups: PosGroup[]) => Promise<void>;
+    /**
+     * Retrieves the current external load data which has to be used to replace the existing groups in the plan.
+     * @returns load data or null if no replacement is needed
+     */
+    onGetSavedPosGroupData?: () => Promise<PosSaveData | null>;
+    /**
+     * "onCompletelyLoaded" is invoked when the groups in the plan are completely loaded.
+     */
+    onPosGroupsCompletelyLoaded?: () => void;
+    /**
+     * "onPosGroupAdded" is invoked when a new group was created. (e.g. duplicate object)
+     * @param groupData The new group data JSON.
+     */
+    onPosGroupAdded?: (posGroups: PosGroup[]) => Promise<void>;
+    /**
+     * "onPosGroupChanged" is invoked when a new group was modified and recalculated. (e.g. split, merge, change, attribute)
+     *
+     * @param groupData The new group data JSON.
+     */
+    onPosGroupChanged?: (posGroups: PosGroup[]) => Promise<void>;
+    /**
+     * "onPosGroupDeleted" is invoked when a group was delete. (e.g. delete button in scene)
+     * @param groupData The ID of the group which was deleted.
+     */
+    onPosGroupDeleted?: (posGroupIds: string[]) => Promise<void>;
+    /**
+     * "onShowHidePanel" is invoked when a the content of the side panel should be changed or hidden.
+     * @param panel The panel to show or hide.
+     * @param posGroupId Optional ID of the selected group in case of SHOW_ATTRIBUTES.
+     * @param rootModuleId Optional ID of the selected root module in case of SHOW_ATTRIBUTES.
+     * @param subModuleId Optional ID of the selected sub module in case of SHOW_ATTRIBUTES.
+     */
+    onShowHidePanel?: (panel: HiPanelActionType, posGroupId?: string | null, rootModuleId?: string | null, subModuleId?: string | null) => void;
+    /**
+     * "onSelectModule" is invoked when a the selected object in the scene was changed.
+     * @param posGroupId ID of the selected group
+     * @param rootModuleId ID of the selected root module
+     * @param subModuleId Optional id of the selected sub module
+     */
+    onSelectModule?: (posGroupId: string | null, rootModuleId: string | null, subModuleId?: string | null) => void;
+    /**
+     * Request the price for the given order data.
+     * @param orderData order data
+     * @returns price data
+     */
+    onFetchPrice?: (orderData: HiOrder) => Promise<HiPriceData | null>;
+    /**
+     * "onPlaceOrder" is invoked when the user wants to place an order.
+     * You can use this to send the order data to Order Manager or to a 3rd party service.
+     * @param orderData
+     */
+    onPlaceOrder?: (orderData: any) => Promise<void>;
+    /**
+     * "onLogMessage" is invoked when the Homag Intelligence library wants to log a message.
+     * You can use this to log messages in your own UI.
+     * @param area
+     * @param message
+     */
+    onLogMessage?: (area: string, message: string) => void;
+}
+
 export declare type HiContextAction = (typeof HI_CONTEXT_ACTION)[keyof typeof HI_CONTEXT_ACTION];
 
 /**
@@ -3910,6 +4524,42 @@ export declare interface HiObjectSelectionApi {
     selectionChanged(selectionMode: SELECTION_MODE, objectType: CallbackObjectType, payload: SelectionPayload, _payloadPromise: Promise<SelectionPayload>, _planElementViewModel: PlanElementViewModel): void;
 }
 
+export declare interface HiOrder extends HiOrderHeader {
+    items: HiOrderData[];
+}
+
+export declare interface HiOrderData {
+    [key: string]: any;
+    additionalData: Array<Record<string, any>>;
+}
+
+export declare interface HiOrderHeader {
+    id: string;
+    state: string;
+    orderNumber: string;
+    orderName: string;
+    orderDescription: string;
+    project: string;
+    personInCharge: string;
+    orderDate: string;
+    deliveryDatePlanned: string;
+    addresses: Array<{
+        type: string;
+        street: string;
+        houseNumber: string;
+        postalCode: string;
+        city: string;
+        country: string;
+    }>;
+    customerName: string;
+    customerNumber: string;
+    createdAt: string;
+    changedAt: string;
+    changedBy: string;
+}
+
+export declare type HiPanelActionType = (typeof HI_PANEL_ACTION)[keyof typeof HI_PANEL_ACTION];
+
 export declare interface HiPlanContext {
     masterData?: Record<string, MasterData>;
     rooms?: ExternalRoomInformation;
@@ -3919,6 +4569,11 @@ export declare interface HiPlanContext {
 
 export declare type HiPlanContextSection = 'masterData' | 'rooms' | 'articles' | 'groups';
 
+export declare interface HiPriceData {
+    [key: string]: any;
+    orderData: HiOrder;
+}
+
 export declare class HiTagCatalogCallbacks implements Context {
     _creator_: string;
     private _glueLogic;
@@ -4091,7 +4746,7 @@ export declare class InitData implements Context, Omit<InitDataDefinition, 'colo
     precisionCm?: number;
     unit?: string;
     unitStringType?: string;
-    measurementSystem?: Enumify_3<typeof MEASUREMENT_SYSTEM_STRING>;
+    measurementSystem?: Enumify<typeof MEASUREMENT_SYSTEM_STRING>;
     meshSelection: boolean;
     stats: boolean;
     debug: boolean;
@@ -4113,7 +4768,7 @@ export declare class InitData implements Context, Omit<InitDataDefinition, 'colo
     restrictionLevel: number;
     hi?: HomagIntelligenceInitData;
     disableDefaultLabelStyles: boolean;
-    highlighting: Enumify_3<typeof ROOMLE_HIGHLIGHTNG>;
+    highlighting: Enumify<typeof ROOMLE_HIGHLIGHTNG>;
     initialFloorMaterial?: string;
     dls?: string;
     ls?: string;
@@ -4141,7 +4796,7 @@ export declare class InitData implements Context, Omit<InitDataDefinition, 'colo
     webGpuConfig: WebGpuConfig;
     meshRaycasting: boolean;
     defaultFloorMaterial?: number | string;
-    mode: Enumify_3<typeof CAMERA_TYPE>;
+    mode: Enumify<typeof CAMERA_TYPE>;
     edit: boolean;
     moc: boolean;
     lockPlan: boolean;
@@ -4305,7 +4960,9 @@ export declare interface InsertItemResult {
 export declare class IntArray extends EmsArray<number> {
 }
 
-export declare class IntArray_2 extends EmsArray<number> {
+export declare type IntArray_2 = EmscriptenArray<number>;
+
+export declare class IntArray_3 extends EmsArray<number> {
 }
 
 export declare type InteractionMethodName = Exclude<keyof PlanInteractionManager, keyof UndoRedoHandler>;
@@ -4319,24 +4976,115 @@ export declare const enum INTERSECTION_MODE {
     CONFIGURATOR = 1
 }
 
-export declare const isExternalObject: (someThing: unknown) => someThing is ExternalObject;
-
-export declare const isExtObjId: (id: unknown) => id is ExtObjId_2;
-
-export declare const isFirefox: () => boolean;
-
-export { isIdAComponent }
-
-export { isIdAConfigurationString }
-
-export { isIdAnItem }
-
-export { isIdAPlan }
-
-export { isPlanSnapshotId }
-
-export declare const isSafari: () => boolean;
-
+export declare const isExternalObject: (someThing: unknown) => someThing is ExternalObject;
+
+export declare const isExtObjId: (id: unknown) => id is ExtObjId;
+
+export declare const isFirefox: () => boolean;
+
+export declare const isIdAComponent: (id: string) => boolean;
+
+export declare const isIdAConfigurationString: (id: string) => boolean;
+
+export declare const isIdAnItem: (id: string) => boolean;
+
+export declare const isIdAPlan: (id: string) => boolean;
+
+export declare const isPlanSnapshotId: (id: string | RapiId) => id is RapiPlanSnapshotId;
+
+export declare const isSafari: () => boolean;
+
+export declare interface Kernel {
+    new (): Kernel;
+    setUpdateCallbacksOnlyIfGeometryIsReady(onlyUpdateIfReady: boolean): void;
+    setLevel(level: number): void;
+    useHDGeometry(shouldUse: boolean): void;
+    useEnvironmentGeometry(shouldUse: boolean): void;
+    setDockInsertPreviewBoxParameters(thickness: number, protruding: number, intruding: number, bevelSize: number): void;
+    setLogLevel(level: number): void;
+    loadConfiguration(conversationId: number, serializedConfiguration: string, bounding: Vector3): void;
+    updateConfiguration(conversationId: number, objectOrComponentId: number, serializedConfiguration: string): void;
+    loadFreeFlyingConfiguration(conversationId: number, serializedConfiguration: string): void;
+    loadComponentDefinition(serializedComponent: string): void;
+    requestComponentDockPreview(targetObjectId: number, componentId: string, serializedComponent: string, dragIn: boolean, allowInsertInBetween: boolean): void;
+    requestItemDockPreview(targetObjectId: number, serializedConfiguration: string, dragIn: boolean, allowInsertInBetween: boolean): void;
+    requestExternalObjectDockPreview(targetObjectId: number, articleId: string, dragIn: boolean, allowInsertInBetween: boolean): void;
+    assetsLoaded(assets: AssetResponse_2 | AssetResponse_2[]): void;
+    loadPlainComponent(conversationId: number, componentId: string, serializedComponent: string): void;
+    saveConfiguration(planObjectId: number): void;
+    getComponent(planComponentId: number): Component;
+    getComponentBounds(componentId: number, animationValues: string[]): ComponentBounds;
+    getComponentParameters(planComponentId: number): ParameterArray_2;
+    getPlanComponentAnimations(planComponentId: number): AnimationArray;
+    setComponentParameter(planComponentId: number, key: string, value: string): void;
+    getCommonPlanComponentParameters(somePlanComponentIds: LongArray): ParametersAndParameterGroups;
+    setPlanComponentsParameter(somePlanComponentIds: LongArray, key: string, value: string): void;
+    dockComponent(id: number, dockId: number, parentId: number, parentDockId: number, position?: Vector3): void;
+    dockComponentWithPosition(id: number, dockId: number, parentId: number, parentDockId: number, position: Vector3): void;
+    determinePlanComponentsThatWillBeDeleted(planComponentId: number, tryDockChildrenToParent: boolean): LongArray;
+    deleteComponent(planComponentId: number, redockChildrenToParent: boolean): void;
+    deleteMultipleComponents(somePlanComponentIds: LongArray): void;
+    prepareForIncrementalUpdate(): void;
+    doNextIncrementalUpdate(): void;
+    getPartList(planComponentId: number): PartList;
+    getPlanObjectPartList(planObjectId: number): PartList;
+    getFullPartList(): PartList;
+    isConfigurationValid(planObjectOrComponentId: number): boolean;
+    retrieveConfigurationId(planObjectOrComponentId: number): UniqueIdAndHash;
+    getHashOfSerializedConfiguration(serializedConfiguration: string): string;
+    getSerializedConfiguration(planObjectOrComponentId: number): string;
+    createNewSerializedConfiguration(planObjectOrComponentId: number): string;
+    clearScene(): void;
+    clearAll(): void;
+    reset(): void;
+    getEnvironmentVariables(): void;
+    getEnvironmentVariable(key: string): void;
+    setEnvironmentVariable(key: string, value: string): void;
+    getPlannedObjects(): void;
+    getPlanObjectParameters(planObjectId: number): ParameterArray_2;
+    getCommonPlanObjectParameters(planObjectIds: LongArray): ParameterArray_2;
+    getPlanObjectAnimations(planObjectId: number): AnimationArray;
+    getPlanViews(planObjectId: number): ConfigurationPlanViewArray;
+    setPlanObjectParameter(planObjectId: number, key: string, value: string): void;
+    setPlanObjectsParameter(somePlanObjectIds: LongArray, key: string, value: string): void;
+    deletePlanObject(planObjectId: number): void;
+    isExternalPlanObject(objectOrPlanComponentId: number): boolean;
+    getComponentOrModuleInformation(objectOrPlanComponentId: number): ObjectInformation;
+    getExternalObjectAttribute(objectOrPlanComponentId: number, attributeId: string, value: string): ExternalAttributeInformation_2;
+    getPlanObject(planObjectId: number): PlanObject_3;
+    getPlanObjectFromPlanComponent(planComponentId: number): PlanObject_3;
+    getRootPlanComponentIdFromObjectId(planObjectId: number): number;
+    getGlobalParameterValue(objectOrComponentId: number, name: string): string;
+    getRuntimeIdOfRootComponent(objectOrComponentId: number): number;
+    getRuntimeIdsOfChildComponents(objectOrComponentId: number): LongArray;
+    getComponentParameterValue(objectOrComponentId: number, name: string): string;
+    getComponentId(objectOrPlanComponentId: number): string;
+    getCurrencySymbol(planComponentId: number): string;
+    getPrice(planComponentId: number): number;
+    addPriceList(priceListId: string): void;
+    resetPriceListIds(): void;
+    requestPlanObjectConstruction(planComponentId: number): void;
+    requestMergedPlanObjectConstruction(planComponentId: number): void;
+    requestPlanComponentConstruction(planComponentId: number): boolean;
+    requestDeltaPlanComponentConstruction(planComponentId: number): boolean;
+    requestPlanComponentConstructionRecursive(planComponentId: number): void;
+    requestPreviewGeometry(dockingObjectOrComponentId: number, targetObjectRuntimeId: number, allowInsertInBetween: boolean): void;
+    cancelDocking(planComponentOrPlanObjectId: number, undoDrag: boolean): void;
+    setActiveGroupInView(activeGroup: string): void;
+    setActiveGroupInViewForPlanObject(activeGroup: string, planObjectOrComponentId: number): void;
+    getPlanObjectPossibleChildren(planObjectId: number): PossibleChildArray_2;
+    getChildrenOfPlanObject(planObjectId: number, onlyPossibleChildren: boolean, onlyVisibleChildren: boolean): PossibleChildArray_2;
+    getPlanComponentPossibleChildren(planComponentId: number): PossibleChildArray_2;
+    getChildrenOfPlanComponent(planComponentId: number, onlyPossibleChildren: boolean, onlyVisibleChildren: boolean): PossibleChildArray_2;
+    syncPlanObjectToView(conversationId: number, planObjectId: number): void;
+    getAddOnSpotsForPlanObject(planObjectId: number): AddOnSpotArray_2;
+    setExternalMeshInvalid(assetType: AssetType_2, idOrUrl: string, quality: number): void;
+    setAssetInvalid(assetType: AssetType_2, idOrUrl: string, quality: number): void;
+    loadExternalAttributeDefinition(serializedDefinition: string): void;
+    setExternalObjectConstructionProperties(serializedProperties: string): void;
+    registerDebugClient(debugClient: DebugClient_2): void;
+}
+
 export declare const KERNEL_MESSAGE_TYPE: {
     readonly EXCEPTION: "exception";
     readonly ERROR: "error";
@@ -4387,9 +5135,9 @@ export declare interface KernelAttic extends KernelObject {
     getFrom(): NodePlanObject;
     getTo(): NodePlanObject;
     getAssociatedWall(): KernelWall;
-    get2dPolygon(): PointArray_2;
-    getRidgePoints(): PointArray_2;
-    getPointsWithHeight(height: number): PointArray_2;
+    get2dPolygon(): PointArray_3;
+    getRidgePoints(): PointArray_3;
+    getPointsWithHeight(height: number): PointArray_3;
     readonly side: WallSide;
     readonly kneeHeight: number;
     readonly width: number;
@@ -4522,7 +5270,7 @@ export declare interface KernelFloor extends KernelObject {
     area: number;
     material: KernelFloorMaterial;
     readonly parapetHeight: number;
-    readonly floorType: FloorType;
+    readonly floorType: FloorType_2;
     getCenter: () => KernelVector3;
     getRandomPointInside: () => KernelVector3;
     getLabelPosition: () => KernelVector3;
@@ -4852,7 +5600,7 @@ export declare interface KernelWall extends KernelObject {
     readonly wallType: KernelEnum;
     readonly leftNormal: KernelVector3;
     readonly rightNormal: KernelVector3;
-    readonly edgeType: EdgeType;
+    readonly edgeType: EdgeType_2;
     getAngle: () => number;
 }
 
@@ -4950,6 +5698,15 @@ export declare interface LightSourceConfiguration {
     maximumNumberOfLightSources: number;
 }
 
+export declare interface Line {
+    angle: number;
+    endPoint: Vector3;
+    length: number;
+    startPoint: Vector3;
+}
+
+export declare type LineArray = EmscriptenArray<Line>;
+
 export declare interface LinksCollection {
     [key: string]: string;
 }
@@ -4993,7 +5750,9 @@ export declare interface LogMessageScope {
     attrId?: string;
 }
 
-export declare class LongArray extends EmsArray<number> {
+export declare type LongArray = EmscriptenArray<number>;
+
+export declare class LongArray_2 extends EmsArray<number> {
 }
 
 export declare const enum MAIL_TYPE {
@@ -5054,6 +5813,10 @@ export declare const enum MaterialSourceType {
     RgbValue = 3
 }
 
+export declare interface MaterialSourceType_2 {
+    value: Enumify_2<typeof CORE_MATERIAL_SOURCE_TYPE>;
+}
+
 export declare class MaterialViewer extends Main {
     private _viewer;
     protected setupGlobals(): void;
@@ -5065,6 +5828,10 @@ export declare class MaterialViewer extends Main {
     protected getContextName(): string;
 }
 
+export declare interface Matrix4 {
+    m: number[];
+}
+
 export declare type MaybePromise<T> = (() => T) | (() => Promise<T>);
 
 export declare type MDAttributeInfo = MDBoolAttributeInfo | MDTextAttributeInfo | MDIntegerAttributeInfo | MDRealAttributeInfo | MDDimAttributeInfo;
@@ -5148,7 +5915,7 @@ export declare const MEASUREMENT_SYSTEM_STRING: {
     METRIC: string;
 };
 
-export declare interface MeasurementBase<Vector2Type = Vector3 | Position2, Vector3Type = Vector3 | Position3> {
+export declare interface MeasurementBase<Vector2Type = Vector3_2 | Position2, Vector3Type = Vector3_2 | Position3> {
     /**  start position of the dimension in 3D **/
     fromPosition3d: Vector3Type;
     /**  end position of the dimension in 3D **/
@@ -5173,7 +5940,7 @@ export declare interface MeasurementBase<Vector2Type = Vector3 | Position2, Vect
     dashed?: boolean;
 }
 
-export declare type MeasurementLineDimension = DimensionDefinition<Vector3, Vector3>;
+export declare type MeasurementLineDimension = DimensionDefinition<Vector3_2, Vector3_2>;
 
 export declare type MeasurementLineDimensionTransferable = DimensionDefinition<Position2, Position3>;
 
@@ -5322,6 +6089,13 @@ export declare abstract class Node_2 extends PlanElement {
     getMaxWallHeight(): number;
 }
 
+export declare interface Node_3 extends PlanElement_2 {
+    new (): Node_3;
+    getNumberOfConnectedWalls(): number;
+    getMaxWallHeight(): number;
+    readonly nodeType: NodeType_2;
+}
+
 export declare interface NodeDimensionTransferable {
     id: number;
     position2d: Position2;
@@ -5337,7 +6111,7 @@ export declare class NodePlanElementViewModel extends PlanElementViewModel {
     update(): void;
     setFenceEnabled(enabled: boolean): void;
     setTopView(enabled: boolean): void;
-    getSize(): Vector3;
+    getSize(): Vector3_2;
     show(): void;
     hide(): void;
     protected getSelectionRingColor(): number;
@@ -5366,7 +6140,11 @@ export declare interface NodeType {
     value: Enumify<typeof CORE_NODE_TYPE>;
 }
 
-export { Nullable }
+export declare interface NodeType_2 {
+    value: Enumify_2<typeof CORE_NODE_TYPE_2>;
+}
+
+export declare type Nullable<T> = T | null;
 
 export declare interface Object3DRoomleEventMap extends Object3DEventMap {
     [OBJECT_EVENT.CLICK]: {
@@ -5377,7 +6155,7 @@ export declare interface Object3DRoomleEventMap extends Object3DEventMap {
     };
     [OBJECT_EVENT.DRAG]: {
         attachment: {
-            position: Vector3;
+            position: Vector3_2;
         };
     };
     [OBJECT_EVENT.DRAG_END]: {
@@ -5416,6 +6194,13 @@ export declare const enum OBJECT_EVENT {
     ROTATE = "rotate"
 }
 
+export declare interface ObjectBounds {
+    boundingBox: Box;
+    rectangleBox: ExtrudedRectangle;
+}
+
+export declare type ObjectBoundsArray = EmscriptenArray<ObjectBounds>;
+
 export declare interface ObjectCategory {
     value: Enumify<typeof CORE_OBJECT_CATEGORY>;
 }
@@ -5425,6 +6210,12 @@ export declare interface ObjectConfigurationType {
 }
 
 export declare interface ObjectFrontRotation {
+    lookAtSide: WallSide_2;
+    rotation: number;
+    rotationRoundTo90deg: number;
+}
+
+export declare interface ObjectFrontRotation_2 {
     lookAtSide: WallSide;
     rotation: number;
     rotationRoundTo90deg: number;
@@ -5434,9 +6225,29 @@ export declare abstract class ObjectGroup extends PlanElement {
     getObjects(): PlanObjectPtr;
 }
 
+export declare interface ObjectGroup_2 extends PlanElement_2 {
+    new (): ObjectGroup_2;
+    getGroupId(): number;
+    getObjects(): PlanObjectPtrList_2;
+}
+
 export declare interface ObjectGroupPtr {
 }
 
+export declare interface ObjectInformation {
+    componentId: string;
+    configurationRuntimeId: number;
+    entityRuntimeId: number;
+    externalModule: ExternalModuleInformation_2;
+    isAGeneratedModule: boolean;
+    name: string;
+    permissionToDelete: PermissionToDelete;
+    permissionToDeleteInIsolation: PermissionToDelete;
+    runtimeId: number;
+    source: string;
+    type: PlanComponentType;
+}
+
 export declare interface ObjectMeasurements {
     rectMeasurements: ObjectWallDimension[];
     objectMeasurements: ObjectWallDimension[];
@@ -5466,13 +6277,21 @@ export declare interface ObjectToWallLine {
 export declare class ObjectToWallLineArray extends EmsArray<ObjectToWallLine> {
 }
 
-export declare type ObjectWallDimension = DimensionDefinition<Vector3, Vector3>;
+export declare interface ObjectTypeCategory {
+    value: Enumify_2<typeof CORE_OBJECT_TYPE_CATEGORY>;
+}
+
+export declare type ObjectWallDimension = DimensionDefinition<Vector3_2, Vector3_2>;
 
 export declare interface OffsetCamera {
     offset: CanvasOffset;
     resetOffset(): void;
 }
 
+export declare interface OpeningDirection {
+    value: Enumify_2<typeof CORE_OPENING_DIRECTION>;
+}
+
 export declare interface OrthographicOffsetCamera extends OrthographicCamera, OffsetCamera {
 }
 
@@ -5486,6 +6305,26 @@ export declare interface OutlineCustomParameters {
     outlineHiddenEdgeColor: ColorRepresentation;
 }
 
+export declare interface Parameter {
+    enabled: boolean;
+    group: string;
+    highlighted: boolean;
+    key: string;
+    label: string;
+    objectIds: IntArray_2;
+    sort: number;
+    source: string;
+    type: ParameterTypeString;
+    unitType: UnitTypeString;
+    validGroups: string[];
+    validRange: Range_2;
+    validValues: ParameterValue[];
+    value: string;
+    valuesAreEqual: boolean;
+    viewType: ViewType;
+    visibleInPlanner: boolean;
+}
+
 export declare const enum PARAMETER_KERNEL_TYPE {
     UNKNOWN = "",
     INTEGER = "Integer",
@@ -5525,7 +6364,16 @@ export declare const PARAMETER_VIEW_TYPE: {
 export declare class ParameterArray extends EmsArray<KernelParameter> {
 }
 
-export declare class ParameterArray_2 extends EmsArray<KernelParameter> {
+export declare type ParameterArray_2 = EmscriptenArray<Parameter>;
+
+export declare class ParameterArray_3 extends EmsArray<KernelParameter> {
+}
+
+export declare interface ParameterGroup {
+    collapsed: boolean;
+    key: string;
+    label: string;
+    sort: number;
 }
 
 export declare class ParameterGroupArray extends EmsArray<KernelParameterGroup> {
@@ -5534,6 +6382,20 @@ export declare class ParameterGroupArray extends EmsArray<KernelParameterGroup>
 export declare class ParameterGroupArray_2 extends EmsArray<KernelParameterGroup> {
 }
 
+export declare interface ParametersAndParameterGroups {
+    animations: Animation_2[];
+    parameterGroups: ParameterGroup[];
+    parameters: Parameter[];
+}
+
+export declare type ParameterTypeString = Enumify_3<typeof CORE_PARAMETER_TYPE_STRING>;
+
+export declare interface ParameterValue {
+    label: string;
+    thumbnail: string;
+    value: string;
+}
+
 export declare class ParameterValueArray extends EmsArray<KernelParameterValue> {
 }
 
@@ -5551,18 +6413,59 @@ export declare interface ParamterKeyValue {
     parameterValue: string;
 }
 
+export declare interface Part {
+    articleNr: string;
+    componentId: string;
+    componentRuntimeIds: number[];
+    count: number;
+    currencySymbol: string;
+    hasGeometry: boolean;
+    isModule: boolean;
+    label: string;
+    labelIsCalculated: boolean;
+    packageSize: number;
+    parameters: PartListParameter[];
+    permissionToDelete: PermissionToDelete;
+    permissionToDeleteInIsolation: PermissionToDelete;
+    price: number;
+    retailerPrice: number;
+    subpartId: number;
+    valid: boolean;
+}
+
 export declare class PartArray extends EmsArray<KernelPart> {
 }
 
 export declare class PartArray_2 extends EmsArray<KernelPart> {
 }
 
+export declare interface PartList {
+    fullList: Part[];
+    originPart: Part;
+    perMainComponent: PartList[];
+}
+
+export declare interface PartListParameter {
+    key: string;
+    label: string;
+    sort: number;
+    type: string;
+    unitType: string;
+    value: string;
+    valueLabel: string;
+    valueThumbnail: string;
+}
+
 export declare class PartListParameterArray extends EmsArray<KernelPartListParameter> {
 }
 
 export declare class PartListParameterArray_2 extends EmsArray<KernelPartListParameter> {
 }
 
+export declare interface PermissionToDelete {
+    value: Enumify_3<typeof CORE_PERMISSION_TO_DELETE_2>;
+}
+
 export declare interface PerspectiveOffsetCamera extends PerspectiveCamera, OffsetCamera {
 }
 
@@ -5586,7 +6489,32 @@ export declare abstract class Plan extends AbstractModelWrapper {
     syncToView(): void;
 }
 
-export declare interface Plan_2 extends KernelObject {
+export declare interface Plan_2 extends AbstractModel_2 {
+    new (): Plan_2;
+    increaseLockLevels(): void;
+    getPlanXML(includeRuntimeId: boolean, version: number): string;
+    getPlanXMLWithNormalizedLockLevels(includeRuntimeId: boolean, version: number): string;
+    createPlanXmlWithSingleObject(object: PlanObject_2, includeRuntimeId: boolean, version: number): string;
+    createPlanXmlWithObjects(objectIds: string | string[], includeRuntimeId: boolean, version: number): string;
+    getRotationForFrontView(objectIds: number | number[]): number;
+    getBounds(): Box;
+    getPlanObjects(): PlanObject_2[];
+    getWalls(): Wall_2[];
+    getWallCount(): number;
+    getAttics(): Attic[];
+    getFloors(): Floor_2[];
+    getImageCount(): number;
+    isEmpty(): boolean;
+    getTotalFloorArea(): number;
+    syncPlanToView(): void;
+    defaultParapetHeight: number;
+    defaultWallColor: number;
+    defaultWallHeight: number;
+    defaultWallThickness: number;
+    vectorWallThickness: number;
+}
+
+export declare interface Plan_3 extends KernelObject {
     defaultParapetHeight: number;
     defaultWallHeight: number;
     defaultWallThickness: number;
@@ -5615,6 +6543,10 @@ export declare const PLAN_ROOM_GEOMETRY_MODE: {
     readonly PLAN: "plan";
 };
 
+export declare interface PlanComponentType {
+    value: Enumify_3<typeof CORE_PLAN_COMPONENT_TYPE_2>;
+}
+
 export declare abstract class PlanElement extends AbstractModelWrapper {
     isLocked: boolean;
     isValid: boolean;
@@ -5622,7 +6554,22 @@ export declare abstract class PlanElement extends AbstractModelWrapper {
     getCenter(): KernelVector3f;
 }
 
-export declare interface PlanElement_2 extends KernelObject {
+export declare interface PlanElement_2 extends AbstractModel_2 {
+    new (): PlanElement_2;
+    getType(): PlanElementType_2;
+    getCenter(): Vector3;
+    getRootComponentCenter(): Vector3;
+    getMeshCenter(): Vector3;
+    getMeshOffsetRelativeToObject(): Vector3;
+    getCustomDataJson(): string;
+    isDuplicable(): boolean;
+    isDeletableInIsolation(): boolean;
+    isLocked(): boolean;
+    isValid(): boolean;
+    readonly hidden: boolean;
+}
+
+export declare interface PlanElement_3 extends KernelObject {
     getType(): any;
     getCenter(): KernelVector3;
     getMeshCenter(): KernelVector3;
@@ -5645,6 +6592,10 @@ export declare const enum PlanElementType {
     CEILING = 7
 }
 
+export declare interface PlanElementType_2 {
+    value: Enumify_2<typeof CORE_PLAN_ELEMENT_TYPE>;
+}
+
 export declare class PlanElementViewModel extends KernelViewModel {
     protected _container: Object3D;
     protected _boundingBox: RoomleEventedMesh;
@@ -5656,7 +6607,7 @@ export declare class PlanElementViewModel extends KernelViewModel {
     private _containerVisible;
     private _hiddenByCameraFacing;
     constructor(planObject: PlanObject);
-    getSize(): Vector3;
+    getSize(): Vector3_2;
     setHiddenByCameraFacing(hidden: boolean): void;
     setContainerVisibility(isVisible: boolean): void;
     protected isContainerVisible(): boolean;
@@ -5664,7 +6615,7 @@ export declare class PlanElementViewModel extends KernelViewModel {
     isHiddenByCameraFacing(): boolean;
     update(): void;
     protected _updateBoundingBox(): void;
-    getPosition(): Vector3;
+    getPosition(): Vector3_2;
     getRotation(): number;
     getBounds(): Box3;
     getMeasurementBounds(): Box3[];
@@ -5683,7 +6634,7 @@ export declare class PlanElementViewModel extends KernelViewModel {
     remove(): void;
     hidePreviewBox(): void;
     protected _generateBoundingBox(): RoomleEventedMesh;
-    protected _setPositionOfBoundingBox(size: Vector3, mesh: RoomleEventedMesh): void;
+    protected _setPositionOfBoundingBox(size: Vector3_2, mesh: RoomleEventedMesh): void;
     get isSelected(): boolean;
     select(): void;
     deselect(): void;
@@ -5703,8 +6654,163 @@ export declare abstract class PlanImage extends PlanElement {
     center: KernelVector3f;
 }
 
+export declare interface PlanImage_2 extends PlanElement_2 {
+    new (): PlanImage_2;
+    readonly url: string;
+    readonly size: Vector3;
+    readonly rotation: Vector3;
+    readonly center: Vector3;
+}
+
 export declare type PlanInteractionHandler = Omit<PlanInteractionHandler_2, keyof HandWrittenPlanInteractionHandler> & HandWrittenPlanInteractionHandler;
 
+export declare interface PlanInteractionHandler_2 {
+    new (): PlanInteractionHandler_2;
+    init(reference: PlanInteractionHandler_2, zoomFactor: number, viewSnapDist: number, wallSnapMode: SnapMode, objectSnapMode: SnapMode, shouldSnap: boolean, drawingType: DrawingType_2): void;
+    loadPlanXML(planXml: string): Plan_2;
+    createPlanWithObjectFromItem(item: CatalogItem_2, position: Vector3, rotationInRad: number): Plan_2;
+    setDefaultParapetHeight(parapetHeight: number, applyToAll: boolean): void;
+    setRoomParapetHeight(floor: Floor_2, parapetHeight: number): void;
+    setDefaultWallColor(wallColor: number, applyToAll: boolean): void;
+    setDefaultWallHeight(wallHeight: number, applyToAll: boolean): void;
+    setDefaultWallThickness(wallThickness: number, applyToAll: boolean): void;
+    getDefaultExteriorWallMaterial(): WallMaterial_2;
+    setDefaultExteriorWallMaterial(wallMaterial: WallMaterial_2): void;
+    getDefaultInteriorWallMaterial(): WallMaterial_2;
+    setDefaultInteriorWallMaterial(wallMaterial: WallMaterial_2): void;
+    getDefaultFloorMaterial(): FloorMaterial_2;
+    setDefaultFloorMaterial(floorMaterial: FloorMaterial_2): void;
+    moveElementBy(element: PlanElement_2, offset: Vector3, dragging: boolean): void;
+    moveElementTo(element: PlanElement_2, position: Vector3, dragging: boolean, cameraPosition?: Vector3): void;
+    moveElementToIn2d(element: PlanElement_2, position: Vector3, dragging: boolean): void;
+    setDiscardExternalObjectsOnLoad(discard: boolean): void;
+    moveObjectsBy(objects: PlanObjectPtrList_2, offset: Vector3): void;
+    removeChildObjectAtPosition(element: PlanElement_2, position: Vector3): boolean;
+    lockElement(element: PlanElement_2): void;
+    unlockElement(element: PlanElement_2): void;
+    consistsOfMergedComponents(object: PlanObject_2): boolean;
+    isChildObjectModePossible(object: PlanObject_2): boolean;
+    getChildObjectMode(object: PlanObject_2): number;
+    setChildObjectMode(object: PlanObject_2, mode: number, switchChildModeOffForAllOtherObjects: boolean): PlanObject_2;
+    setChildObjectModeOfExternalObject(objectId: string, mode: number, switchChildModeOffForAllOtherObjects: boolean): PlanObject_2;
+    setChildObjectModeForAllPlanObjects(mode: number): void;
+    isEnabledChildObjectMode(object: PlanObject_2): boolean;
+    enableChildObjects(object: PlanObject_2, switchChildModeOffForAllOtherObjects: boolean): PlanObject_2;
+    disableChildObjects(object: PlanObject_2): PlanObject_2;
+    disableChildObjectsOfAllPlanObjects(): void;
+    enableChildObjectsOfExternalObject(objectId: string, switchChildModeOffForAllOtherObjects: boolean): PlanObject_2;
+    disableChildObjectsOfExternalObject(objectId: string): PlanObject_2;
+    rotateObjectTo(object: PlanObject_2, targetAngleInRad: number): void;
+    changePitchAngleTo(object: PlanObject_2, targetAngleInRad: number): void;
+    changeRollAngleTo(object: PlanObject_2, targetAngleInRad: number): void;
+    rotateObjectBy(object: PlanObject_2, deltaAngleInRad: number): void;
+    rotateObjectsBy(objects: PlanObjectPtrList_2, deltaAngleInRad: number, pivot: Vector3): void;
+    rotateGroupBy(group: ObjectGroup_2, angleInRad: number, pivot: Vector3): void;
+    setObjectRotation(object: PlanObject_2, targetAngleInRad: number): void;
+    setObjectFlipX(object: PlanObject_2, shouldFlipX: boolean): void;
+    setObjectFlipY(object: PlanObject_2, shouldFlipY: boolean): void;
+    setObjectFixedZ(object: PlanObject_2, shouldFlipZ: boolean): void;
+    setObjectCustomColor(object: PlanObject_2, rgbColor: number, useCustomColor: boolean): void;
+    setObjectCustomLabel(object: PlanObject_2, label: string): void;
+    setElementCustomDataJson(element: PlanElement_2, customDataJson: string): void;
+    setObjectSize(object: PlanObject_2, newSize: Vector3, anchor: ResizingAnchor_2): void;
+    deleteObjectsInGroup(group: ObjectGroup_2): void;
+    replaceObject(objectToBeReplaced: PlanElement_2, replacement: PlanElement_2): void;
+    duplicateGroup(group: ObjectGroup_2, count: number, findFreeSpaceInPlan: boolean): ObjectGroup_2[];
+    mergeObjects(objects: PlanObjectPtrList_2): void;
+    groupObjects(objects: PlanObjectPtrList_2): ObjectGroup_2;
+    ungroup(group: ObjectGroup_2): void;
+    duplicatePlanObjects(objects: PlanObjectPtrList_2, count: number, findFreeSpaceInPlan: boolean): PlanObject_2[];
+    setElementVisibility(element: PlanElement_2, isVisible: boolean): void;
+    setLengthOfEdge2D(wall: Wall_2, newLength: number, side: WallSide_2, extensionType: WallExtensionType_2, alsoMoveOrthogonalWalls: boolean): void;
+    setLengthOfSlopingEdge(wall: Wall_2, newSlopingLength: number, side: WallSide_2, extensionType: WallExtensionType_2, alsoMoveOrthogonalWalls: boolean): void;
+    setNodeType(node: Node_3, nodeType: NodeType_2): void;
+    setWallThickness(wall: Wall_2, thickness: number): void;
+    setWallHeight(wall: Wall_2, height: number): void;
+    setWallColor(wall: Wall_2, color: number): void;
+    setWallLeftMaterial(wall: Wall_2, material: WallMaterial_2): void;
+    setWallRightMaterial(wall: Wall_2, material: WallMaterial_2): void;
+    splitWall(wall: Wall_2, splitPoint: Vector3): void;
+    setAtticSide(attic: Attic, side: WallSide_2): void;
+    setAtticKneeHeight(attic: Attic, kneeHeight: number): void;
+    setAtticWidth(attic: Attic, width: number): void;
+    setFloorMaterial(floor: Floor_2, material: FloorMaterial_2): void;
+    setFloorMaterialRotation(floor: Floor_2, rotationInRad: number): void;
+    setFloorMaterialUvScale(floor: Floor_2, uvScale: Vector3): void;
+    setFloorLabelObject(floor: Floor_2, serializedLabelObject: string): void;
+    setFloorType(floor: Floor_2, floorType: FloorType): void;
+    setEdgeType(wall: Wall_2, edgeType: EdgeType): void;
+    setPlanTexterText(text: PlanText_2, texterText: string): void;
+    setPlanTexterSize(text: PlanText_2, newSize: Vector3): void;
+    setMeasurePoint1(measure: PlanMeasure_2, point: Vector3, snapToWalls: boolean, snapToObjects: boolean): void;
+    setMeasurePoint2(measure: PlanMeasure_2, point: Vector3, snapToWalls: boolean, snapToObjects: boolean): void;
+    setPlanImageRotation(image: PlanImage_2, newRotation: Vector3): void;
+    setPlanImageSize(image: PlanImage_2, newSize: Vector3): void;
+    removeElement(element: PlanElement_2): void;
+    removeObjectWithId(objectId: string): void;
+    duplicatePlanObject(object: PlanObject_2, count: number, findFreeSpaceInPlan: boolean): PlanObject_2[];
+    addWall(from: Node_3, to: Node_3): Wall_2;
+    addAttic(wall: Wall_2, kneeHeight: number, width: number, side: WallSide_2 | null | undefined): Attic;
+    addNode(position: Vector3): Node_3;
+    addText(text: string, position: Vector3): PlanText_2;
+    addPlanObject(itemId: string, type: string, size: Vector3, position: Vector3, rotationInRad: number, findFreeSpaceInPlan: boolean): PlanObject_2;
+    addPlanObjects(catalogItems: CatalogItemPtrList_2, findFreeSpaceInPlan: boolean): PlanObject_2[];
+    addPlanObjectFromItem(item: CatalogItem_2, position: Vector3, rotationInRad: number, findFreeSpaceInPlan: boolean): PlanObject_2;
+    addOrUpdateExternalPlanObjects(groups: string | string[], position: Vector3, rotationInRad: number, updateConfiguration: ExternalObjectLoadConfiguration, mergedGroupIds: string | string[]): PlanObject_2[];
+    createPreviewGeometryForAddOn(objectId: string, objectConfiguration: string, articleId: string, groupDefinitions: string, validContainerModules: ExternalValidContainerModule[]): void;
+    catalogItemLoaded(catalogItem: CatalogItem_2): void;
+    addMeasure(startPosition: Vector3, endPosition: Vector3): PlanMeasure_2;
+    addImage(url: string, center: Vector3, size: Vector3, rotation: Vector3): PlanImage_2;
+    setPlanObjectMesh(object: PlanObject_2, mesh: any): void;
+    getPlan(): Plan_2;
+    setPlan(plan: Plan_2): void;
+    clearPlan(): void;
+    setViewSnapDist(distance: number): void;
+    setViewSnapHeightLevelDistance(distance: number): void;
+    setViewSnapEdgeEndPointDistance(distance: number): void;
+    setZoomFactor(distance: number): void;
+    setRotationSnapAngle(angleInRadians: number): void;
+    endInteraction(): void;
+    clearHistory(): void;
+    startInteraction(): void;
+    resumeInteraction(): void;
+    setSnapFeedbackWhileDrawing(shouldSnapWhileDrawing: boolean): void;
+    setSnapToClusterWhileContinuousDrawing(shouldSnapWhileDrawing: boolean): void;
+    setParallelWallToleranceInDegrees(tolerance: number): void;
+    isVectorPreviewModeEnabled(): boolean;
+    getDrawingMode(): DrawingMode_2;
+    isCreateUnclosedSpaceEnabled(): boolean;
+    beginDrawing(position: Vector3, drawingMode: DrawingMode_2, createUnclosedSpace: boolean): void;
+    currentDrawingPosition(position: Vector3): void;
+    forceNode(position: Vector3): void;
+    endDrawing(position: Vector3): void;
+    cancelDrawing(): void;
+    setDrawingType(newDrawingType: DrawingType_2): void;
+    getContinuousDrawingManager(): ContinuousDrawingManager;
+    deactivateAllSnappingActivity(): void;
+    reactivateAllSnappingActivity(): void;
+    getConfiguratorKernel(): ConfiguratorKernel;
+    loadPlanObjectConfigurations(): void;
+    undo(): void;
+    redo(): void;
+    isRedoPossible(): boolean;
+    isUndoPossible(): boolean;
+    getRelativeHistoryPosition(): number;
+    generateTCExport(planObjectItemIds: string[]): string;
+    unit: string;
+    objectToWallSnapMode: SnapMode;
+    objectToObjectSnapMode: SnapMode;
+    enableSnap: boolean;
+    enableRaster: boolean;
+    customRaster: number;
+    moveWallsOrthogonal: boolean;
+    enableDrawingSnap: boolean;
+    dockWhenSnap: boolean;
+    unDockOnMove: boolean;
+    automaticallyIntersectWithWalls: boolean;
+    enableTerrain: boolean;
+}
+
 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;
@@ -5735,7 +6841,13 @@ export declare abstract class PlanMeasure extends PlanElement {
     getPoint2(): KernelVector3f;
 }
 
-export declare interface PlanMeasure_2 extends PlanObject {
+export declare interface PlanMeasure_2 extends PlanElement_2 {
+    new (): PlanMeasure_2;
+    getPoint1(): Vector3;
+    getPoint2(): Vector3;
+}
+
+export declare interface PlanMeasure_3 extends PlanObject {
     getPoint1(): KernelVector3f;
     getPoint2(): KernelVector3f;
 }
@@ -5754,21 +6866,21 @@ export declare abstract class PlanModelViewHelper {
 }
 
 export declare interface PlanModelViewHelper_2 {
-    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;
-    getRootPlanObjectId(plan: Plan_2, aRuntimeId: number): number;
-    getObjectComponent(plan: Plan_2, typeOfId: TypeOfCoreId, anId: number): KernelPlanObjectComponent;
-    getExternalObjectComponent(plan: Plan_2, groupId: string, moduleId: string): KernelPlanObjectComponent;
-    requestMesh3d(element: PlanElement_2): void;
-    getExternalObjectGroups(plan: Plan_2): KernelObjectConfigurationArray;
-    getExternalRoomInformation(plan: Plan_2, mode: PlanRoomGeometryMode_2): RoomInformation;
+    getPlanOverview(plan: Plan_3): PlanOverview;
+    getConstructionOverview(plan: Plan_3): ConstructionOverview;
+    getPlanObject(plan: Plan_3, aRuntimeId: number): KernelPlanObject;
+    isChildObjectRootComponent(plan: Plan_3, componentRuntimeId: number): boolean;
+    isAnimationRootComponent(plan: Plan_3, componentRuntimeId: number): boolean;
+    getRootPlanObjectId(plan: Plan_3, aRuntimeId: number): number;
+    getObjectComponent(plan: Plan_3, typeOfId: TypeOfCoreId, anId: number): KernelPlanObjectComponent;
+    getExternalObjectComponent(plan: Plan_3, groupId: string, moduleId: string): KernelPlanObjectComponent;
+    requestMesh3d(element: PlanElement_3): void;
+    getExternalObjectGroups(plan: Plan_3): KernelObjectConfigurationArray;
+    getExternalRoomInformation(plan: Plan_3, mode: PlanRoomGeometryMode_2): RoomInformation;
     getGroupedObjects(anObject: PlanObject): KernelPlanObject[];
-    calculateLightSourceDistribution(plan: Plan_2, lightSourceConfiguration: LightSourceConfiguration): RoomLightSourceDistributionArray;
+    calculateLightSourceDistribution(plan: Plan_3, lightSourceConfiguration: LightSourceConfiguration): RoomLightSourceDistributionArray;
     getObjectSnapInformation(anObject: PlanObject, debugHelpLines: boolean): ObjectSnapInformation;
-    getPlanViews(plan: Plan_2): PlanView[];
+    getPlanViews(plan: Plan_3): PlanView[];
 }
 
 export declare class Planner<P extends readonly PluginName[] = readonly []> extends Main {
@@ -5860,7 +6972,7 @@ export declare interface PlannerInitData {
      * usage: mode=2D
      * options: 2D, 3D, FP
      */
-    mode?: Enumify_3<typeof CAMERA_TYPE>;
+    mode?: Enumify<typeof CAMERA_TYPE>;
     /* Excluded from this release type: edit */
     /**
      * @description If set to true it will treat the planner as a multi object configurator (moc).
@@ -5938,50 +7050,50 @@ export declare class PlannerKernelAccess extends ConfiguratorKernelAccess {
     requestPlanObjectDimensions(): void;
     cleanUpCallbacks(): void;
     registerCallbacks(): void;
-    planElementRemoved(element: PlanElement_2): void;
-    handlerSwitchedPlans(fromPlan: Plan_2, toPlan: Plan_2): void;
+    planElementRemoved(element: PlanElement_3): void;
+    handlerSwitchedPlans(fromPlan: Plan_3, toPlan: Plan_3): void;
     planBoundsChanged(): void;
     planCleared(): void;
-    planCompletelyLoaded(plan: Plan_2): void;
-    planElement3dMeshChanged(_plan: Plan_2, element: PlanElement_2): void;
+    planCompletelyLoaded(plan: Plan_3): void;
+    planElement3dMeshChanged(_plan: Plan_3, element: PlanElement_3): void;
     private _onStaticItemAdded;
     private _onConfigurableItemAdded;
     private _onConfigurableConstructionItemAdded;
-    planElementAdded(plan: Plan_2, element: PlanElement_2): Promise<void>;
-    planElementChanged(plan: Plan_2, element: PlanElement_2): void;
+    planElementAdded(plan: Plan_3, element: PlanElement_3): Promise<void>;
+    planElementChanged(plan: Plan_3, element: PlanElement_3): void;
     planHistoryStateChanged(): void;
-    planObjectConfigurationCreated(_plan: Plan_2, _element: PlanObject): void;
-    externalObjectConfigurationChanged(plan: Plan_2, planObject: PlanObject, configuration: string): void;
-    externalObjectConfigurationLoaded(plan: Plan_2, planObject: PlanObject, configuration: string): void;
-    externalObjectConfigurationDeleted(plan: Plan_2, planObject: PlanObject, uniqueId: string): void;
-    externalObjectComponentDeleted(plan: Plan_2, planObject: PlanObject, remainingGroupOrGroups: ExternalObjectGroup | ExternalObjectGroup[], deletedRootModuleId: string): void;
-    externalObjectConfigurationDuplicated(plan: Plan_2, planObject: PlanObject, duplicatedGroup: ExternalObjectGroup): void;
-    externalObjectPositionChanged(plan: Plan_2, planObject: PlanObject, movedGroup: ExternalObjectGroup): void;
-    externalObjectPlanChanged(plan: Plan_2, planObject: PlanObject, movedGroup: ExternalObjectGroup): void;
-    externalObjectConfigurationsMerged(plan: Plan_2, planObject: PlanObject, mergedGroup: ExternalObjectGroup, idsOfGroupsMerged: string | string[], targetRootModuleId: string, mergedWithDragging: boolean): void;
-    externalObjectComponentSplitOff(plan: Plan_2, planObject: PlanObject, splitGroups: ExternalObjectGroup[]): void;
-    externalObjectRequestAddOnContainers(plan: Plan_2, planObject: PlanObject, groupId: string, subArticleId: string): void;
-    externalObjectAddSubArticle(plan: Plan_2, planObject: PlanObject, subArticleId: string, rootModuleId: string, parentModuleId: string, insertPosition?: number[]): void;
-    externalObjectMoveSubArticle(plan: Plan_2, planObject: PlanObject, subArticleId: string, subModuleId: string, rootModuleId: string, parentModuleId: string, insertPosition?: number[]): void;
-    externalObjectRemoveSubModule(plan: Plan_2, planObject: PlanObject, groupId: string, subModuleId: string): void;
-    planObjectConfigurationLoaded(plan: Plan_2, element: PlanElement_2, success: boolean): Promise<void>;
-    planObjectConfigurationChanged(plan: Plan_2, object: PlanObject): void;
+    planObjectConfigurationCreated(_plan: Plan_3, _element: PlanObject): void;
+    externalObjectConfigurationChanged(plan: Plan_3, planObject: PlanObject, configuration: string): void;
+    externalObjectConfigurationLoaded(plan: Plan_3, planObject: PlanObject, configuration: string): void;
+    externalObjectConfigurationDeleted(plan: Plan_3, planObject: PlanObject, uniqueId: string): void;
+    externalObjectComponentDeleted(plan: Plan_3, planObject: PlanObject, remainingGroupOrGroups: ExternalObjectGroup | ExternalObjectGroup[], deletedRootModuleId: string): void;
+    externalObjectConfigurationDuplicated(plan: Plan_3, planObject: PlanObject, duplicatedGroup: ExternalObjectGroup): void;
+    externalObjectPositionChanged(plan: Plan_3, planObject: PlanObject, movedGroup: ExternalObjectGroup): void;
+    externalObjectPlanChanged(plan: Plan_3, planObject: PlanObject, movedGroup: ExternalObjectGroup): void;
+    externalObjectConfigurationsMerged(plan: Plan_3, planObject: PlanObject, mergedGroup: ExternalObjectGroup, idsOfGroupsMerged: string | string[], targetRootModuleId: string, mergedWithDragging: boolean): void;
+    externalObjectComponentSplitOff(plan: Plan_3, planObject: PlanObject, splitGroups: ExternalObjectGroup[]): void;
+    externalObjectRequestAddOnContainers(plan: Plan_3, planObject: PlanObject, groupId: string, subArticleId: string): void;
+    externalObjectAddSubArticle(plan: Plan_3, planObject: PlanObject, subArticleId: string, rootModuleId: string, parentModuleId: string, insertPosition?: number[]): void;
+    externalObjectMoveSubArticle(plan: Plan_3, planObject: PlanObject, subArticleId: string, subModuleId: string, rootModuleId: string, parentModuleId: string, insertPosition?: number[]): void;
+    externalObjectRemoveSubModule(plan: Plan_3, planObject: PlanObject, groupId: string, subModuleId: string): void;
+    planObjectConfigurationLoaded(plan: Plan_3, element: PlanElement_3, success: boolean): Promise<void>;
+    planObjectConfigurationChanged(plan: Plan_3, object: PlanObject): void;
     requestCatalogItem(catalogItemId: string): void;
     startedDrawing(): void;
     stoppedDrawing(): void;
     updateMesh2d(): void;
     beginConstruction(): void;
-    addMesh(planElement: PlanElement_2, material: any, vertices: Float32Array, indices: Int32Array, uvCoords: Float32Array, normals: Float32Array): void;
+    addMesh(planElement: PlanElement_3, material: any, vertices: Float32Array, indices: Int32Array, uvCoords: Float32Array, normals: Float32Array): void;
     endConstruction(): void;
-    beginPlanConstruction(plan: Plan_2): void;
-    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;
+    beginPlanConstruction(plan: Plan_3): void;
+    addPlanMesh(plan: Plan_3, material: any, vertices: Float32Array, indices: Int32Array, uvCoords: Float32Array, normals: Float32Array, type: KernelEnum): void;
+    endPlanConstruction(plan: Plan_3): void;
+    createPlanFromObject(rapiElement: RapiItem | RapiConfiguration, position?: Position3, rotation?: number): Plan_3;
     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;
+    isConstructionPlanElement(planElement: PlanElement_3): boolean;
     planObjectSelectionChanged(configurationRuntimeId: number, elementRuntimeId: number): void;
     protected _componentSelectionChanged(_planObject: PlanObjectKernel, component: KernelComponent): void;
     protected _externalObjectParameterChanged(objectOrComponentId: number, parameterKey: string, value: string): void;
@@ -6001,7 +7113,7 @@ export declare class PlannerKernelAccess extends ConfiguratorKernelAccess {
     configureExternalObjectApi(externalObjectSettings?: ExternalObjectApiConfiguration): Promise<void>;
     setComponentParameter(componentId: number, interactionKey: string, newValue: any): void;
     protected _getAnimationLevelForObject(runtimeId: number, _animation: KernelAnimation): AnimationLevelType;
-    getObjectComponent(runtimeId: number, typeOfId: Enumify_3<typeof CORE_TYPE_OF_CORE_ID>): KernelPlanObjectComponent | null;
+    getObjectComponent(runtimeId: number, typeOfId: Enumify<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;
@@ -6010,18 +7122,18 @@ export declare class PlannerKernelAccess extends ConfiguratorKernelAccess {
 }
 
 export declare interface PlannerKernelCallbackI {
-    handlerSwitchedPlans(fromPlan: Plan_2, toPlan: Plan_2): void;
-    planCompletelyLoaded(plan: Plan_2): void;
-    beginPlanConstruction(plan: Plan_2): void;
-    addMesh(planElement: PlanElement_2, material: any, vertices: Float32Array, indices: Int32Array, uvCoords: Float32Array, normals: Float32Array): void;
-    addPlanMesh(plan: Plan_2, material: any, vertices: Float32Array, indices: Int32Array, uvCoords: Float32Array, normals: Float32Array, type: KernelEnum): void;
-    endPlanConstruction(plan: Plan_2): void;
+    handlerSwitchedPlans(fromPlan: Plan_3, toPlan: Plan_3): void;
+    planCompletelyLoaded(plan: Plan_3): void;
+    beginPlanConstruction(plan: Plan_3): void;
+    addMesh(planElement: PlanElement_3, material: any, vertices: Float32Array, indices: Int32Array, uvCoords: Float32Array, normals: Float32Array): void;
+    addPlanMesh(plan: Plan_3, material: any, vertices: Float32Array, indices: Int32Array, uvCoords: Float32Array, normals: Float32Array, type: KernelEnum): void;
+    endPlanConstruction(plan: Plan_3): void;
     addPlanObjectToScene(planElementViewModel: PlanObjectViewModel | null): void;
     removePlanObjectFromScene(planElementViewModel: PlanObjectViewModel | undefined): void;
-    planElementChanged(plan: Plan_2, planObject: PlanElementViewModel): void;
-    planElementRemoved(element: PlanElement_2): void;
-    planObjectConfigurationLoaded(plan: Plan_2, element: PlanElement_2, success: boolean): void;
-    planObjectConfigurationChanged(plan: Plan_2, element: PlanElementViewModel): void;
+    planElementChanged(plan: Plan_3, planObject: PlanElementViewModel): void;
+    planElementRemoved(element: PlanElement_3): void;
+    planObjectConfigurationLoaded(plan: Plan_3, element: PlanElement_3, success: boolean): void;
+    planObjectConfigurationChanged(plan: Plan_3, element: PlanElementViewModel): void;
     planBoundsChanged(): void;
     planHistoryStateChanged(): void;
     planCleared(): void;
@@ -6079,7 +7191,7 @@ export declare interface PlannerKernelContainer {
     unregisterPlannerCallback: (callbacksObject: any) => void;
     StringArray: StringArray;
     Vector2fArray: Vector2fArray;
-    LongArray: LongArray;
+    LongArray: LongArray_2;
     DockPairPreviewArray: DockPairPreviewArray_2;
     ComponentArray: ComponentArray_2;
     Type: Type_2;
@@ -6087,16 +7199,16 @@ export declare interface PlannerKernelContainer {
     VariableArray: VariableArray_2;
     RangeArray: RangeArray_2;
     ParameterValueArray: ParameterValueArray_2;
-    ParameterArray: ParameterArray_2;
+    ParameterArray: ParameterArray_3;
     ParameterGroupArray: ParameterGroupArray_2;
     PartListParameterArray: PartListParameterArray_2;
     ConfigurationArray: ConfigurationArray_2;
     PartArray: PartArray_2;
-    PossibleChildArray: PossibleChildArray_2;
-    AddOnSpotArray: AddOnSpotArray_2;
+    PossibleChildArray: PossibleChildArray_3;
+    AddOnSpotArray: AddOnSpotArray_3;
     PlanObjectList: PlanObjectList;
     ParamKeyValuePairArray: ParamKeyValuePairArray_2;
-    IntArray: IntArray_2;
+    IntArray: IntArray_3;
     Kernel: ConfiguratorKernelClass;
     Unit: Unit_2;
     UnitStringType: UnitStringType_2;
@@ -6280,7 +7392,7 @@ export declare class PlannerSceneManager extends ConfiguratorSceneManager implem
     private _hide2dMeasurements;
     private _is2dMeasurementsOverlayDirty;
     private _debugSpheres;
-    constructor(creator: string, offset: CanvasOffset, plannerCallback: RoomlePlannerCallback, mode: Enumify_3<typeof CAMERA_TYPE>);
+    constructor(creator: string, offset: CanvasOffset, plannerCallback: RoomlePlannerCallback, mode: Enumify<typeof CAMERA_TYPE>);
     isDragging(): boolean;
     protected _initializeMeshGeneratorSettings(): void;
     setHomagIntelligence(homagIntelligence: HomagIntelligence | null): void;
@@ -6323,7 +7435,7 @@ export declare class PlannerSceneManager extends ConfiguratorSceneManager implem
     private _resetCameraFacingVisibility;
     private _forceWallsAndCeiling;
     protected _getInputManager(): InputManager;
-    protected createCameraControl(mode: Enumify_3<typeof CAMERA_TYPE>, _offset: CanvasOffset): void;
+    protected createCameraControl(mode: Enumify<typeof CAMERA_TYPE>, _offset: CanvasOffset): void;
     startViewing(): void;
     startConfiguring(): void;
     private _is3DView;
@@ -6337,10 +7449,10 @@ export declare class PlannerSceneManager extends ConfiguratorSceneManager implem
     requestCatalogItem(catalogItemId: string): void;
     private _staticItemsLoaded;
     preload(id: string): void;
-    planXMLLoaded(plan: Plan_2): void;
+    planXMLLoaded(plan: Plan_3): void;
     private _activateCeilingLight;
-    planCompletelyLoaded(_plan: Plan_2): void;
-    handlerSwitchedPlans(fromPlan: Plan_2, toPlan: Plan_2): void;
+    planCompletelyLoaded(_plan: Plan_3): void;
+    handlerSwitchedPlans(fromPlan: Plan_3, toPlan: Plan_3): void;
     /**
      * Re-applies the persisted lamp on/off state after a plan finishes loading.
      * Reads the `lampOff` flag from each element's `customDataJson` (which the
@@ -6348,13 +7460,13 @@ export declare class PlannerSceneManager extends ConfiguratorSceneManager implem
      */
     private _restoreLampStates;
     private _itemsLoaded;
-    beginPlanConstruction(_plan: Plan_2): void;
-    addPlanMesh(_plan: Plan_2, _material: any, _vertices: Float32Array, _indices: Int32Array, _uvCoords: Float32Array, _normals: Float32Array, _type: KernelEnum): void;
-    endPlanConstruction(_plan: Plan_2): void;
+    beginPlanConstruction(_plan: Plan_3): void;
+    addPlanMesh(_plan: Plan_3, _material: any, _vertices: Float32Array, _indices: Int32Array, _uvCoords: Float32Array, _normals: Float32Array, _type: KernelEnum): void;
+    endPlanConstruction(_plan: Plan_3): void;
     addPlanObjectToScene(planViewModel: PlanObjectViewModel | null): Promise<void>;
     private _recycleLights;
     removePlanObjectFromScene(planViewModel: PlanElementViewModel | undefined): void;
-    planElementChanged(plan: Plan_2, planElementViewModel: PlanElementViewModel): void;
+    planElementChanged(plan: Plan_3, planElementViewModel: PlanElementViewModel): void;
     exportGLB(options?: ModelExportOptions): Promise<void>;
     exportUSDZ(options?: ModelExportOptions): Promise<void>;
     importGLB(url: string): void;
@@ -6384,7 +7496,7 @@ export declare class PlannerSceneManager extends ConfiguratorSceneManager implem
     redo(): Promise<void>;
     private _reshowDimensionsAfterUndoRedo;
     protected _updateConfigurationFromHistory(configurationString: string): Promise<void>;
-    setMode(mode: Enumify_3<typeof CAMERA_TYPE>): void;
+    setMode(mode: Enumify<typeof CAMERA_TYPE>): void;
     private _clearHighlighting;
     updateHighlightingOfPlanElements(): void;
     planObjectUpdated(planObject: PlanObjectKernel, geometryChanged: boolean, pendingDocking: boolean, automaticCalculationUpdate: boolean): void;
@@ -6392,9 +7504,9 @@ export declare class PlannerSceneManager extends ConfiguratorSceneManager implem
     highlightPlanElementsById(runtimeIds: number[] | null): void;
     highlightPlanElementById(runtimeId: number | null): void;
     destroy(): void;
-    planObjectConfigurationLoaded(plan: Plan_2, element: PlanElement_2, success: boolean): void;
-    planObjectConfigurationChanged(_plan: Plan_2, element: PlanElementViewModel): Promise<void>;
-    addMesh(_planElement: PlanElement_2, _material: any, _vertices: Float32Array, _indices: Int32Array, _uvCoords: Float32Array, _normals: Float32Array): void;
+    planObjectConfigurationLoaded(plan: Plan_3, element: PlanElement_3, success: boolean): void;
+    planObjectConfigurationChanged(_plan: Plan_3, element: PlanElementViewModel): Promise<void>;
+    addMesh(_planElement: PlanElement_3, _material: any, _vertices: Float32Array, _indices: Int32Array, _uvCoords: Float32Array, _normals: Float32Array): void;
     updateCameraOnDrawWalls(): void;
     getBounds(): Box3;
     getGeometryBounds(): Box3 | null;
@@ -6407,7 +7519,7 @@ export declare class PlannerSceneManager extends ConfiguratorSceneManager implem
     rotatePlanElements(ids: RuntimeId[], rotateBy: number): void;
     rotatePlanElementSelection(rotateBy: number): void;
     planBoundsChanged(): void;
-    planElementRemoved(element: PlanElement_2): void;
+    planElementRemoved(element: PlanElement_3): void;
     private _onPlanChanged;
     prepareTopImage(options?: PrepareImageOptions, isolationMode?: boolean): Promise<Base64Image>;
     preparePerspectiveImageOf(runtimeId: RuntimeId, options?: PrepareImageOptions): Promise<Base64Image>;
@@ -6434,8 +7546,8 @@ export declare class PlannerSceneManager extends ConfiguratorSceneManager implem
     getPositionForDragEvent(dragEvent: DragEvent | TouchEvent | {
         clientX: number;
         clientY: number;
-    }): Vector3 | null;
-    getPositionForLastPointer(): Vector3 | null;
+    }): Vector3_2 | null;
+    getPositionForLastPointer(): Vector3_2 | null;
     isPointerUp(): boolean;
     getPlannerSceneEventHandler(): PlannerSceneEventHandler;
     disablePlannerEvents(): void;
@@ -6522,7 +7634,7 @@ export declare class PlannerSceneManager extends ConfiguratorSceneManager implem
     enableEvents(): void;
     resetCameraPositionToStart(): void;
     moveCamera(cameraParameter: CameraParameter): Promise<void>;
-    protected _setInteriorOrExteriorWallMaterial(type: Enumify_3<typeof SET_WALL_MATERIAL_TYPE>, material: BatchPaintMaterial): void;
+    protected _setInteriorOrExteriorWallMaterial(type: Enumify<typeof SET_WALL_MATERIAL_TYPE>, material: BatchPaintMaterial): void;
     changeInteriorWallsMaterial(material: BatchPaintMaterial): void;
     changeExteriorWallsMaterial(material: BatchPaintMaterial): void;
     changeFloorsMaterial(floors: KernelFloor[], material: BatchPaintMaterial): void;
@@ -6552,7 +7664,7 @@ export declare class PlannerSceneManager extends ConfiguratorSceneManager implem
     switchConfiguratorObject(clickedComponentId: number): Promise<void>;
     selectObjectComponent(planObjectComponent: KernelPlanObjectComponent, switchToConfigurator: boolean, selectComponent: boolean): Promise<void>;
     _swapObjectInConfigurator(planObjectComponent: KernelPlanObjectComponent): Promise<void>;
-    getObjectComponent(id: number, typeOfId: Enumify_3<typeof CORE_TYPE_OF_CORE_ID>): KernelPlanObjectComponent | null;
+    getObjectComponent(id: number, typeOfId: Enumify<typeof CORE_TYPE_OF_CORE_ID>): KernelPlanObjectComponent | null;
     getExternalObjectComponent(groupOrRootModuleId: string, subModuleId: string): KernelPlanObjectComponent;
     getCameraParameters3d(): CameraParameter | null;
     private _createCeilingLightGroup;
@@ -6576,7 +7688,7 @@ export declare interface PlanNode extends KernelObject {
     getNumberOfConnectedWalls(): number;
 }
 
-export declare interface PlanObject extends PlanElement_2 {
+export declare interface PlanObject extends PlanElement_3 {
     size: KernelVector3;
     rotation: number;
     customLabel: string;
@@ -6599,11 +7711,63 @@ export declare interface PlanObject extends PlanElement_2 {
     isConstructionObjectProduct(): boolean;
     getWallDistances(): ObjectToWallLineArray;
     getRectangle(): Rectangle;
-    getRotationToPreferredFront(): ObjectFrontRotation;
+    getRotationToPreferredFront(): ObjectFrontRotation_2;
     isRootComponentOfChildObject(componentRuntimeId: number): boolean;
     getReplacementConstructionId(): number;
 }
 
+export declare interface PlanObject_2 extends PlanElement_2 {
+    new (): PlanObject_2;
+    getCatalogItemId(): string;
+    getOpenConversationId(): number;
+    getConfigurationRuntimeId(): number;
+    getReplacementConstructionId(): number;
+    getObjectType(): string;
+    getObjectCategory(): ObjectTypeCategory;
+    hasConfiguration(): boolean;
+    isAdjustable(): boolean;
+    isExternalObject(): boolean;
+    isConstructionObjectProduct(): boolean;
+    retrieveConfigurationId(): UniqueIdAndHash;
+    getConfiguration(): string;
+    isConfigurationLoaded(): boolean;
+    getRectangle(): ExtrudedRectangle;
+    getWallDistances(): LineArray;
+    getRotationToPreferredFront(): ObjectFrontRotation;
+    isRootComponentOfChildObject(componentRuntimeId: number): boolean;
+    readonly customLabel: string;
+    readonly roll: number;
+    readonly pitch: number;
+    readonly entityYaw: number;
+    readonly rotation: number;
+    readonly rgbColor: number;
+    readonly useCustomColor: boolean;
+    readonly level: number;
+    readonly flipX: boolean;
+    readonly flipXEnabled: boolean;
+    readonly flipY: boolean;
+    readonly flipYEnabled: boolean;
+    readonly fixedZ: boolean;
+    size: Vector3;
+    readonly boxForMeasurement: Box;
+    readonly measurementBounds: AssembledObjectBounds;
+}
+
+export declare interface PlanObject_3 {
+    animations: Animation_2[];
+    boxForMeasurement: Box;
+    dimensioningAxes: DimensioningAxis_2[];
+    dimensionings: Dimensioning_2[];
+    externalId: string;
+    externalObject: boolean;
+    geometryBounds: Box;
+    geometryBoundsWithEnvironment: Box;
+    id: number;
+    parameterGroups: ParameterGroup[];
+    parameters: Parameter[];
+    rootPlanComponentId: number;
+}
+
 export declare interface PlanObjectKernel {
     geometryBounds: KernelCube;
     boxForMeasurement: KernelCube;
@@ -6647,6 +7811,8 @@ export declare abstract class PlanObjectPtr extends AbstractModelWrapper {
 export declare class PlanObjectPtrList extends EmsList<PlanObjectPtr> {
 }
 
+export declare type PlanObjectPtrList_2 = EmscriptenList_2<PlanObject_2>;
+
 export declare class PlanObjectPtrVector extends EmsArray<PlanObjectPtr> {
 }
 
@@ -6667,8 +7833,8 @@ export declare class PlanObjectViewModel extends PlanElementViewModel {
     isInitDone(): Promise<void>;
     clear(): void;
     getPlanObject(): PlanObject;
-    getSize(): Vector3;
-    getObjectMeasurements(zoomFactor: number, clientWidth: number, clientHeight: number, otherObjects?: NeighboringObjectMeasurementInfo[]): Nullable_2<ObjectMeasurements>;
+    getSize(): Vector3_2;
+    getObjectMeasurements(zoomFactor: number, clientWidth: number, clientHeight: number, otherObjects?: NeighboringObjectMeasurementInfo[]): Nullable<ObjectMeasurements>;
     update(): void;
 }
 
@@ -6676,7 +7842,7 @@ export declare interface PlanOverview {
     area: number;
     bounds: KernelCube;
     objects: KernelPlanObjectList;
-    outsideWalls: PlanElement_2[];
+    outsideWalls: PlanElement_3[];
     rooms: PlanOverviewRoom[];
 }
 
@@ -6697,6 +7863,11 @@ export declare abstract class PlanText extends PlanElement {
     getText(): string;
 }
 
+export declare interface PlanText_2 extends PlanElement_2 {
+    new (): PlanText_2;
+    getText(): string;
+}
+
 export declare interface PlanView extends KernelPlanViewStyle {
     id: number;
     viewType: PlanViewType;
@@ -6741,9 +7912,9 @@ export declare class PlanViewModel extends ConfiguratorViewModel implements Plan
     startedDrawing(): void;
     stoppedDrawing(): void;
     planBoundsChanged(): void;
-    setReference(plan: Plan_2): void;
+    setReference(plan: Plan_3): void;
     clearReference(): void;
-    getCorePlan(): Plan_2;
+    getCorePlan(): Plan_3;
     addPlanElementViewModel(planElementViewModel: PlanElementViewModel): void;
     private _handleConfiguratorPlanObjectViewModel;
     private _linkPlanObjectViewModelAndComponent;
@@ -6832,19 +8003,19 @@ export declare class PlanViewModel extends ConfiguratorViewModel implements Plan
     protected _setMaterial(mesh: Mesh, material: any, _type?: KernelEnum, materialAttributes?: Record<string, string>): void;
     Editor3dComponentCreated(componentDocking: KernelComponentDocking): void;
     addPlanObjectToScene(_planViewModel: PlanObjectViewModel | null): void;
-    handlerSwitchedPlans(_fromPlan: Plan_2, _toPlan: Plan_2): void;
-    planCompletelyLoaded(_plan: Plan_2): void;
-    beginPlanConstruction(_plan: Plan_2): void;
-    addPlanMesh(_plan: Plan_2, _material: any, _vertices: Float32Array, _indices: Int32Array, _uvCoords: Float32Array, _normals: Float32Array, _type: KernelEnum): void;
-    endPlanConstruction(_plan: Plan_2): void;
-    planElementChanged(_plan: Plan_2, _planObject: PlanElementViewModel): void;
-    planObjectConfigurationLoaded(_plan: Plan_2, planElement: PlanElement_2, success: boolean): void;
+    handlerSwitchedPlans(_fromPlan: Plan_3, _toPlan: Plan_3): void;
+    planCompletelyLoaded(_plan: Plan_3): void;
+    beginPlanConstruction(_plan: Plan_3): void;
+    addPlanMesh(_plan: Plan_3, _material: any, _vertices: Float32Array, _indices: Int32Array, _uvCoords: Float32Array, _normals: Float32Array, _type: KernelEnum): void;
+    endPlanConstruction(_plan: Plan_3): void;
+    planElementChanged(_plan: Plan_3, _planObject: PlanElementViewModel): void;
+    planObjectConfigurationLoaded(_plan: Plan_3, planElement: PlanElement_3, success: boolean): void;
     recomputeConfigurableBoundingBoxes(): void;
-    planObjectConfigurationChanged(_plan: Plan_2, _element: PlanElementViewModel): void;
-    addMesh(planElement: PlanElement_2, material: any, vertices: Float32Array, indices: Int32Array, uvCoords: Float32Array, normals: Float32Array): void;
+    planObjectConfigurationChanged(_plan: Plan_3, _element: PlanElementViewModel): void;
+    addMesh(planElement: PlanElement_3, material: any, vertices: Float32Array, indices: Int32Array, uvCoords: Float32Array, normals: Float32Array): void;
     removePlanObjectFromScene(planElementViewModel: PlanElementViewModel | undefined): void;
     private _isConstructionType;
-    planElementRemoved(element: PlanElement_2): void;
+    planElementRemoved(element: PlanElement_3): void;
     private _removeObject;
     protected getMeshGenerator(): MeshGenerator;
     componentConfigurationUpdated(runtimeComponentId: number, geometryChanged: boolean): void;
@@ -6856,8 +8027,8 @@ export declare class PlanViewModel extends ConfiguratorViewModel implements Plan
     showAll(): void;
     planHistoryStateChanged(): void;
     setNodeVisibility(visible: boolean): void;
-    setCameraType(cameraType: Enumify_3<typeof CAMERA_TYPE>): Promise<void>;
-    get cameraType(): Enumify_3<typeof CAMERA_TYPE>;
+    setCameraType(cameraType: Enumify<typeof CAMERA_TYPE>): Promise<void>;
+    get cameraType(): Enumify<typeof CAMERA_TYPE>;
     setNodeZoom(zoom: number): void;
     planCleared(): void;
     requestCatalogItem(_catalogItemId: string): void;
@@ -6871,6 +8042,10 @@ export declare interface PlanViewType {
     value: Enumify<typeof CORE_PLAN_VIEW_TYPE>;
 }
 
+export declare interface PlanViewType_2 {
+    value: Enumify_3<typeof CORE_PLAN_VIEW_TYPE_2>;
+}
+
 export declare interface PluginConfigMap {
     'external-objects': RapiConfigurationEnhanced | ExternalConfiguration;
 }
@@ -6886,21 +8061,23 @@ export declare class PluginSystem implements Context, ScenePluginHooks {
     private _cameraPosition;
     private _plugins;
     constructor(creator: string);
-    init(scene: Scene, uiScene: Scene, cameraPosition: Vector3): Promise<void>;
+    init(scene: Scene, uiScene: Scene, cameraPosition: Vector3_2): Promise<void>;
     addPlugin(plugin: ScenePlugin): void;
     updateBounds(bounds: Box3): void;
     clearScene(scene: Scene, uiScene: Scene): void;
     getActivePlugins(): ScenePlugin[];
     getPlugin<T extends ScenePlugin>(type: any): T | null;
-    moveCameraEnd(position: Vector3): void;
-    moveCameraStart(position: Vector3): void;
+    moveCameraEnd(position: Vector3_2): void;
+    moveCameraStart(position: Vector3_2): void;
     needsUiScene(): boolean;
 }
 
 export declare class PointArray extends EmsArray<KernelVector3f> {
 }
 
-export declare class PointArray_2 extends EmsArray<KernelVector3f> {
+export declare type PointArray_2 = EmscriptenArray<Vector3>;
+
+export declare class PointArray_3 extends EmsArray<KernelVector3f> {
 }
 
 export declare interface PointerInputEvent {
@@ -7158,10 +8335,20 @@ export declare interface PosSaveData {
     rooms?: PosContour[];
 }
 
+export declare interface PossibleChild {
+    componentId: string;
+    group: string;
+    isDefault: boolean;
+    itemId: string;
+    possible: boolean;
+}
+
 export declare class PossibleChildArray extends EmsArray<KernelPossibleChild> {
 }
 
-export declare class PossibleChildArray_2 extends EmsArray<KernelPossibleChild> {
+export declare type PossibleChildArray_2 = EmscriptenArray<PossibleChild>;
+
+export declare class PossibleChildArray_3 extends EmsArray<KernelPossibleChild> {
 }
 
 export declare interface PossibleChildPreviewElement {
@@ -7212,19 +8399,19 @@ export declare interface PreviewComponent extends RoomleComponent {
     stringId: string;
     receivedPointAssociation: boolean;
     dockInsertAnimation?: DragInsertAnimation;
-    clickPosition?: Vector3;
+    clickPosition?: Vector3_2;
     clonePreview(cloneId: string): PreviewComponent;
     preparePreview(): void;
     startPulsating(): void;
-    updateClickPosition(intersectionPoint: Vector3): void;
+    updateClickPosition(intersectionPoint: Vector3_2): void;
 }
 
 export declare interface PreviewLineComponent extends PreviewComponent {
-    lineFrom: Vector3;
-    lineTo: Vector3;
+    lineFrom: Vector3_2;
+    lineTo: Vector3_2;
     lineSegments: PreviewLineSegment[];
-    positionFrom: Vector3;
-    positionTo: Vector3;
+    positionFrom: Vector3_2;
+    positionTo: Vector3_2;
     roomleLineFrom: KernelVector3;
     roomleLineTo: KernelVector3;
     roomlePositionFrom: KernelVector3;
@@ -7233,8 +8420,8 @@ export declare interface PreviewLineComponent extends PreviewComponent {
     lineMesh: Mesh;
     boundingLineMesh: RoomleEventedMesh;
     clonePreviewLine(cloneId: string): PreviewLineComponent;
-    getPositionForIntersectionPoint(intersectionPoint: Vector3): Vector3;
-    updatePreviewPosition(intersectionPoint: Vector3): void;
+    getPositionForIntersectionPoint(intersectionPoint: Vector3_2): Vector3_2;
+    updatePreviewPosition(intersectionPoint: Vector3_2): void;
     hideSelectionLine(): void;
 }
 
@@ -7277,6 +8464,13 @@ export declare class PromiseQueue<T> {
     get length(): number;
 }
 
+export declare interface Range_2 {
+    step: number;
+    type: string;
+    valueFrom: number;
+    valueTo: number;
+}
+
 export declare class RangeArray extends EmsArray<KernelRange> {
 }
 
@@ -8008,7 +9202,7 @@ export declare class RaycastHelper extends EventDispatcher<Record<RAYCAST_EVENT,
     private _onRotate;
     private _positionPlanes;
     private _calculateOffset;
-    update(bounds: Vector3 | null, rootComponentPosition: Vector3 | null, backgroundScene: Scene | null): void;
+    update(bounds: Vector3_2 | null, rootComponentPosition: Vector3_2 | null, backgroundScene: Scene | null): void;
     clear(): void;
     enableDragIn(mesh: RoomleEventedMesh): void;
     setRootComponentId(rootComponentId: number): void;
@@ -8018,18 +9212,30 @@ export declare class RaycastHelper extends EventDispatcher<Record<RAYCAST_EVENT,
     intersectMouseOnScene(event: Pick<PointerInputEvent, 'positionRelative'>): KernelVector3 | null;
     enableOnWallSnapping(): void;
     disableOnWallSnapping(): void;
-    getCameraPosition(): Vector3;
+    getCameraPosition(): Vector3_2;
 }
 
 export declare interface Rectangle {
     angle: number;
     center: KernelVector3f;
-    cornerPoints: PointArray_2;
-    referencePoints: RectangleReferencePoints;
+    cornerPoints: PointArray_3;
+    referencePoints: RectangleReferencePoints_2;
     size: KernelVector3f;
 }
 
 export declare interface RectangleReferencePoints {
+    bottom: Vector3;
+    bottomLeft: Vector3;
+    bottomRight: Vector3;
+    center: Vector3;
+    left: Vector3;
+    right: Vector3;
+    top: Vector3;
+    topLeft: Vector3;
+    topRight: Vector3;
+}
+
+export declare interface RectangleReferencePoints_2 {
     bottom: KernelVector3;
     bottomLeft: KernelVector3;
     bottomRight: KernelVector3;
@@ -8041,7 +9247,7 @@ export declare interface RectangleReferencePoints {
     topRight: KernelVector3;
 }
 
-export declare const removeExtObjIdPrefix: (id: ExtObjId_2) => string;
+export declare const removeExtObjIdPrefix: (id: ExtObjId) => string;
 
 export declare type RenderOptions = Partial<typeof DEFAULT_RENDER_OPTIONS>;
 
@@ -8057,6 +9263,10 @@ export declare const enum ResizingAnchor {
     Right = 8
 }
 
+export declare interface ResizingAnchor_2 {
+    value: Enumify_2<typeof CORE_RESIZING_ANCHOR>;
+}
+
 export declare class RoomDesignerApi implements RoomDesignerRequests {
     private _roomlePlanner;
     constructor(roomlePlanner: RoomlePlannerType);
@@ -9721,7 +10931,7 @@ export declare type RoomlePlannerType = RoomlePlanner | RoomlePlannerWithExtObjs
 export declare class RoomlePlannerUiCallback extends UiCallback implements ExternalObjectUiCallback {
     constructor(creator: string);
     onItemsLoaded: () => void;
-    onCameraChanged: (type: Enumify_4<typeof CAMERA_TYPE>) => void;
+    onCameraChanged: (type: Enumify<typeof CAMERA_TYPE>) => void;
     onCameraIdle: () => void;
     onTotalFloorAreaChanged: (totalFloorArea: number) => void;
     onPlanInteractionManagerCreated: (planInteractionManager: PlanInteractionManager) => void;
@@ -9759,7 +10969,7 @@ export declare class RoomlePlannerUiCallback extends UiCallback implements Exter
      * When an element in the plan has been added, removed or changed
      * null if changed, added or removed object is not a item or configuration, such as a wall or construction element
      */
-    onPlanElementChanged: (changeType: Enumify_4<typeof PLAN_ELEMENT_CHANGE_TYPES>, changedObject: UiPlanObject) => void;
+    onPlanElementChanged: (changeType: Enumify<typeof PLAN_ELEMENT_CHANGE_TYPES>, changedObject: UiPlanObject) => void;
     /**
      * When the plan has been completely loaded
      */
@@ -9896,7 +11106,7 @@ export declare abstract class RoomleRenderer<RendererType extends WebGLRenderer
     renderer: RendererType;
     protected isConfiguratorMode: boolean;
     protected isCameraMoving: boolean;
-    protected cameraType: Enumify_4<typeof CAMERA_TYPE>;
+    protected cameraType: Enumify<typeof CAMERA_TYPE>;
     protected shadowNeedsUpdate: boolean;
     protected boundingBox: Box3;
     protected boundingBoxNeedsUpdate: boolean;
@@ -9905,7 +11115,7 @@ export declare abstract class RoomleRenderer<RendererType extends WebGLRenderer
     dispose(): void;
     setSize(width: number, height: number): void;
     getSize(target: Vector2): Vector2;
-    setCameraType(cameraType: Enumify_4<typeof CAMERA_TYPE>): void;
+    setCameraType(cameraType: Enumify<typeof CAMERA_TYPE>): void;
     movingCameraStarts(): void;
     movingCameraStops(): void;
     forceShadowUpdates(_updateBakedGroundShadow: boolean): void;
@@ -10008,7 +11218,7 @@ export declare class RoomleWebGPURenderer extends RoomleRenderer<WebGPURenderer>
     clearCache(): void;
     disableUiInteractionMode(): void;
     enableUiInteractionMode(): void;
-    setCameraType(cameraType: Enumify_3<typeof CAMERA_TYPE>): void;
+    setCameraType(cameraType: Enumify<typeof CAMERA_TYPE>): void;
     switchToConfigurator(): void;
     switchToPlanner(renderMode: PlannerRenderMode): void;
     highlightObjects(selectedMeshes: Object3D_2[]): void;
@@ -10038,13 +11248,18 @@ export declare class RoomleWebGPURenderer extends RoomleRenderer<WebGPURenderer>
 export declare interface RoomLightSourceDistribution {
     ceilingId: number;
     floorId: number;
-    positionsInPlan: PointArray_2;
-    positionsRelativeToFloor: PointArray_2;
+    positionsInPlan: PointArray_3;
+    positionsRelativeToFloor: PointArray_3;
 }
 
 export declare class RoomLightSourceDistributionArray extends EmsArray<RoomLightSourceDistribution> {
 }
 
+export declare interface RoomWall {
+    roomSide: WallSide_2;
+    wall: Wall_2;
+}
+
 /**
  * Shared API between configurator and planner
  */
@@ -10179,7 +11394,7 @@ export declare abstract class SceneManager implements Context, LifeCycleCallback
     protected _isInteriorLightActive: boolean;
     protected _perspectiveOffsetCamera: PerspectiveOffsetCamera | null;
     protected _orthographicOffsetCamera: OrthographicOffsetCamera | null;
-    protected abstract createCameraControl(mode: Enumify_3<typeof CAMERA_TYPE>, offset: CanvasOffset): void;
+    protected abstract createCameraControl(mode: Enumify<typeof CAMERA_TYPE>, offset: CanvasOffset): void;
     protected abstract _getInputManager(): InputManager;
     get cameraBehaviour(): CameraBehaviour;
     protected _scheduleRenderLoopFunction(renderLoopFunction: () => void): void;
@@ -10193,7 +11408,7 @@ export declare abstract class SceneManager implements Context, LifeCycleCallback
     abstract getGeometryBounds(): Box3 | null;
     protected onBeforeRender(): void;
     protected _onAfterRender: () => void;
-    protected constructor(creator: string, offset: CanvasOffset, canvasID: string, mode: Enumify_3<typeof CAMERA_TYPE>);
+    protected constructor(creator: string, offset: CanvasOffset, canvasID: string, mode: Enumify<typeof CAMERA_TYPE>);
     addEventListener(_listener: LifeCycleCallbacks): void;
     removeEventListener(_listener: LifeCycleCallbacks): void;
     get lightCache(): LightCache | null;
@@ -10236,8 +11451,8 @@ export declare abstract class SceneManager implements Context, LifeCycleCallback
     cleanUp(): void;
     clearScene(): void;
     enableHD(source?: DynamicLightSettingSource): void;
-    protected _loadGLTF(gltfJSON: string, position?: Vector3, rotation?: number, size?: Vector3, scale?: Vector3, color?: number, callback?: (percent: number) => void): Promise<Object3D>;
-    protected _loadGLB(url: string, position?: Vector3, rotation?: number, size?: Vector3, scale?: Vector3, color?: number, colorable?: boolean, callback?: (percent: number) => void): Promise<Object3D>;
+    protected _loadGLTF(gltfJSON: string, position?: Vector3_2, rotation?: number, size?: Vector3_2, scale?: Vector3_2, color?: number, callback?: (percent: number) => void): Promise<Object3D>;
+    protected _loadGLB(url: string, position?: Vector3_2, rotation?: number, size?: Vector3_2, scale?: Vector3_2, color?: number, colorable?: boolean, callback?: (percent: number) => void): Promise<Object3D>;
     showGUI(): Promise<void>;
     protected initializeWebGLGUI(): void;
     protected initializeWebGPUGUI(roomleWebGPURenderer: RoomleWebGPURenderer): void;
@@ -10291,8 +11506,8 @@ export declare interface ScenePlugin extends ScenePluginHooks, Context {
 export declare interface ScenePluginHooks {
     updateBounds(bounds: Box3): void;
     clearScene(scene: Scene, uiScene: Scene): void;
-    moveCameraEnd(position: Vector3): void;
-    moveCameraStart(position: Vector3): void;
+    moveCameraEnd(position: Vector3_2): void;
+    moveCameraStart(position: Vector3_2): void;
     needsUiScene(): boolean;
 }
 
@@ -10301,7 +11516,7 @@ export declare interface SceneSettings {
     lights: DynamicLight[];
 }
 
-export declare type SceneShadingType = Enumify_2<typeof SCENE_SHADING_TYPES>;
+export declare type SceneShadingType = Enumify<typeof SCENE_SHADING_TYPES>;
 
 export declare interface ScriptData {
     name: string;
@@ -10365,6 +11580,8 @@ export declare class SinglePromiseFactory implements Context {
 export declare class SizeTArray extends EmsArray<number> {
 }
 
+export declare type SizeTArray_2 = EmscriptenArray<number>;
+
 export declare const SKY_EVENT: {
     readonly ENTERED_PLANNER: "sky:entered-planner";
     readonly ENTERED_CONFIGURATOR: "sky:entered-configurator";
@@ -10385,7 +11602,11 @@ export declare class SkyStateTracker extends EventDispatcher<SkyFeatureEventMap>
     notifyEnteredConfigurator(): void;
 }
 
-export declare const enum SnapMode {
+export declare interface SnapMode {
+    value: Enumify_2<typeof CORE_SNAP_MODE>;
+}
+
+export declare const enum SnapMode_2 {
     OFF = 0,
     ON_COLLISION = 1,
     ON_COLLISION_ROTATE_WITHIN_DISTANCE = 2,
@@ -10763,8 +11984,8 @@ export declare class UndoRedoHandler {
     private reset;
     undo(): void;
     redo(): void;
-    loadPlanXML(xml: string): Plan_2;
-    createPlanWithObjectFromItem(object: KernelObject, position: KernelVector3, rotationInRad: number): Plan_2;
+    loadPlanXML(xml: string): Plan_3;
+    createPlanWithObjectFromItem(object: KernelObject, position: KernelVector3, rotationInRad: number): Plan_3;
     endDrawing(point: {
         x: number;
         y: number;
@@ -10805,6 +12026,12 @@ export declare class UndoRedoHandler {
     onCoreLoad(reason: HiLoadObjectReason): void;
 }
 
+export declare interface UniqueIdAndHash {
+    hash: string;
+    libraryId: string;
+    uniqueId: string;
+}
+
 export declare const enum Unit {
     InchFeet = 0,
     MM = 1,
@@ -10922,6 +12149,8 @@ export declare const enum UnitType_2 {
     COUNT = 3
 }
 
+export declare type UnitTypeString = Enumify_3<typeof CORE_UNIT_TYPE_STRING>;
+
 export declare type UseIdbStore = <T>(txMode: IDBTransactionMode, callback: (store: IDBObjectStore) => T | PromiseLike<T>) => Promise<T>;
 
 export declare interface UserAction {
@@ -10955,6 +12184,16 @@ export declare interface VariantsList {
 export declare class Vector2fArray extends EmsArray<KernelVector2f> {
 }
 
+export declare interface Vector3 {
+    x: number;
+    y: number;
+    z: number;
+}
+
+export declare interface ViewType {
+    value: Enumify_3<typeof CORE_VIEW_TYPE>;
+}
+
 export declare class Wall extends PlanObjectPtr {
     readonly thickness: number;
     readonly height: number;
@@ -10980,6 +12219,36 @@ export declare class Wall extends PlanObjectPtr {
     getPointWithHeight(aHeight: number): KernelVector3f;
 }
 
+export declare interface Wall_2 extends PlanElement_2 {
+    new (): Wall_2;
+    getFrom(): Node_3;
+    getTo(): Node_3;
+    getAttachedAttics(): AtticArray;
+    getCornerFromLeft(): Vector3;
+    getCornerFromRight(): Vector3;
+    getCornerToLeft(): Vector3;
+    getCornerToRight(): Vector3;
+    getAngle(): number;
+    getLength(side: WallSide_2): number;
+    getSlopingLength(): number;
+    getPreferredSide(): WallSide_2;
+    getAttachedObjects(): ConstructionObjectSet_2;
+    getAttachedObjectsExtRefArray(): SizeTArray_2;
+    getCenter(): Vector3;
+    getHeightAt(aPoint: Vector3): number;
+    getPointWithHeight(aHeight: number): Vector3;
+    readonly meshThickness: number;
+    readonly isVectorWall: boolean;
+    readonly thickness: number;
+    readonly height: number;
+    readonly leftMaterial: WallMaterial_2;
+    readonly rightMaterial: WallMaterial_2;
+    readonly wallType: WallType;
+    readonly leftNormal: Vector3;
+    readonly rightNormal: Vector3;
+    readonly edgeType: EdgeType;
+}
+
 export declare const WALL_SIDES: {
     readonly LEFT: 0;
     readonly RIGHT: 1;
@@ -11002,7 +12271,7 @@ export declare interface WallDefinition {
     };
 }
 
-export declare type WallDimension = DimensionDefinition<Vector3, Vector3> & {
+export declare type WallDimension = DimensionDefinition<Vector3_2, Vector3_2> & {
     label?: string;
     measurementKind?: WallMeasurementKind;
     slopingMeasurement?: WallMeasurementVariant;
@@ -11020,9 +12289,17 @@ export declare interface WallExtensionType {
     ExtendBoth: EMSConstant;
 }
 
+export declare interface WallExtensionType_2 {
+    value: Enumify_2<typeof CORE_WALL_EXTENSION_TYPE>;
+}
+
 export declare class WallMaterial extends BaseMaterial {
 }
 
+export declare interface WallMaterial_2 extends BaseMaterial_2 {
+    new (): WallMaterial_2;
+}
+
 export declare type WallMeasurementKind = 'edge2d' | 'sloping';
 
 export declare interface WallMeasurementVariant {
@@ -11103,6 +12380,14 @@ export declare interface WallSide {
     value: Enumify<typeof WALL_SIDES>;
 }
 
+export declare interface WallSide_2 {
+    value: Enumify_2<typeof CORE_WALL_SIDE>;
+}
+
+export declare interface WallType {
+    value: Enumify_2<typeof CORE_WALL_TYPE>;
+}
+
 export declare const WEBGPU_TONE_MAPPINGS: {
     readonly NONE: "none";
     readonly LINEAR: "linear";
@@ -11393,7 +12678,7 @@ export declare interface WebGpuSSGIConfigDefinition {
     aoDenoiseRadius?: number;
 }
 
-export declare type WebGpuToneMapping = Enumify_3<typeof WEBGPU_TONE_MAPPINGS>;
+export declare type WebGpuToneMapping = Enumify<typeof WEBGPU_TONE_MAPPINGS>;
 
 export declare class WebGpuTopLightConfig implements WebGpuTopLightConfigDefinition {
     intensity: number;
@@ -11421,6 +12706,16 @@ export declare interface WebGpuTopLightConfigDefinition {
     shadowRadius?: number;
 }
 
+export declare const enum WORKER_MESSAGE {
+    PREFIX = 0,
+    INIT = 1,
+    ERROR = 2,
+    ASSET_LOADED = 3,
+    INIT_DONE = 4,
+    LOAD_ASSET = 5,
+    SW_CLAIMED_CONTROL = 6
+}
+
 export declare class ZoomChangeEvent {
     minZoom: boolean;
     maxZoom: boolean;
@@ -11430,18 +12725,10 @@ export declare class ZoomChangeEvent {
 export { }
 
 declare global {
-  // @ts-ignore -- just for testing
-  const THREE: typeof __THREE; // eslint-disable-line
-  // @ts-ignore -- just for testing
-  const dat: typeof __dat; // eslint-disable-line
-  // @ts-ignore -- just for testing
-  const WebAssembly: any; // eslint-disable-line
   interface Window {
     KernelCallback?: { isReady: () => void } | null;
-    __RML_WEBGL_GUI__: GUI; // eslint-disable-line
     __RML__DEBUG__?: Debug;
     __RML__ENV__?: ExternalEnv;
-    _rsl: { [key: string]: ThreeShader };
     THREE?: any;
   }
 }