@roomle/web-sdk 3.6.0 → 3.7.0-alpha.2

package/lib/roomle-sdk.d.ts

@@ -1,26 +1,18 @@
-import { Blending } from 'three';
-import { BlendingDstFactor } from 'three';
-import { BlendingEquation } from 'three';
-import { BlendingSrcFactor } from 'three';
 import { Box3 } from 'three';
 import { BufferGeometry } from 'three';
 import { BufferGeometryEventMap } from 'three';
 import { Camera } from 'three';
 import { Color } from 'three';
-import { ColorRepresentation } from 'three';
 import { CommunicationInterfaceCallback } from '../../../workers/src/communication-interface';
 import { ConstructionObjectDoorArchArray } from 'roomle-core-hsc/src/embind/plannerCoreInterface';
 import { createExtObjId } from '../../../../../common/src/utils/external-objects';
-import { EffectComposer } from 'three/examples/jsm/postprocessing/EffectComposer.js';
 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 { Enumify as Enumify_5 } 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 { FullScreenQuad } from 'three/examples/jsm/postprocessing/Pass.js';
 import { Group } from 'three';
 import { GUI } from 'dat.gui';
 import { HiCallbacks } from '../../../../common/src/hi/hi-types';
@@ -29,35 +21,24 @@ import { HiOrderHeader } from '../../../../common/src/hi/hi-types';
 import { Intersection } from 'three';
 import { Layers } from 'three';
 import { Light } from 'three';
-import { MagnificationTextureFilter } from 'three';
 import { Material } from 'three';
-import { Matrix3 } from 'three';
-import { Matrix4 } from 'three';
 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 { Nullable as Nullable_3 } from '../../../../../../../common/src/utils/types';
 import { Object3D } from 'three';
 import { Object3DEventMap } from 'three';
 import { OrthographicCamera } from 'three';
-import { Pass } from 'three/examples/jsm/postprocessing/Pass.js';
 import { PerspectiveCamera } from 'three';
 import { PointLight } from 'three';
-import { RectAreaLight } from 'three';
 import { Scene } from 'three';
-import { ShaderMaterial } from 'three';
-import { ShadowMapType } from 'three';
 import { Texture } from 'three';
-import { TextureFilter } from 'three';
 import { TextureLoader } from 'three';
 import { Vector2 } from 'three';
 import { Vector3 } from 'three';
-import { Vector4 } from 'three';
 import { WebGLRenderer } from 'three';
-import { WebGLRenderTarget } from 'three';
 import { WebGPURenderer } from 'three/webgpu';
 import { WORKER_MESSAGE } from '../../../workers/src/communication-interface';
 
@@ -140,74 +121,6 @@ export declare class AnimationValueMap {
     getSequentAnimations(animationName: string, level: number): string[];
 }
 
-export declare const AO_ALGORITHMS: {
-    readonly SSAO: 0;
-    readonly SAO: 1;
-    readonly N8AO: 2;
-    readonly HBAO: 3;
-    readonly GTAO: 4;
-};
-
-export declare type AoAlgorithmType = Enumify_5<typeof AO_ALGORITHMS> | null;
-
-export declare interface AOPassParameters {
-    aoParameters?: AORenderPassParameters;
-    normalVectorSourceType?: NormalVectorSourceType;
-    depthValueSourceType?: DepthValueSourceType;
-    modulateRedChannel?: boolean;
-    depthTexture?: Texture;
-    normalTexture?: Texture;
-}
-
-export declare class AORenderPass {
-    needsUpdate: boolean;
-    parameters: AORenderPassParameters;
-    private _width;
-    private _height;
-    private _samples;
-    private _gBufferAntiAliasing;
-    private _normalVectorSourceType;
-    private _depthValueSourceType;
-    private _modulateRedChannel;
-    depthTexture: Texture | null;
-    normalTexture: Texture | null;
-    private _noiseTexture;
-    private _aoMaterial?;
-    private _renderTarget;
-    private _passRenderer;
-    private _sceneClipBox;
-    private _sceneScale;
-    get texture(): Texture | null;
-    constructor(width: number, height: number, samples: number, gBufferAntiAliasing: boolean, parameters?: AOPassParameters);
-    private _getNoiseTexture;
-    private _getMaterial;
-    private _newAoMaterial;
-    private _updateShader;
-    private _updateUniforms;
-    private _getRenderTargets;
-    dispose(): void;
-    setSize(width: number, height: number): void;
-    updateBounds(sceneClipBox: Box3, sceneScale?: number): void;
-    updateParameters(parameters: AORenderPassParameters): void;
-    updateTextures(parameters: AOPassParameters): void;
-    clear(renderer: WebGLRenderer, renderTarget?: WebGLRenderTarget): void;
-    render(renderer: WebGLRenderer, camera: Camera, _scene: Scene, renderTarget?: WebGLRenderTarget): void;
-}
-
-export declare interface AORenderPassParameters {
-    [key: string]: any;
-    resolutionScale: number;
-    algorithm: AoAlgorithmType;
-    samples: number;
-    radius: number;
-    distanceExponent: number;
-    thickness: number;
-    distanceFallOff: number;
-    scale: number;
-    bias: number;
-    screenSpaceRadius: boolean;
-}
-
 /**
  * Currently this is a Configurator-specific App State, not a generic one.
  * If we need it for other modules, we should create separate interfaces per context.
@@ -259,7 +172,7 @@ export declare interface AtticDimension<Vector2Type = Vector3 | Position2, Vecto
     /** Center position of the attic in 3D **/
     atticCenterPosition3d?: Vector3Type;
     /** Wall center position in 3D, representing the reference point for attic placement **/
-    wallCenterPosition3d: Vector3Type;
+    wallCenterPosition3d?: Vector3Type;
     /** Start position of the attic in 2D (screen coordinates) **/
     fromPosition2d?: Vector2Type;
     /** End position of the attic in 2D (screen coordinates) **/
@@ -267,15 +180,15 @@ export declare interface AtticDimension<Vector2Type = Vector3 | Position2, Vecto
     /** Center position of the attic in 2D, used for screen rendering **/
     atticCenterPosition2d?: Vector2Type;
     /** Wall center position in 2D, serving as the reference for attic placement in screen space **/
-    wallCenterPosition2d: Vector2Type;
+    wallCenterPosition2d?: Vector2Type;
     /** Position of the attic text label in 3D space **/
-    textPosition3d: Vector3Type;
+    textPosition3d?: Vector3Type;
     /** Position of the attic text label in 2D screen space **/
-    textPosition2d: Vector2Type;
+    textPosition2d?: Vector2Type;
     /** Rotation angle of the attic text label in degrees **/
-    textRotation: number;
+    textRotation?: number;
     /** Rotation angle from attic start to end positions **/
-    atticFromToRotation: number;
+    atticFromToRotation?: number;
     /** Position of the attic label "C" in 3D space **/
     labelCPosition3d?: Vector3Type;
     /** Position of the attic label "C" in 2D screen space **/
@@ -302,81 +215,6 @@ export declare interface AtticDimension<Vector2Type = Vector3 | Position2, Vecto
     attic2mCornerto2d?: Vector2Type;
 }
 
-export declare interface BakedGroundContactShadowConstructorParameters {
-    sharedShadowGroundPlane?: ShadowGroundPlane;
-    shadowMapSize?: number;
-    enabled?: boolean;
-    cameraHelper?: boolean;
-    alwaysUpdate?: boolean;
-    fadeIn?: boolean;
-    blurMin?: number;
-    blurMax?: number;
-    fadeoutFalloff?: number;
-    fadeoutBias?: number;
-    opacity?: number;
-    maximumPlaneSize?: number;
-    planeSize?: number;
-    cameraFar?: number;
-    hardLayers?: Layers | null;
-    softLayers?: Layers | null;
-    polygonOffset?: number;
-}
-
-export declare interface BakedGroundContactShadowParameters {
-    [key: string]: any;
-    enabled: boolean;
-    cameraHelper: boolean;
-    alwaysUpdate: boolean;
-    fadeIn: boolean;
-    blurMin: number;
-    blurMax: number;
-    fadeoutFalloff: number;
-    fadeoutBias: number;
-    opacity: number;
-    maximumPlaneSize: number;
-    planeSize: number;
-    cameraFar: number;
-    hardLayers: Layers | null;
-    softLayers: Layers | null;
-    polygonOffset: number;
-}
-
-export declare class BakedGroundContactShadowPass extends RenderPass {
-    static addTestMesh: boolean;
-    shadowMapSize: number;
-    limitPlaneSize: boolean;
-    parameters: BakedGroundContactShadowParameters;
-    private _renderer;
-    needsUpdate: boolean;
-    noNeedOfUpdateCount: number;
-    private _blurScale;
-    private _shadowScale;
-    private _groundGroup;
-    private _groundShadowFar;
-    private _sharedShadowGroundPlane?;
-    private _shadowGroundPlane?;
-    private _groundContactCamera;
-    private _renderTargetBlur;
-    private _blurPass;
-    readonly renderTarget: WebGLRenderTarget;
-    private _depthMaterial;
-    get shadowGroundPlane(): ShadowGroundPlane;
-    constructor(renderPassManager: RenderPassManager, renderer: WebGLRenderer | WebGPURenderer, groundGroup: Group, parameters: BakedGroundContactShadowConstructorParameters);
-    private _getDefaultParameters;
-    dispose(): void;
-    updateParameters(parameters: BakedGroundContactShadowParameters): void;
-    applyParameters(): void;
-    setScale(groundContactShadowScale: number, _shadowScale?: number): void;
-    updateBounds(sceneBounds: SceneVolume, groundLevel?: number): void;
-    updatePlaneAndShadowCamera(): void;
-    setGroundVisibilityLayers(visible: boolean): void;
-    renderPass(renderer: WebGLRenderer | WebGPURenderer): void;
-    private _renderGroundContact;
-    private _renderBlur;
-    private _renderReduceBandingBlur;
-    private _renderBlurPass;
-}
-
 export declare interface Base64Image {
     image: Base64String;
     width: number;
@@ -431,18 +269,6 @@ export declare interface BatchPaintMaterial {
     catalogItemId?: RapiId;
 }
 
-export declare interface BlendAoAndAShadowMaterialParameters {
-    texture?: Nullable_3<Texture>;
-    blending?: Blending;
-    aoIntensity?: number;
-    shadowIntensity?: number;
-}
-
-export declare interface BlendAoPassDepthMaterialParameters {
-    texture?: Nullable_3<Texture>;
-    blending?: Blending;
-}
-
 export declare class CacheHolder {
     private _componentCache;
     private _geometryCache;
@@ -456,8 +282,6 @@ export declare class CacheHolder {
     setupLightCache(scene: Scene, maxAnisotropy: number): void;
 }
 
-export declare type CacheKey = any;
-
 export declare type CallbackObjectType = 'static' | 'configuration' | 'wall' | 'measure' | 'attic' | 'door' | 'floor' | 'window' | 'unknown' | 'external-configuration';
 
 export declare const enum CAMERA_EVENT {
@@ -514,6 +338,7 @@ export declare abstract class CameraControl extends EventDispatcher<CameraEventM
     protected _tweenEnd: CameraParameter | null;
     private _stateSaved;
     private _cameraStandingStill;
+    private _destroyed;
     protected _pitch: number;
     protected _yaw: number;
     protected _distance: number;
@@ -803,7 +628,7 @@ export declare class CatalogItemPtrList extends EmsList<CatalogItem> {
 export declare class CeilingLight extends PointLight {
     private _container;
     private _shouldCastShadow;
-    getContainer(): Mesh;
+    getContainer(): Mesh | null;
     get shouldCastShadow(): boolean;
     constructor(debug: boolean, maxQualityLevel: QualityLevel);
     recalculatePower(amountOfLights: number): void;
@@ -1002,7 +827,7 @@ export declare interface CommonInitData {
      */
     maxLightSources?: number;
     /**
-     * @description Use old light setting instead of env maps
+     * @description Use old light setting instead of env maps. Ignored when using the WebGPU renderer
      * @groups scene-settings
      */
     legacyLight?: boolean;
@@ -1097,6 +922,7 @@ export declare abstract class CommonKernelAccess implements LifeCycleCallbacks,
     protected _shouldWait: boolean;
     protected _kernelPath: string;
     protected _useWASM: boolean;
+    private _registeredCallbackTarget;
     protected _utilityToLongArray(longArray: number[]): any;
     protected abstract onLoadComponentError(error: Error, id: RapiId): void;
     constructor(creator: string);
@@ -1139,6 +965,7 @@ export declare abstract class CommonKernelAccess implements LifeCycleCallbacks,
     removeConfiguratorListener(listener: ConfiguratorKernelCallbackI): void;
     cleanUpCallbacks(): void;
     requestMaterialProperties(materialIds: RapiId[]): Promise<void>;
+    protected _buildCallbackTarget(): this;
     protected registerCallbacks(): void;
     pause(): void;
     resume(): void;
@@ -1180,7 +1007,7 @@ export declare class ComponentRaycastHelper {
     init(object: Object3D, camera: PerspectiveCamera): void;
     setCamera(camera: PerspectiveCamera): void;
     setObject(object: Object3D): void;
-    changeMaterialsOnSelect(object: Object3D, component: RoomleComponent, selected?: boolean, callback?: () => void): void;
+    changeMaterialsOnSelect(object: Object3D, component: RoomleComponent | null, selected?: boolean, callback?: () => void): void;
     private _changeMaterialsOnSelect;
     isComponentVisible(component: RoomleComponent): boolean;
     checkComponentAndPreviewVisibility(sceneEventHandler: ConfiguratorSceneEventHandler, configuratorViewModel: ConfiguratorViewModel): void;
@@ -1446,7 +1273,7 @@ export declare class ConfiguratorKernelAccess extends CommonKernelAccess {
     private _addAnimationParameters;
     private _updateComponentParameters;
     selectionChange(componentId: number, isRoot: boolean): void;
-    protected _componentSelectionChanged(_planObject: PlanObjectKernel, _component: KernelComponent, _planComponentSelection: boolean): void;
+    protected _componentSelectionChanged(_planObject: PlanObjectKernel, _component: KernelComponent): void;
     protected _externalObjectParameterChanged(_objectOrComponentId: number, _parameterKey: string, _value: string): void;
     multiSelectionChange(runtimeComponentIds: number[], rootComponentId: number): void;
     private _updateCommonComponentDependencies;
@@ -1483,7 +1310,7 @@ export declare class ConfiguratorKernelAccess extends CommonKernelAccess {
     isReady(): void;
     protected _setupKernel(): void;
     onLoadComponentError(error: Error, id: RapiId): void;
-    configurationLoaded(conversationId: number, objectId: number, componentId: number, hash: string, errors: EmscriptenString[], _valid: boolean): void;
+    configurationLoaded(conversationId: number, objectId: number, componentId: number, hash: string, errors: EmscriptenString[], _valid: boolean, isFreeFlying: boolean): void;
     componentDefinitionLoaded(_conversationId: number, componentId: number): void;
     componentDefinitionLoadingError(_conversationId: number, errorMessage: string): void;
     configurationLoadingError(_runtimeId: number, errors?: EmscriptenString[]): void;
@@ -1560,7 +1387,7 @@ export declare interface ConfiguratorKernelCallbackI extends CommonConfiguratorK
     planObjectCreated(conversationId: number, planObjectId: number): void;
     planObjectUpdated(planObject: PlanObjectKernel, pendingDocking: boolean): void;
     planObjectConfigurationUpdated(planObjectId: number, configuration: ConfigurationString, hash: string, pendingDocking: boolean): void;
-    configurationLoaded(conversationId: number, objectId: number, componentId: number, hash: string, errors: any): void;
+    configurationLoaded(conversationId: number, objectId: number, componentId: number, hash: string, errors: any, isFreeFlying: boolean): void;
     Editor3dAddDockPreview(componentId: number, previewId: number): void;
     Editor3dSetPreviewAssociations(dockPairs: KernelDockPairPreview[], previewId: number): void;
     Editor3dPreviewConstructionDone(componentId: number, objectId: number): void;
@@ -1585,6 +1412,9 @@ export declare interface ConfiguratorKernelClass {
     loadPlainComponent(conversationId: number, componentId: RapiId, configuration: ConfigurationString): void;
     loadFreeFlyingConfiguration(conversationId: number, configuration: ConfigurationString): void;
     loadFreeFlyingExternalObject(conversationId: number, targetObjectId: number, serializedConfiguration: 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 | AssetResponse[]): void;
     deleteComponent(componentId: number, redockChildrenToParent: boolean): void;
     deleteMultipleComponents(componentIds: any): void;
@@ -1608,7 +1438,6 @@ export declare interface ConfiguratorKernelClass {
     getComponent(componentId: number): KernelComponent;
     getComponentId(componentId: number): RapiId;
     isExternalPlanObject(objectOrPlanComponentId: number): boolean;
-    getExternalComponentModuleIds(objectOrPlanComponentId: number): ExternalModuleInformation;
     getComponentOrModuleInformation(objectOrPlanComponentId: number): KernelObjectInformation;
     getExternalObjectAttribute(objectOrPlanComponentId: number, attributeKey: string, value: string): ExternalAttributeInformation;
     getPlanObject(planObjectId: number): PlanObjectKernel;
@@ -1713,7 +1542,7 @@ export declare class ConfiguratorSceneEventHandler extends SceneEventHandler<Sce
     addPreviewLineHandlers(component: PreviewLineComponent, requestRenderSceneUpdateCallback?: () => void): void;
     private _clickPreview;
     private _clickPreviewLine;
-    clickComponent(component: RoomleComponent, triggerClickCallback?: boolean): void;
+    clickComponent(component: RoomleComponent, componentIsClicked?: boolean): void;
     private _clickOutside;
     private _hoverOn;
     private _hoverOff;
@@ -1730,7 +1559,7 @@ export declare class ConfiguratorSceneEventHandler extends SceneEventHandler<Sce
     private _dragEnd;
     protected _interaction(forceRender?: boolean): void;
     hasSelection(): boolean;
-    update(bounds: Vector3, rootComponentPosition: Vector3, backgroundScene: Scene): void;
+    update(bounds: Vector3 | null, rootComponentPosition: Vector3 | null, backgroundScene: Scene | null): void;
     isDragIn(): boolean;
     isDragging(): boolean;
     setRootComponentId(rootComponentId: number): void;
@@ -1832,7 +1661,7 @@ export declare class ConfiguratorSceneManager extends SceneManager implements Co
     protected enablePanning(): void;
     protected disablePanning(): void;
     cancelPreviousDockings(): void;
-    cancelComponentSelection(resetCamera?: boolean, reason?: CancelSelectionReasons): void;
+    cancelComponentSelection(resetCamera: boolean, reason?: CancelSelectionReasons): void;
     protected notifyPlannerOnComponentSelectionCancel(_isExternalObject: boolean, _reason: CancelSelectionReasons): void;
     private _cancelSelection;
     private _selectComponent;
@@ -1879,10 +1708,10 @@ export declare class ConfiguratorSceneManager extends SceneManager implements Co
     saveConfigToIdb(): void;
     protected _getInputManager(): InputManager;
     protected createCameraControl(_mode: Enumify_3<typeof CAMERA_TYPE>, offset: CanvasOffset): void;
-    getBounds(): Box3;
-    getGeometryBounds(): Box3;
+    getBounds(): Box3 | null;
+    getGeometryBounds(): Box3 | null;
     sceneChanged(): void;
-    protected get configuratorCameraBehaviour(): ConfiguratorCameraBehaviour;
+    protected get configuratorCameraBehaviour(): ConfiguratorCameraBehaviour | null;
     protected get cameraBehaviour3d(): CameraBehaviour3d;
     protected _onCameraIdle(): boolean;
     protected _onCameraMove(): boolean;
@@ -1928,7 +1757,7 @@ export declare class ConfiguratorUiCallbacks extends UiCallback implements Confi
      * @param tags
      * @param defaultChild
      */
-    onUpdatePossibleChildren: (tags: UiPossibleChildTag[], defaultChild: UiPossibleChild) => void;
+    onUpdatePossibleChildren: (tags: UiPossibleChildTag[], defaultChild: UiPossibleChild | undefined) => void;
     /**
      * When the price of a configuration/item changes, this event is triggered
      * on start up and when a configuration changes
@@ -2262,7 +2091,7 @@ export declare class ConfiguratorViewModel implements ConfiguratorKernelCallback
     componentMetaUpdated(kernelComponent: KernelComponent): void;
     componentConfigurationUpdated(runtimeComponentId: number, geometryChanged: boolean): void;
     private _getRuntimeComponent;
-    configurationLoaded(conversationId: number, objectId: number, componentId: number, _hash: string, _errors: any): void;
+    configurationLoaded(conversationId: number, objectId: number, componentId: number, _hash: string, _errors: any, isFreeFlying: boolean): void;
     finishParameterChange(resolve: () => void, _reject: () => void): void;
     planObjectConfigurationUpdated(planObjectId: number, _configuration: ConfigurationString, _hash: string, pendingDocking: boolean): void;
     planObjectCreated(_conversationId: number, configurationRuntimeId: number): void;
@@ -2365,7 +2194,7 @@ export declare class ConstructionTopView extends Object3D {
     private _topSlidingBar2;
     private _debugCircles;
     private _planElement;
-    private _rapiItem;
+    private _rapiItem?;
     constructor(planElement: ConstructionPlanObject, rapiItem?: RapiItem);
     private _init;
     setTopView(enabled: boolean): void;
@@ -2392,21 +2221,6 @@ export declare interface ContinuousDrawingManager {
     CIRCLE_RADIUS: number;
 }
 
-export declare interface CopyTransformMaterialParameters {
-    texture?: Texture | null;
-    colorTransform?: Matrix4;
-    colorBase?: Vector4;
-    multiplyChannels?: number;
-    uvTransform?: Matrix3;
-    blending?: Blending;
-    blendSrc?: BlendingSrcFactor | BlendingDstFactor;
-    blendDst?: BlendingDstFactor;
-    blendEquation?: BlendingEquation;
-    blendSrcAlpha?: BlendingSrcFactor;
-    blendDstAlpha?: BlendingDstFactor;
-    blendEquationAlpha?: BlendingEquation;
-}
-
 export declare const CORE_ASSET_TYPE: {
     readonly ITEM: 0;
     readonly COMPONENT: 1;
@@ -2442,6 +2256,7 @@ export declare const CORE_PLAN_COMPONENT_TYPE: {
     readonly COMPONENT: 1;
     readonly ROOT_MODULE: 2;
     readonly SUB_MODULE: 3;
+    readonly SUB_ARTICLE: 4;
 };
 
 export declare const CORE_TYPE_OF_CORE_ID: {
@@ -2467,7 +2282,7 @@ export declare class CSS2DRendererManager implements Context {
     renderSnapshotToCanvasWithAspectRatio(scene: Scene, camera: Camera, aspectRatio: number): Promise<HTMLCanvasElement>;
     private getCanvasDimensionsForAspectRatio;
     renderSnapshotToCanvas(scene: Scene, camera: Camera): Promise<HTMLCanvasElement>;
-    render(scene: Scene, camera: Camera): void;
+    render(scene: Scene, camera: Camera | null | undefined): void;
     private logNotInitializedWarning;
     private injectStyles;
 }
@@ -2524,24 +2339,6 @@ export declare interface DebugClient {
     debugValueMapChange(changes: DebugValueMapChange): void;
 }
 
-export declare class DebugPass extends RenderPass {
-    private _environmentMapDecodeMaterial;
-    private _copyMaterial?;
-    private _blendAoAndShadowMaterial?;
-    private _blendAoPassDepthMaterial?;
-    private _srgbToLinearCopyMaterial?;
-    private _depthRenderMaterial?;
-    debugOutput: string;
-    constructor(renderPassManager: RenderPassManager);
-    dispose(): void;
-    protected getCopyMaterial(parameters?: CopyTransformMaterialParameters): ShaderMaterial;
-    protected getBlendAoAndShadowMaterial(parameters?: BlendAoAndAShadowMaterialParameters): ShaderMaterial;
-    protected getBlendAoPassDepthMaterial(parameters?: BlendAoPassDepthMaterialParameters): ShaderMaterial;
-    protected getSrgbToLinearCopyMaterial(parameters?: CopyTransformMaterialParameters): ShaderMaterial;
-    private _getDepthRenderMaterial;
-    renderPass(renderer: WebGLRenderer): void;
-}
-
 export declare interface DebugValueMapChange {
     sourceId: number;
     sourceInfo: string;
@@ -2571,21 +2368,6 @@ export declare const DEFAULT_RENDER_OPTIONS: {
 
 export declare type DefaultEnvironmentSceneType = Enumify_2<typeof DEFAULT_ENVIRONMENT_SCENE_TYPES> | null;
 
-export declare interface DenoisePass {
-    get texture(): Texture | null;
-    set inputTexture(texture: Texture | null);
-    dispose(): void;
-    setSize(width: number, height: number): void;
-    render(renderer: WebGLRenderer | WebGPURenderer, camera: Camera): void;
-}
-
-export declare const DEPTH_VALUE_SOURCE_TYPES: {
-    readonly SEPARATE_BUFFER: "separateBuffer";
-    readonly NORMAL_VECTOR_ALPHA: "normalVectorAlpha";
-};
-
-export declare type DepthValueSourceType = Enumify_5<typeof DEPTH_VALUE_SOURCE_TYPES>;
-
 export declare interface DimensionDefinition<Vector2Type = Vector3 | Position2, Vector3Type = Vector3 | Position3> extends MeasurementBase<Vector2Type, Vector3Type> {
     id: number;
     lengthFormatted: string;
@@ -3202,6 +2984,7 @@ export declare interface ExternalObjectApiConfiguration {
     uiConfiguration?: ExternalObjectUiConfiguration;
     materialConfiguration?: ExternalObjectMaterialConfiguration;
     debugConfiguration?: ExternalObjectDebugConfiguration;
+    overlayUiDrawer?: boolean;
 }
 
 export declare interface ExternalObjectContour {
@@ -3267,13 +3050,13 @@ export declare interface ExternalObjectSegment {
 }
 
 export declare interface ExternalObjectSnapshotData {
-    orderData: HiOrderData;
+    orderData: HiOrderData | null | undefined;
     planXML: string;
-    objectGlb: string;
-    perspectiveImage: string;
-    topImage: string;
-    perspectiveObjectImage: string;
-    topObjectImage: string;
+    objectGlb: string | undefined;
+    perspectiveImage: string | undefined;
+    topImage: string | undefined;
+    perspectiveObjectImage: string | undefined;
+    topObjectImage: string | undefined;
 }
 
 export declare interface ExternalObjectSnapshotSaveResult {
@@ -3423,63 +3206,7 @@ export declare class FloorPlanElementViewModel extends PlanElementViewModel {
     private calculateTextVisibility;
 }
 
-export declare interface GBufferParameters {
-    [key: string]: any;
-    depthNormalScale: number;
-}
-
-export declare class GBufferRenderPass extends RenderPass implements GBufferTextures {
-    parameters: GBufferParameters;
-    readonly floatRgbNormalAlphaDepth: boolean;
-    readonly linearDepth: boolean;
-    copyToSeparateDepthBuffer: boolean;
-    private _gBufferMaterialCache?;
-    private _targetMinificationTextureFilter;
-    private _targetMagnificationTextureFilter;
-    private _width;
-    private _height;
-    private _samples;
-    private _gBufferRenderMaterial?;
-    private _depthNormalRenderTarget?;
-    private _separateDeptRenderTarget?;
-    private _copyMaterial?;
-    private _shared;
-    needsUpdate: boolean;
-    drawGround: boolean;
-    set groundDepthWrite(value: boolean);
-    get isFloatGBufferWithRgbNormalAlphaDepth(): boolean;
-    get gBufferTexture(): Texture;
-    get depthBufferTexture(): Texture;
-    get textureWithDepthValue(): Texture;
-    updateGBufferRenderMaterial(camera: Camera): Material;
-    get depthNormalRenderTarget(): WebGLRenderTarget;
-    get separateDeptRenderTarget(): WebGLRenderTarget;
-    constructor(renderPassManager: RenderPassManager, parameters?: GBufferRenderTargetsParameters);
-    dispose(): void;
-    setSize(width: number, height: number): void;
-    renderPass(renderer: WebGLRenderer | WebGPURenderer): void;
-    private _renderGBuffer;
-    protected getCopyMaterial(parameters?: CopyTransformMaterialParameters): ShaderMaterial;
-    private _copyDepthToSeparateDepthTexture;
-}
-
-export declare interface GBufferRenderTargetsParameters {
-    capabilities?: any;
-    textureMinificationFilter?: TextureFilter;
-    textureMagnificationFilter?: MagnificationTextureFilter;
-    width?: number;
-    height?: number;
-    samples?: number;
-    shared?: boolean;
-    depthNormalScale?: number;
-}
-
-export declare interface GBufferTextures {
-    get isFloatGBufferWithRgbNormalAlphaDepth(): boolean;
-    get gBufferTexture(): Texture;
-    get depthBufferTexture(): Texture;
-    get textureWithDepthValue(): Texture;
-}
+export declare type GenericRoomleRenderer = RoomleRenderer<WebGLRenderer | WebGPURenderer>;
 
 export declare const enum GEOMETRY {
     CUBE = "cube",
@@ -3627,6 +3354,12 @@ export declare interface GlobalInitDataDefinition {
      * @default false
      */
     lockPlan?: boolean;
+    /**
+     * @description If set to true, the plan is in read-only mode. Hides all editing UI and prevents interaction with plan elements.
+     * Automatically sets edit=false and lockPlan=true and saveToIdb=false
+     * @default false
+     */
+    readonly?: boolean;
 }
 
 export declare interface GlueLogic {
@@ -3659,70 +3392,13 @@ export declare interface GlueLogic {
     removedGroup(groupId: string): void;
     openCloseGroup(groupId: string): void;
     getSaveDataGroups(): Promise<PosGroup[] | null>;
+    getSubArticleId(id: string): string | undefined;
     newPosDataFromId(id: string): Promise<PosGroup | undefined>;
     newPosDataFromGroup(posDataJson: PosGroup): Promise<PosGroup>;
     getGroupDataForOrder(roomlePlannerId?: string): Promise<HiOrderData | null>;
     getMaterialUrl(materialId: string, groupOrModuleId?: string): string | null;
 }
 
-export declare interface GroundReflectionConstructorParameters {
-    enabled?: boolean;
-    intensity?: number;
-    fadeOutDistance?: number;
-    fadeOutExponent?: number;
-    brightness?: number;
-    blurHorizontal?: number;
-    blurVertical?: number;
-    blurAscent?: number;
-    groundLevel?: number;
-    groundReflectionScale?: number;
-    renderTargetDownScale?: number;
-}
-
-export declare interface GroundReflectionParameters {
-    [key: string]: any;
-    enabled: boolean;
-    intensity: number;
-    fadeOutDistance: number;
-    fadeOutExponent: number;
-    brightness: number;
-    blurHorizontal: number;
-    blurVertical: number;
-    blurAscent: number;
-    groundLevel: number;
-    groundReflectionScale: number;
-    renderTargetDownScale: number;
-}
-
-export declare class GroundReflectionPass extends RenderPass {
-    private _width;
-    private _height;
-    private _samples;
-    parameters: GroundReflectionParameters;
-    reflectionFadeInScale: number;
-    private _reflectionRenderTarget?;
-    private _intensityRenderTarget?;
-    private _blurRenderTarget?;
-    private _blurPass;
-    private _reflectionIntensityMaterial;
-    private _copyMaterial;
-    get reflectionRenderTarget(): WebGLRenderTarget;
-    get intensityRenderTarget(): WebGLRenderTarget;
-    get blurRenderTarget(): WebGLRenderTarget;
-    constructor(renderPassManager: RenderPassManager, width: number, height: number, samples: number, parameters: GroundReflectionConstructorParameters);
-    private _newRenderTarget;
-    dispose(): void;
-    setSize(width: number, height: number): void;
-    updateParameters(parameters: GroundReflectionParameters): void;
-    updateBounds(groundLevel: number, groundReflectionScale: number): void;
-    private _updateCopyMaterial;
-    renderPass(renderer: WebGLRenderer | WebGPURenderer): void;
-    private _renderGroundReflection;
-    private _renderGroundReflectionIntensity;
-    blurReflection(renderer: WebGLRenderer, camera: Camera, renderTargets: WebGLRenderTarget[]): void;
-    private _createGroundReflectionCamera;
-}
-
 export declare class HdrEnvironmentLoader implements Context {
     _creator_: string;
     private _environmentMap;
@@ -3914,17 +3590,19 @@ export declare class IdbManager implements Context {
 
 export declare type ImageKeysOnObject = 'perspectiveImage' | 'topImage';
 
-export declare class ImageRenderer {
-    private _creator_;
+export declare class ImageRenderer implements Context {
+    _creator_: string;
     private _roomleRenderer;
     private _imageRenderer;
     private _thumbnailCamera;
     private _globalInitData;
+    private _initData;
     private _css2DRendererManager;
+    constructor(creator: string);
     private _getRenderer;
-    switchToPlannerSettings(): void;
-    switchToConfiguratorSettings(): void;
-    updateBounds(bounds: Box3): void;
+    switchToPlannerSettings(): Promise<void>;
+    switchToConfiguratorSettings(): Promise<void>;
+    updateBounds(bounds: Box3): Promise<void>;
     static getCameraTargetForBBox(bbox: Box3, spacing?: number): CameraTarget;
     preparePerspectiveImage(scene: Scene, camera: PerspectiveCamera, cameraTarget?: CameraTarget, options?: PrepareImageOptions, onBeforeRender?: (camera: Camera) => void): Promise<Base64Image>;
     static placeCameraForPerspectiveImage(camera: PerspectiveCamera, cameraTarget: CameraTarget, angleX: number, angleY: number): void;
@@ -4012,6 +3690,7 @@ export declare class InitData implements Context, Omit<InitDataDefinition, 'colo
     edit?: boolean;
     moc?: boolean;
     lockPlan: boolean;
+    readonly?: boolean;
     externalObjectSettings?: ExternalObjectApiConfiguration;
     /**
      * If true, the callbacks will only be called if the geometry is ready.
@@ -4153,6 +3832,16 @@ export declare class InputManager extends EventDispatcher<InputEventMap> impleme
     updateSize(): void;
 }
 
+export declare interface InsertItemIdInfo {
+    id: RapiId | ExtObjId;
+    index: number;
+}
+
+export declare interface InsertItemResult {
+    runtimeId: RuntimeId;
+    originalIndex: number;
+}
+
 export declare class IntArray extends EmsArray<number> {
 }
 
@@ -4405,7 +4094,7 @@ export declare interface KernelMessageMetaInfo {
 export declare type KernelMessageType = ValuesFromObject<typeof KERNEL_MESSAGE_TYPE>;
 
 export declare interface KernelObject {
-    extRef: EMSReference_2;
+    extRef: EMSReference_2 | null;
     clone(): KernelObject;
     delete(): void;
     getId(): number;
@@ -4716,12 +4405,6 @@ export declare class LightGroup extends Group {
     toggleAllLights(on: boolean): void;
 }
 
-export declare class LightSample {
-    readonly position: Vector3;
-    readonly uv: Vector2;
-    constructor(position: Vector3, uv: Vector2);
-}
-
 export declare abstract class LightSetting {
     protected _scene: Scene;
     private _cameraContainer;
@@ -4735,17 +4418,6 @@ export declare abstract class LightSetting {
     getCameraContainer(): Object3D;
 }
 
-export declare class LightSource {
-    readonly lightSamples: LightSample[];
-    position: Vector3;
-    uv: Vector2;
-    averageIntensity: number;
-    maxIntensity: number;
-    size: number;
-    constructor(lightSamples: LightSample[]);
-    calculateLightSourceProperties(luminanceFunction: (uv: Vector2) => number): void;
-}
-
 export declare interface LightSourceConfiguration {
     lightSourceAreaInSquareMeters: number;
     minimumRoomSizeInSquareMeters: number;
@@ -4803,13 +4475,6 @@ export declare interface LutImageDefinition {
     type: string;
 }
 
-export declare interface LutPassParameters {
-    [key: string]: any;
-    enabled: boolean;
-    lut: string;
-    intensity: number;
-}
-
 export declare const enum MAIL_TYPE {
     STANDARD = 1,
     AUGMENTED_REALITY = 2,
@@ -4970,11 +4635,11 @@ export declare interface MeasurementBase<Vector2Type = Vector3 | Position2, Vect
     /**  length of the wall in millimeters **/
     length: number;
     /**  start position of the dimension in 2D **/
-    fromPosition2d: Vector2Type;
+    fromPosition2d?: Vector2Type;
     /**  end position of the dimension in 2D **/
-    toPosition2d: Vector2Type;
+    toPosition2d?: Vector2Type;
     /**  2D position where the length/label should be shown **/
-    textPosition2d: Vector2Type;
+    textPosition2d?: Vector2Type;
     id?: number;
 }
 
@@ -4992,7 +4657,7 @@ export declare class MeasurementLinePlanElementViewModel extends PlanElementView
     private _point2Draggable;
     private _point1BoundingBox;
     private _point2BoundingBox;
-    currentPoint: string;
+    currentPoint: string | null;
     constructor(planObject: PlanObject);
     private _initializeContainer;
     private _initializeLines;
@@ -5034,8 +4699,8 @@ export declare class MeasurementLinePlanElementViewModel extends PlanElementView
     hoverOffDragPoint1(): void;
     hoverOffDragPoint2(): void;
     selectPointOnDragStart(planElementViewModel: MeasurementLinePlanElementViewModel): void;
-    hideDraggablePointsOnDragStart(planElementViewModel: MeasurementLinePlanElementViewModel, point: MeasurementLineDraggablePoints): void;
-    showDraggablePointsOnDragEnd(planElementViewModel: MeasurementLinePlanElementViewModel, point: MeasurementLineDraggablePoints): void;
+    hideDraggablePointsOnDragStart(planElementViewModel: MeasurementLinePlanElementViewModel, point: MeasurementLineDraggablePoints | null): void;
+    showDraggablePointsOnDragEnd(planElementViewModel: MeasurementLinePlanElementViewModel, point: MeasurementLineDraggablePoints | null): void;
     handleDraggablePointsSelection(planElementViewModel: MeasurementLinePlanElementViewModel): void;
     showDraggablePointsOnHoverOn(planElementViewModel: MeasurementLinePlanElementViewModel): void;
     showDraggablePointsOnHoverOff(planElementViewModel: MeasurementLinePlanElementViewModel): void;
@@ -5073,6 +4738,7 @@ export declare class MeshGenerator implements Context {
     protected _createMaterial(materialId: string, resolve: () => void, reject: (error: Error) => void, width?: number, height?: number): void;
     private _loadBenchmarkTextures;
     protected _loadTextures(rapiMaterial: RapiMaterial, material: MeshPhysicalMaterial, width?: number, height?: number): Promise<void>;
+    private _addTexturesToMaterial;
     protected _loadMaterial(materialId: string, width?: number, height?: number): Promise<Material>;
     protected _assignMaterial(mesh: Mesh, materialId: string, materialAttributes?: Record<string, string>): Promise<void>;
     get maxAnisotropy(): number;
@@ -5122,14 +4788,6 @@ export declare interface NodePlanObject extends PlanObject {
     getMaxWallHeight(): number;
 }
 
-export declare const NORMAL_VECTOR_SOURCE_TYPES: {
-    readonly INPUT_RGB_NORMAL: "inputRgbNormal";
-    readonly FLOAT_BUFFER_NORMAL: "floatBufferNormal";
-    readonly CONSTANT_Z: "constantZ";
-};
-
-export declare type NormalVectorSourceType = Enumify_5<typeof NORMAL_VECTOR_SOURCE_TYPES>;
-
 export { Nullable }
 
 export declare interface Object3DRoomleEventMap extends Object3DEventMap {
@@ -5231,105 +4889,6 @@ export declare interface OffsetCamera {
 export declare interface OrthographicOffsetCamera extends OrthographicCamera, OffsetCamera {
 }
 
-export declare interface OutlineParameters {
-    [key: string]: any;
-    enabled: boolean;
-    edgeStrength: number;
-    edgeGlow: number;
-    edgeThickness: number;
-    pulsePeriod: number;
-    usePatternTexture: false;
-    visibleEdgeColor: ColorRepresentation;
-    hiddenEdgeColor: ColorRepresentation;
-}
-
-export declare class OutlinePass extends RenderPass {
-    static BlurDirectionX: Vector2;
-    static BlurDirectionY: Vector2;
-    static highlightLines: boolean;
-    renderScene: Scene;
-    renderCamera: Camera;
-    selectedObjects: Object3D[];
-    visibleEdgeColor: Color;
-    hiddenEdgeColor: Color;
-    edgeGlow: number;
-    usePatternTexture: boolean;
-    patternTexture: Texture | null;
-    edgeThickness: number;
-    edgeStrength: number;
-    downSampleRatio: number;
-    pulsePeriod: number;
-    edgeDetectionFxaa: boolean;
-    _visibilityCache: Map<Object3D, boolean>;
-    resolution: Vector2;
-    renderTargetMaskBuffer: WebGLRenderTarget;
-    prepareMaskMaterial: ShaderMaterial;
-    renderTargetFxaaBuffer?: WebGLRenderTarget;
-    fxaaRenderMaterial?: ShaderMaterial;
-    renderTargetMaskDownSampleBuffer: WebGLRenderTarget;
-    renderTargetBlurBuffer1: WebGLRenderTarget;
-    renderTargetBlurBuffer2: WebGLRenderTarget;
-    edgeDetectionMaterial: ShaderMaterial;
-    renderTargetEdgeBuffer1: WebGLRenderTarget;
-    renderTargetEdgeBuffer2: WebGLRenderTarget;
-    separableBlurMaterial1: ShaderMaterial;
-    separableBlurMaterial2: ShaderMaterial;
-    overlayMaterial: ShaderMaterial;
-    copyUniforms: any;
-    materialCopy: ShaderMaterial;
-    oldClearColor: Color;
-    oldClearAlpha: number;
-    fsQuad: FullScreenQuad;
-    tempPulseColor1: Color;
-    tempPulseColor2: Color;
-    textureMatrix: Matrix4;
-    clearBackground: boolean;
-    constructor(renderPassManager: RenderPassManager, resolution: Vector2, scene: Scene, camera: Camera, selectedObjects: Object3D[], parameters?: OutlinePassParameters);
-    dispose(): void;
-    setSize(width: number, height: number): void;
-    private _canBeHighlighted;
-    private _changeVisibilityOfSelectedObjects;
-    private _changeVisibilityOfNonSelectedObjects;
-    private _updateTextureMatrix;
-    render(renderer: WebGLRenderer | WebGPURenderer, _writeBuffer: WebGLRenderTarget | null, readBuffer: WebGLRenderTarget | null, _deltaTime: number, maskActive: boolean): void;
-    renderPass(renderer: WebGLRenderer | WebGPURenderer): void;
-    private _getPrepareMaskMaterial;
-    private _getEdgeDetectionMaterial;
-    private _getSeperableBlurMaterial;
-    private _getOverlayMaterial;
-}
-
-export declare interface OutlinePassParameters {
-    downSampleRatio?: number;
-    edgeDetectionFxaa?: boolean;
-}
-
-export declare class OutlineRenderer {
-    parameters: OutlineParameters;
-    private _renderPassManager;
-    private _effectComposer;
-    outlinePassActivated: boolean;
-    get isOutlinePassActivated(): boolean;
-    get outlinePass(): OutlinePass | null;
-    constructor(renderPassManager: RenderPassManager, _effectComposer: EffectComposer | null, parameters: OutlineRendererParameters);
-    updateParameters(parameters: OutlineParameters): void;
-    applyParameters(): void;
-    activateOutline(scene: Scene, camera: Camera): void;
-    deactivateOutline(): void;
-    updateOutline(scene: Scene, camera: Camera, selectedObjects: Object3D[]): void;
-}
-
-export declare interface OutlineRendererParameters {
-    enabled?: boolean;
-    edgeStrength?: number;
-    edgeGlow?: number;
-    edgeThickness?: number;
-    pulsePeriod?: number;
-    usePatternTexture?: false;
-    visibleEdgeColor?: ColorRepresentation;
-    hiddenEdgeColor?: ColorRepresentation;
-}
-
 export declare const enum PARAMETER_KERNEL_TYPE {
     UNKNOWN = "",
     INTEGER = "Integer",
@@ -5407,23 +4966,6 @@ export declare class PartListParameterArray extends EmsArray<KernelPartListParam
 export declare class PartListParameterArray_2 extends EmsArray<KernelPartListParameter> {
 }
 
-export declare class PassRenderer {
-    private _originalClearColor;
-    private _originalClearAlpha;
-    private _originalAutoClear;
-    private _originalRenderTarget;
-    private _screenSpaceQuad;
-    private _emptyScene;
-    private _defaultCamera;
-    renderWithOverrideMaterial(renderer: WebGLRenderer | WebGPURenderer, scene: Scene, camera: Camera, overrideMaterial: Material | null, renderTarget: WebGLRenderTarget | null, clearColor?: ColorRepresentation, clearAlpha?: number): void;
-    clear(renderer: WebGLRenderer | WebGPURenderer, renderTarget: WebGLRenderTarget | null, clearColor?: ColorRepresentation, clearAlpha?: number): void;
-    render(renderer: WebGLRenderer | WebGPURenderer, scene: Scene, camera: Camera, renderTarget: WebGLRenderTarget | null, clearColor?: ColorRepresentation, clearAlpha?: number): void;
-    renderScreenSpace(renderer: WebGLRenderer | WebGPURenderer, passMaterial: Material, renderTarget: WebGLRenderTarget | null, clearColor?: ColorRepresentation, clearAlpha?: number): void;
-    private _prepareRenderer;
-    private _backup;
-    private _restore;
-}
-
 export declare interface PerspectiveOffsetCamera extends PerspectiveCamera, OffsetCamera {
 }
 
@@ -5551,8 +5093,8 @@ export declare interface PlanInteractionHandler {
     loadPlanXML(xml: string): Plan_2;
     createPlanWithObjectFromItem(object: KernelObject, position: KernelVector3, rotationInRad: number): Plan_2;
     getPlan(): Plan_2;
-    moveElementTo(planObject: KernelObject, point: KernelVector3): void;
-    moveElementToIn2d(planObject: KernelObject, point: KernelVector3, dragging: boolean): void;
+    moveElementTo(planObject: KernelObject, targetPosition: KernelVector3, cameraPosition?: KernelVector3): void;
+    moveElementToIn2d(planObject: KernelObject, targetPosition: KernelVector3, dragging: boolean): void;
     moveElementBy(planObject: KernelObject, distance: KernelVector3): void;
     duplicatePlanObject(object: PlanObject, count: number, findFreeSpaceInPlan: boolean): PlanObject[];
     duplicatePlanObjects(objects: PlanObjectList, count: number, findFreeSpaceInPlan: boolean): PlanObject[];
@@ -5693,10 +5235,10 @@ export declare interface PlanModelViewHelper_2 {
     getPlanOverview(planObject: KernelObject): PlanOverview;
     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;
-    getExternalComponentModuleIdsForSelection(plan: Plan_2, groupOrRootModuleId: string, subModuleId: string): ExternalModuleInformation;
     requestMesh3d(element: PlanElement_2): void;
     getExternalObjectGroups(plan: Plan_2): KernelObjectConfigurationArray;
     getExternalRoomInformation(plan: Plan_2): RoomInformation;
@@ -5717,6 +5259,36 @@ export declare class Planner<P extends readonly PluginName[] = readonly []> exte
     protected getContextName(): string;
 }
 
+export declare class Planner2dCameraBehaviour extends PlannerCameraBehaviour {
+    get cameraControl(): CameraControl2D;
+    resetCameraOnPlanCompletelyLoaded(bounds: Box3): void;
+    externalApiResetCameraPosition(bounds: Box3): void;
+    resetCameraOnFirstSwitchTo2d(bounds: Box3): void;
+    updateCameraOnDrawWalls(bounds: Box3): void;
+    updateCameraOnPlanElementInsertedOutsideCurrentCameraView(bounds: Box3): void;
+    updateCameraOnPlanElementInsertedInsideCurrentCameraView(_bounds: Box3): void;
+    updateCameraOnPlanElementDraggedOutsidePlanBounds(bounds: Box3): void;
+    updateCameraOnPlanElementRemoved(_bounds: Box3): void;
+    updateCameraOnBackToPlanner(bounds: Box3, _startCameraParams: CameraParameter, _endCameraParams: CameraParameter): void;
+    resetCameraOnEnableWallDrawing(bounds: Box3): void;
+}
+
+export declare class Planner3dCameraBehaviour extends PlannerCameraBehaviour {
+    get cameraControl(): CameraControl3D;
+    resetCameraOnPlanCompletelyLoaded(bounds: Box3): void;
+    externalApiResetCameraPosition(bounds: Box3): void;
+    disablePanningOnShiftRelease(): void;
+    enablePanningOnShiftClick(): void;
+    updateCameraOnDrawWalls(bounds: Box3): void;
+    updateCameraOnPlanElementInsertedOutsideCurrentCameraView(bounds: Box3): void;
+    updateCameraOnPlanElementDraggedOutsidePlanBounds(bounds: Box3): void;
+    updateCameraOnPlanElementInsertedInsideCurrentCameraView(bounds: Box3): void;
+    updateCameraOnPlanElementRemoved(bounds: Box3): void;
+    updateCameraOnBackToPlanner(bounds: Box3, startCameraParams: CameraParameter, endCameraParams: CameraParameter): Promise<void>;
+    resetCameraOnEnableWallDrawing(bounds: Box3): void;
+    externalApiMoveCamera(cameraParameter: CameraParameter): Promise<void>;
+}
+
 export declare const enum PLANNER_SCENE_EVENT_STATE {
     IDLE = 0,
     DRAG = 1,
@@ -5725,6 +5297,33 @@ export declare const enum PLANNER_SCENE_EVENT_STATE {
     MEASURE = 4
 }
 
+export declare abstract class PlannerCameraBehaviour extends CameraBehaviour {
+    get cameraControl(): CameraControl;
+    abstract resetCameraOnPlanCompletelyLoaded(bounds: Box3): void;
+    abstract externalApiResetCameraPosition(bounds: Box3): void;
+    abstract updateCameraOnDrawWalls(bounds: Box3): void;
+    abstract updateCameraOnPlanElementInsertedOutsideCurrentCameraView(bounds: Box3): void;
+    abstract updateCameraOnPlanElementInsertedInsideCurrentCameraView(bounds: Box3): void;
+    abstract updateCameraOnPlanElementDraggedOutsidePlanBounds(bounds: Box3): void;
+    abstract updateCameraOnPlanElementRemoved(bounds: Box3): void;
+    abstract updateCameraOnBackToPlanner(bounds: Box3, startCameraParams: CameraParameter, endCameraParams: CameraParameter): void;
+    abstract resetCameraOnEnableWallDrawing(bounds: Box3): void;
+}
+
+export declare class PlannerFpCameraBehaviour extends PlannerCameraBehaviour {
+    get cameraControl(): CameraControlFirstPerson;
+    resetCameraOnPlanCompletelyLoaded(_bounds: Box3): void;
+    externalApiResetCameraPosition(_bounds: Box3): void;
+    updateCameraOnDrawWalls(_bounds: Box3): void;
+    updateCameraOnPlanElementInsertedOutsideCurrentCameraView(_bounds: Box3): void;
+    updateCameraOnPlanElementInsertedInsideCurrentCameraView(_bounds: Box3): void;
+    updateCameraOnPlanElementDraggedOutsidePlanBounds(_bounds: Box3): void;
+    updateCameraOnPlanElementRemoved(_bounds: Box3): void;
+    updateCameraOnBackToPlanner(_bounds: Box3, _startCameraParams: CameraParameter, _endCameraParams: CameraParameter): void;
+    resetCameraOnEnableWallDrawing(_bounds: Box3): void;
+    resetCameraOnSwitchToFirstPerson(): void;
+}
+
 export declare interface PlannerInitData {
     /**
      * @description Select with which camera mode to start initially.
@@ -5800,6 +5399,7 @@ export declare class PlannerKernelAccess extends ConfiguratorKernelAccess {
     externalObjectArrangementChanged(plan: Plan_2, planObject: PlanObject, changedGroup: 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): 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;
     requestCatalogItem(catalogItemId: string): void;
@@ -5818,7 +5418,7 @@ export declare class PlannerKernelAccess extends ConfiguratorKernelAccess {
     private _decoupleReferences;
     isConstructionPlanElement(planElement: PlanElement_2): boolean;
     planObjectSelectionChanged(configurationRuntimeId: number, elementRuntimeId: number): void;
-    protected _componentSelectionChanged(_planObject: PlanObjectKernel, component: KernelComponent, planComponentSelection: boolean): void;
+    protected _componentSelectionChanged(_planObject: PlanObjectKernel, component: KernelComponent): void;
     protected _externalObjectParameterChanged(objectOrComponentId: number, parameterKey: string, value: string): void;
     protected _externalObjectConfigurationChanged(_objectId: number, configuration: string): void;
     protected _externalObjectConfigurationLoaded(_objectId: number, configuration: string): void;
@@ -5839,6 +5439,7 @@ export declare class PlannerKernelAccess extends ConfiguratorKernelAccess {
     protected _getAnimationLevelForObject(runtimeId: number, _animation: KernelAnimation): AnimationLevelType;
     getObjectComponent(runtimeId: number, typeOfId: Enumify_3<typeof CORE_TYPE_OF_CORE_ID>): KernelPlanObjectComponent | null;
     isChildObjectRootComponent(roomleComponent: RoomleComponent): boolean;
+    isAnimationRootComponent(roomleComponent: RoomleComponent): boolean;
 }
 
 export declare interface PlannerKernelCallbackI {
@@ -5848,8 +5449,8 @@ export declare interface PlannerKernelCallbackI {
     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;
-    addPlanObjectToScene(planElementViewModel: PlanObjectViewModel): void;
-    removePlanObjectFromScene(planElementViewModel: PlanObjectViewModel): 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;
@@ -5862,6 +5463,7 @@ export declare interface PlannerKernelCallbackI {
     requestCatalogItem(catalogItemId: string): void;
     externalObjectRequestAddOnContainers(groupId: string, subArticleId: string): void;
     externalObjectAddSubArticle(subArticleId: string, rootModuleId: string, parentModuleId: string): void;
+    externalObjectRemoveSubModule(groupId: string, subModuleId: string): void;
 }
 
 export declare interface PlannerKernelContainer {
@@ -5934,6 +5536,11 @@ export declare interface PlannerKernelContainer {
     UnitMeasureFormatter: UnitMeasureFormatter_2;
 }
 
+export declare enum PlannerRenderMode {
+    Mode3D = 0,
+    Mode2D = 1
+}
+
 export declare class PlannerSceneEventHandler extends SceneEventHandler<SceneEventInfo_2> {
     private _plannerSelectionHandler;
     private _plannerKernelAccess;
@@ -6031,7 +5638,7 @@ export declare class PlannerSceneEventHandler extends SceneEventHandler<SceneEve
     private _initMobileDrawing;
     private _drawWallOnMouseMove;
     private _createNode;
-    getIntersectionAtScreenPosition(positionRelative: Position2): KernelVector3;
+    getIntersectionAtScreenPosition(positionRelative: Position2): KernelVector3 | null;
     private _getIntersectionPointWithScene;
     private _setStateAndCursor;
     setKernelZoomFactor(kernelZoomFactor: number): void;
@@ -6048,6 +5655,243 @@ export declare class PlannerSceneEventHandler extends SceneEventHandler<SceneEve
     switchCameraMode(): void;
 }
 
+export declare class PlannerSceneManager extends ConfiguratorSceneManager implements PlannerKernelCallbackI {
+    private _rapiAccess;
+    private _plannerMeshGenerator;
+    private _plannerInputManager;
+    private _roomlePlannerUiCallback;
+    private _localStorageHelper;
+    private _plannerSceneEventHandler;
+    private _roomlePlannerCallback;
+    private _homagIntelligence;
+    private _itemsLoadingStatePromises;
+    private _sky;
+    private _drawingEnabled;
+    private _configureInRoom;
+    private _planId;
+    private _preloadScene;
+    private _staticItemGuard;
+    private _completelyLoaded;
+    private _configurableItemGuard;
+    private _planCompletelyLoadedGuard;
+    private _dragStartBounds;
+    currentSelection: SelectionPayload | null;
+    private _paperBackground;
+    private _cameraState;
+    private _cameraStateLocked;
+    private _planElementHighlighter;
+    private _debugSpheres;
+    constructor(creator: string, offset: CanvasOffset, plannerCallback: RoomlePlannerCallback, mode: Enumify_3<typeof CAMERA_TYPE>);
+    isDragging(): boolean;
+    protected _initializeMeshGeneratorSettings(): void;
+    setHomagIntelligence(homagIntelligence: HomagIntelligence | null): void;
+    get configuratorContext(): ConfiguratorContext;
+    get hasSingleRoom(): boolean;
+    /**
+     * Collects all toggleable lights for a plan element.
+     * Configurable components expose lights through `getAllLightSources()` on the
+     * `RoomleComponent`. Static lamp objects add lights as raw Three.js children
+     * (LampLight / RectLampLight) via `handleLampLight`, bypassing that map.
+     *
+     * Priority: if the component has kernel-driven lights (`getAllLightSources`
+     * returns a non-empty map), those are returned exclusively. Otherwise the
+     * helper falls back to scanning Three.js children for static lamp nodes.
+     */
+    private _getElementLightObjects;
+    getScenePlanElementLightSources(): ToggleableLightSource[];
+    setAllLightsOnOff(state: boolean): void;
+    setElementLightsOnOff(planElementViewModel: PlanElementViewModel, state: boolean): void;
+    private _activateElement;
+    planCleared(): void;
+    planHistoryStateChanged(): void;
+    protected _getViewModel(): PlanViewModel;
+    private _getDragPosition;
+    private _hideAllMeasurementsNodeOnElementChange;
+    private _onSelectionChange;
+    private _onSelectionCancel;
+    private _handleMeasurementLineDraggablePoints;
+    resetConfiguratorContext(reason: CancelSelectionReasons): void;
+    protected _setupScene(offset?: CanvasOffset, transparent?: boolean): Promise<void>;
+    protected onBeforeRender(): void;
+    protected _getInputManager(): InputManager;
+    protected createCameraControl(mode: Enumify_3<typeof CAMERA_TYPE>, _offset: CanvasOffset): void;
+    startViewing(): void;
+    startConfiguring(): void;
+    private _is3DView;
+    private _setCameraPosition;
+    private _resetCameraPosition;
+    selectPlanObject(runtimeId: number): Promise<void>;
+    backToPlanner(): void;
+    private _getYRotationOfObject;
+    loadStaticPlanObjects(): void;
+    requestCatalogItem(catalogItemId: string): void;
+    private _staticItemsLoaded;
+    preload(id: string): void;
+    planXMLLoaded(plan: Plan_2): void;
+    private _activateCeilingLight;
+    planCompletelyLoaded(_plan: Plan_2): void;
+    handlerSwitchedPlans(fromPlan: Plan_2, toPlan: Plan_2): 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
+     * kernel round-trips through plan XML) and turns off matching lights.
+     */
+    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;
+    addPlanObjectToScene(planViewModel: PlanObjectViewModel | null): Promise<void>;
+    private _recycleLights;
+    removePlanObjectFromScene(planViewModel: PlanElementViewModel | undefined): void;
+    planElementChanged(plan: Plan_2, planElementViewModel: PlanElementViewModel): void;
+    exportGLB(): Promise<void>;
+    exportUSDZ(): Promise<void>;
+    importGLB(url: string): void;
+    clearScene(): void;
+    private _addSky;
+    toggleConfigureInRoom(): void;
+    switchTo2D(): void;
+    switchTo3D(): void;
+    switchToFirstPerson(): void;
+    protected onCameraChanged(): void;
+    protected _setCameraControlListeners(): void;
+    private _onCameraZoomChange;
+    private _setKernelZoomFactor;
+    private _setCeiling;
+    cameraBehaviourChanged(updateDistance?: boolean): void;
+    private _updatePaperBackground;
+    sceneChanged(): void;
+    protected _onKeyDown(event: KeyboardEvent): void;
+    private _checkCopyPaste;
+    private _checkPanning;
+    private _onMouseDown;
+    private _checkNumKey;
+    protected _onKeyUp(event: KeyboardEvent, cleanup?: boolean): void;
+    undo(): Promise<void>;
+    redo(): Promise<void>;
+    protected _updateConfigurationFromHistory(configurationString: string): Promise<void>;
+    setMode(mode: Enumify_3<typeof CAMERA_TYPE>): void;
+    private _clearHighlighting;
+    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;
+    updateCameraOnDrawWalls(): void;
+    getBounds(): Box3;
+    getGeometryBounds(): Box3 | null;
+    getPlanObject(id: number): KernelPlanObject;
+    getRootPlanObjectId(id: number): number;
+    cancelPlanElementSelection(reason: CancelSelectionReasons): void;
+    deletePlanElements(runtimeIds: RuntimeId[]): Promise<void>;
+    deletePlanElementSelection(): Promise<void>;
+    deletePlanElementByIds(runtimeIds: number[]): Promise<void>;
+    rotatePlanElements(ids: RuntimeId[], rotateBy: number): void;
+    rotatePlanElementSelection(rotateBy: number): void;
+    planBoundsChanged(): void;
+    planElementRemoved(element: PlanElement_2): void;
+    private _onPlanChanged;
+    prepareTopImage(options?: PrepareImageOptions, isolationMode?: boolean): Promise<Base64Image>;
+    preparePerspectiveImageOf(runtimeId: RuntimeId, options?: PrepareImageOptions): Promise<Base64Image>;
+    protected _waitForAssets(): Promise<void>;
+    private _preparePerspectiveImage;
+    prepareThumbnailImage(options: PrepareImageOptionsPlanner): Promise<Base64Image>;
+    private _handlePlannerIsolationModeState;
+    private _hideAllExceptSelectedElement;
+    preparePerspectiveImage(options?: PrepareImageOptions, isolationMode?: boolean): Promise<Base64Image>;
+    protected _calculateImageCameraTarget(spacing?: number): CameraTarget;
+    enableRotation(): void;
+    disableRotation(): void;
+    enableSnapping(): void;
+    disableSnapping(): void;
+    enableAdvancedDocking(): void;
+    disableAdvancedDocking(): void;
+    isEnabledChildObjectMode(planElementViewModel: PlanElementViewModel): boolean;
+    enableChildObjects(planElementViewModel: PlanElementViewModel): KernelObject;
+    disableChildObjects(planElementViewModel: PlanElementViewModel): KernelObject;
+    dragIn(dragEvent: DragEvent): void;
+    getPositionForDragEvent(dragEvent: DragEvent | TouchEvent): Vector3 | null;
+    getPlannerSceneEventHandler(): PlannerSceneEventHandler;
+    disablePlannerEvents(): void;
+    enablePlannerEvents(): void;
+    protected _onCameraIdle(): boolean;
+    private _hideAllNodeIfThereAreNoSelections;
+    protected _onCameraMove(): boolean;
+    private _showWallNodes;
+    private _updateNodeSize;
+    private _sendPlanObjectPositions;
+    private _sendMultiSelectionPosition;
+    private _sendSelectedPlanObjectPositions;
+    private _sendRoomAreaData;
+    private _updateMeasurementPositions;
+    private _sendElementMeasurements;
+    private _sendRoomMeasurements;
+    private _sendMeasurementLineDimension;
+    private _sendObjectMeasurements;
+    private transformMeasurements;
+    private _sendConstructionElementDimensions;
+    setConstructionElementDistanceToWall(measurementId: number, distance: number): void;
+    private _adjustConstructionPosition;
+    private _sendWallDimensions;
+    enableWallDrawing(resetCamera: boolean): void;
+    disableWallDrawing(): void;
+    escapeDrawing(cancelDrawing: boolean): void;
+    cancelDragIn(): Promise<void>;
+    setSceneEvents(sceneEvents: SceneEvents): void;
+    /**
+     * called by kernel
+     */
+    startedDrawing(): void;
+    /**
+     * called by kernel
+     */
+    stoppedDrawing(): void;
+    disableEvents(): void;
+    enableEvents(): void;
+    resetCameraPositionToStart(): void;
+    moveCamera(cameraParameter: CameraParameter): Promise<void>;
+    protected _setInteriorOrExteriorWallMaterial(type: Enumify_3<typeof SET_WALL_MATERIAL_TYPE>, material: BatchPaintMaterial): void;
+    changeInteriorWallsMaterial(material: BatchPaintMaterial): void;
+    changeExteriorWallsMaterial(material: BatchPaintMaterial): void;
+    changeFloorsMaterial(floors: KernelFloor[], material: BatchPaintMaterial): void;
+    changeAllFloorsMaterial(material: BatchPaintMaterial): void;
+    getWallAngleDegrees(wall: WallPlanElementViewModel): number;
+    moveElementPosition(selectedElement: PlanElementViewModel, position: KernelVector3): void;
+    moveElementsPosition(selectedElements: PlanElementViewModel[], position: KernelVector3): void;
+    protected get plannerCameraBehaviour(): Planner2dCameraBehaviour | Planner3dCameraBehaviour | PlannerFpCameraBehaviour;
+    enableMeasurementLineDrawing(): void;
+    disableMeasurementLineDrawing(): void;
+    setCompletelyLoaded(completelyLoaded: boolean): void;
+    protected enablePanning(): void;
+    protected disablePanning(): void;
+    setObjectToWallMeasurementLength(planElementId: number, measurementId: number, length: number): void;
+    setWallMeasurementLength(measurementId: number, length: number, wallDirection: EMSConstant): void;
+    setMeasurementLineLength(measurementId: number, length: number, wallDirection: string): void;
+    protected setEventHandlerObject(object: Object3D): void;
+    protected _readyForRender(): void;
+    protected notifyPlannerOnComponentSelectionCancel(isExternalObject: boolean, reason: CancelSelectionReasons): void;
+    private _externalPlanObjectSelectionChanged;
+    highlightExternalObject(planObjectComponent: KernelPlanObjectComponent): void;
+    private _selectExternalObjectComponent;
+    getSelectedPlanObjectComponent(): KernelPlanObjectComponent | null;
+    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;
+    getExternalObjectComponent(groupOrRootModuleId: string, subModuleId: string): KernelPlanObjectComponent;
+    getCameraParameters3d(): CameraParameter | null;
+    private _createCeilingLightGroup;
+    toggleInteriorLightsSceneSettings(on: boolean): void;
+    private _insertRapiItems;
+    insertRapiObjects(rapiIds: InsertItemIdInfo[]): Promise<InsertItemResult[]>;
+    private _saveConfiguration;
+    externalObjectRequestAddOnContainers(groupId: string, subArticleId: string): Promise<void>;
+    externalObjectAddSubArticle(subArticleId: string, rootModuleId: string, parentModuleId: string): void;
+    externalObjectRemoveSubModule(groupId: string, subModuleId: string): void;
+    getExternalSubArticles(id: number): PosArticle[];
+}
+
 export declare interface PlanNode extends KernelObject {
     getMaxWallHeight(): number;
     getNumberOfConnectedWalls(): number;
@@ -6228,13 +6072,13 @@ export declare class PlanViewModel extends ConfiguratorViewModel implements Plan
     protected dockComponent(componentId: number, isRootComponent: boolean, parentId: number, componentPosition: KernelVector3, componentRotation: KernelVector3): void;
     protected _addComponent(component: RoomleComponent): void;
     private _getPlanObjectViewModelForRuntimeId;
-    getConfigurablePlanObjectForId(id: number): ConfiguratorPlanObjectViewModel;
+    getConfigurablePlanObjectForId(id: number): ConfiguratorPlanObjectViewModel | null;
     private _findPlanObjectViewModel;
     protected updatePlanElement(elementId: number): void;
-    getStaticPlanObjectForId(id: number): StaticPlanObjectViewModel;
-    getConstructionObjectForId(id: number): ConstructionPlanObjectViewModel;
-    getStaticPlanObjectViewModelForId(id: number): StaticPlanObjectViewModel;
-    getPlanObjectForId(id: number): PlanElementViewModel;
+    getStaticPlanObjectForId(id: number): StaticPlanObjectViewModel | null;
+    getConstructionObjectForId(id: number): ConstructionPlanObjectViewModel | null;
+    getStaticPlanObjectViewModelForId(id: number): StaticPlanObjectViewModel | ConstructionPlanObjectViewModel | null;
+    getPlanObjectForId(id: number): PlanElementViewModel | null;
     getPlanObjectViewModelsFromRapiId(): (StaticPlanObjectViewModel | ConfiguratorPlanObjectViewModel)[];
     getPlanObjectCount(): number;
     getConstructionGroup(): Group;
@@ -6269,10 +6113,10 @@ export declare class PlanViewModel extends ConfiguratorViewModel implements Plan
     getFloorPlanObjectViewModels(): FloorPlanElementViewModel[];
     getMeasurementLineObjectViewModels(): MeasurementLinePlanElementViewModel[];
     getWallAtticsObjectViewModels(): WallAtticPlanElementViewModel[];
-    protected _generateMesh(runtimeComponentId: number, geometryId: string, material: any, vertices: Float32Array, indices: Int32Array, uvCoords: Float32Array, normals: Float32Array, type?: KernelEnum, newGeometryInstance?: boolean, materialAttributes?: Record<string, string>): Mesh;
+    protected _generateMesh(runtimeComponentId: number, geometryId: string | null, material: any, vertices: Float32Array, indices: Int32Array, uvCoords: Float32Array, normals: Float32Array, type?: KernelEnum, newGeometryInstance?: boolean, materialAttributes?: Record<string, string>): Mesh;
     protected _setMaterial(mesh: Mesh, material: any, _type?: KernelEnum, materialAttributes?: Record<string, string>): void;
     Editor3dComponentCreated(id: number, position: KernelVector3, eulerAngles: KernelVector3, isRootComponent: boolean, parentObjectRuntimeId: number): void;
-    addPlanObjectToScene(_planViewModel: PlanElementViewModel): void;
+    addPlanObjectToScene(_planViewModel: PlanObjectViewModel | null): void;
     handlerSwitchedPlans(_fromPlan: Plan_2, _toPlan: Plan_2): void;
     planCompletelyLoaded(_plan: Plan_2): void;
     beginPlanConstruction(_plan: Plan_2): void;
@@ -6282,7 +6126,7 @@ export declare class PlanViewModel extends ConfiguratorViewModel implements Plan
     planObjectConfigurationLoaded(_plan: Plan_2, planElement: PlanElement_2, success: boolean): void;
     planObjectConfigurationChanged(_plan: Plan_2, _element: PlanElementViewModel): void;
     addMesh(planElement: PlanElement_2, material: any, vertices: Float32Array, indices: Int32Array, uvCoords: Float32Array, normals: Float32Array): void;
-    removePlanObjectFromScene(planElementViewModel: PlanElementViewModel): void;
+    removePlanObjectFromScene(planElementViewModel: PlanElementViewModel | undefined): void;
     private _isConstructionType;
     planElementRemoved(element: PlanElement_2): void;
     private _removeObject;
@@ -6301,6 +6145,7 @@ export declare class PlanViewModel extends ConfiguratorViewModel implements Plan
     requestCatalogItem(_catalogItemId: string): void;
     externalObjectRequestAddOnContainers(_groupId: string, _subArticleId: string): void;
     externalObjectAddSubArticle(_subArticleId: string, _rootModuleId: string, _parentModuleId: string): void;
+    externalObjectRemoveSubModule(_groupId: string, _subModuleId: string): void;
 }
 
 export declare interface PluginConfigMap {
@@ -6323,7 +6168,7 @@ export declare class PluginSystem implements Context, ScenePluginHooks {
     updateBounds(bounds: Box3): void;
     clearScene(scene: Scene, uiScene: Scene): void;
     getActivePlugins(): ScenePlugin[];
-    getPlugin<T extends ScenePlugin>(type: any): T;
+    getPlugin<T extends ScenePlugin>(type: any): T | null;
     moveCameraEnd(position: Vector3): void;
     moveCameraStart(position: Vector3): void;
     needsUiScene(): boolean;
@@ -6343,72 +6188,6 @@ export declare interface PointerInputEvent {
     event?: Event;
 }
 
-export declare interface PoissonDenoiseParameters {
-    poissonDenoisePassParameters?: PoissonDenoisePassParameters;
-    normalVectorSourceType?: NormalVectorSourceType;
-    depthValueSourceType?: DepthValueSourceType;
-    rgInputTexture?: boolean;
-    luminanceWeighted?: boolean;
-    luminanceType?: string;
-    sampleLuminance?: string;
-    fragmentOutput?: string;
-    inputTexture?: Texture;
-    depthTexture?: Texture;
-    normalTexture?: Texture;
-}
-
-export declare interface PoissonDenoisePassParameters {
-    [key: string]: any;
-    iterations: number;
-    samples: number;
-    rings: number;
-    radiusExponent: number;
-    radius: number;
-    lumaPhi: number;
-    depthPhi: number;
-    normalPhi: number;
-    nvOrientatedSamples?: boolean;
-}
-
-export declare class PoissonDenoiseRenderPass implements DenoisePass {
-    needsUpdate: boolean;
-    parameters: PoissonDenoisePassParameters;
-    private _width;
-    private _height;
-    private _samples;
-    private _normalVectorSourceType;
-    private _depthValueSourceType;
-    _inputTexture: Texture | null;
-    depthTexture: Texture | null;
-    normalTexture: Texture | null;
-    private _noiseTexture;
-    private _pdMaterial?;
-    private _renderTargets;
-    private _outputRenderTargetIndex;
-    private _passRenderer;
-    private _sceneClipBox;
-    private _rgInputTexture;
-    private _luminanceWeighted;
-    private _luminanceType;
-    private _sampleLuminance;
-    private _fragmentOutput;
-    get texture(): Texture | null;
-    set inputTexture(texture: Texture | null);
-    constructor(width: number, height: number, samples: number, parameters?: PoissonDenoiseParameters);
-    private _getNoiseTexture;
-    private _getMaterial;
-    private _updateShader;
-    private _updateUniforms;
-    private _getRenderTargets;
-    dispose(): void;
-    setSize(width: number, height: number): void;
-    updateBounds(sceneClipBox: Box3): void;
-    updateParameters(parameters: PoissonDenoisePassParameters): void;
-    updateTextures(parameters: PoissonDenoiseParameters): void;
-    render(renderer: WebGLRenderer, camera: Camera): void;
-    renderToTarget(renderer: WebGLRenderer, camera: Camera, renderTarget: WebGLRenderTarget): void;
-}
-
 export declare interface PosArticle extends PosArticleInfo {
     roots: PosModuleRootData[];
 }
@@ -6815,6 +6594,8 @@ export declare class RapiAccess implements Context {
     private _globalCallback;
     private _itemLoaded;
     private _currentToken;
+    private _savesByHash;
+    private _onlineHandler;
     private _configurator;
     constructor(creator: string);
     setConfiguratorSettings(): Promise<void>;
@@ -7163,7 +6944,8 @@ export declare interface RapiMaterialShading {
     thicknessFactor?: number;
     attenuationColor?: RapiBaseColor;
     attenuationDistance?: number;
-    [key: string]: number | boolean | string | RapiBaseColor | undefined;
+    embeddedTextures?: RapiTexture[];
+    [key: string]: number | boolean | string | RapiBaseColor | RapiTexture[] | undefined;
 }
 
 export declare interface RapiMesh extends RapiJson {
@@ -7229,7 +7011,7 @@ export declare interface RapiPlanSnapshotGetData extends RapiPlanSnapshotPostDat
 export declare type RapiPlanSnapshotId = `ps_${string}`;
 
 export declare interface RapiPlanSnapshotPostData extends RapiJson {
-    parentId: RapiId;
+    parentId: RapiId | null;
     planObjects: Array<{
         combinedId: RapiId;
         position: string;
@@ -7436,7 +7218,7 @@ export declare class RaycastHelper extends EventDispatcher<Record<RAYCAST_EVENT,
     private _findHover;
     private _intersection;
     private _intersect;
-    intersectAtPosition(position: Position2): RoomleEventedIntersection;
+    intersectAtPosition(position: Position2): RoomleEventedIntersection | null;
     private _findObjectWithHandler;
     private _onDragStart;
     private _onDrag;
@@ -7446,7 +7228,7 @@ export declare class RaycastHelper extends EventDispatcher<Record<RAYCAST_EVENT,
     private _onRotate;
     private _positionPlanes;
     private _calculateOffset;
-    update(bounds: Vector3, rootComponentPosition: Vector3, backgroundScene: Scene): void;
+    update(bounds: Vector3 | null, rootComponentPosition: Vector3 | null, backgroundScene: Scene | null): void;
     clear(): void;
     enableDragIn(mesh: RoomleEventedMesh): void;
     setRootComponentId(rootComponentId: number): void;
@@ -7456,6 +7238,7 @@ export declare class RaycastHelper extends EventDispatcher<Record<RAYCAST_EVENT,
     intersectMouseOnScene(event: Pick<PointerInputEvent, 'positionRelative'>): KernelVector3;
     enableOnWallSnapping(): void;
     disableOnWallSnapping(): void;
+    getCameraPosition(): Vector3;
 }
 
 export declare interface Rectangle {
@@ -7480,127 +7263,8 @@ export declare interface RectangleReferencePoints {
 
 export declare const removeExtObjIdPrefix: (id: ExtObjId_2) => string;
 
-export declare interface RenderCache {
-    dispose(): void;
-    clear(): void;
-    addLineOrPoint(object3d: Object3D): void;
-    addMesh(mesh: Mesh): void;
-    addObject(object3d: Object3D): void;
-    onBeforeRender(): void;
-    onAfterRender(): void;
-}
-
-export declare class RenderCacheManager {
-    private _cacheMap;
-    dispose(): void;
-    registerCache(key: CacheKey, cache: RenderCache): void;
-    clearCache(): void;
-    clearObjectCache(key: CacheKey): void;
-    onBeforeRender(key: CacheKey, object3d: Object3D): void;
-    onAfterRender(key: CacheKey): void;
-    render(key: CacheKey, object3d: Object3D, renderMethod: () => void): void;
-}
-
-export declare enum RenderMode {
-    Mode3D = 0,
-    Mode2D = 1
-}
-
 export declare type RenderOptions = Partial<typeof DEFAULT_RENDER_OPTIONS>;
 
-export declare abstract class RenderPass extends Pass {
-    private _renderPassManager;
-    protected get renderPassManager(): RenderPassManager;
-    protected get renderCacheManager(): RenderCacheManager;
-    protected get scene(): Scene;
-    protected get camera(): Camera;
-    protected get gBufferTextures(): GBufferTextures;
-    protected get passRenderer(): PassRenderer;
-    constructor(renderPassManager: RenderPassManager);
-    render(renderer: WebGLRenderer | WebGPURenderer, _writeBuffer: WebGLRenderTarget, _readBuffer: WebGLRenderTarget, _deltaTime: number, _maskActive: boolean): void;
-    abstract renderPass(renderer: WebGLRenderer | WebGPURenderer): void;
-}
-
-export declare class RenderPassManager {
-    _creator_: string;
-    materialsNeedUpdate: boolean;
-    private _sceneRenderer;
-    private _passRenderer;
-    private _sceneRenderPass;
-    private _bakedGroundContactShadowPass;
-    private _gBufferRenderPass;
-    private _groundReflectionPass;
-    private _screenSpaceShadowMapPass;
-    private _shadowAndAoPass;
-    private _outlinePass;
-    private _debugPass;
-    private _scene?;
-    private _camera?;
-    private _cameraUpdate;
-    private _cameraChanged;
-    private _noUpdateNeededCount;
-    private _noOStaticFrames;
-    private _maxSamples;
-    private _passUpdateStates;
-    aoPassMapTexture: Texture | null;
-    private _lutMap;
-    private _lutPass;
-    private _lutPassParameters;
-    lutPassNeedsUpdate: boolean;
-    private _renderToRenderTarget;
-    private _outputPass;
-    private _passRenderTarget?;
-    private _passPassRenderTarget?;
-    private _initData;
-    get passRenderer(): PassRenderer;
-    get scene(): Scene;
-    get camera(): Camera;
-    get aspect(): number;
-    get cameraChanged(): boolean;
-    get noOStaticFrames(): number;
-    get renderCacheManager(): RenderCacheManager;
-    private get parameters();
-    get sceneRenderPass(): SceneRenderPass;
-    get bakedGroundContactShadowPass(): BakedGroundContactShadowPass;
-    get gBufferRenderPass(): GBufferRenderPass;
-    get groundReflectionPass(): GroundReflectionPass;
-    get screenSpaceShadowMapPass(): ScreenSpaceShadowMapPass;
-    get shadowAndAoPass(): ShadowAndAoPass;
-    get lutPassParameters(): LutPassParameters;
-    get lutMaps(): string[];
-    get outlinePass(): OutlinePass | null;
-    get outlineRenderer(): OutlineRenderer;
-    get debugPass(): DebugPass;
-    get debugOutput(): string;
-    constructor(creator: string, sceneRender: SceneRenderer);
-    dispose(): void;
-    setSize(width: number, height: number): void;
-    loadLutImage(name: string, url: string): void;
-    loadLutCube(name: string, url: string): void;
-    loadLut3dl(name: string, url: string): void;
-    createOutlinePass(): OutlinePass;
-    getRenderPassRenderTarget(renderer: WebGLRenderer | WebGPURenderer): WebGLRenderTarget | null;
-    getPostPassRenderTarget(renderer: WebGLRenderer | WebGPURenderer): WebGLRenderTarget | null;
-    setGroundVisibility(visible: boolean): void;
-    updatePasses(_renderer: WebGLRenderer | WebGPURenderer, scene: Scene, camera: Camera): void;
-    private _evaluateIfShadowAndAoUpdateIsNeeded;
-    private _dynamicChanges;
-    private _updateSceneRenderPass;
-    private _updateBakedGroundContactShadowPass;
-    private _updateGBufferPass;
-    private _updateGroundReflectionPass;
-    private _updateScreenSpaceShadowPass;
-    private _updateShadowAndAoPass;
-    private _updateLutPass;
-    private _updateOutlinePass;
-    private _updateDebugPass;
-    private _updateMaterials;
-    private _updateMaterial;
-    private _updatePlugInAo;
-    private _updatePlugInReflection;
-    renderPasses(renderer: WebGLRenderer | WebGPURenderer, scene: Scene): void;
-}
-
 export declare const enum ResizingAnchor {
     Center = 0,
     BackLeft = 1,
@@ -7758,6 +7422,7 @@ export declare class RoomleConfigurator<P extends readonly PluginName[] = readon
     exportCanvasScreenshot(quality?: number): Promise<string>;
     initSceneManager(sceneManager?: ConfiguratorSceneManager): void;
     getScene(): Scene;
+    getSceneManager(): ConfiguratorSceneManager;
     updateScene(): void;
     private _loadWebGlLib;
     private _loadingWebGlSuccess;
@@ -7784,7 +7449,7 @@ export declare class RoomleConfigurator<P extends readonly PluginName[] = readon
      * Set general configuration parameter
      * @param initData
      */
-    setOverrides(initData: Partial<InitDataDefinition & GlobalInitDataDefinition> | InitData): void;
+    setOverrides(initData: Partial<InitDataDefinition & GlobalInitDataDefinition> | InitData | undefined): void;
     /**
      * This method has to be called before configurator is ready to use
      *
@@ -8004,7 +7669,7 @@ export declare class RoomleConfigurator<P extends readonly PluginName[] = readon
      * Returns same url when online or caches url when offline
      * @param url
      */
-    requestAsset(url: string): AssetUrl;
+    requestAsset(url: string): AssetUrl | null;
     /**
      * Sets the material of the floor to the given RapiMaterial.
      * If the current environment is not floor environment it will be changed
@@ -8667,10 +8332,13 @@ export declare class RoomlePlanner<P extends readonly PluginName[] = readonly []
     private _plan;
     private _preloadPlanId;
     private _kernelReadyCallback;
+    private _pendingExternalMasterData;
+    private _earlyHiTagCatalogCallbacks;
     private _hscInstance;
     private _glbInstance;
     private _configurator;
     private _currentMode;
+    private _isDragInInProgress;
     constructor(creator: string, activePlugins?: P);
     setEnvironmentMap(params: {
         url?: string;
@@ -8701,7 +8369,7 @@ export declare class RoomlePlanner<P extends readonly PluginName[] = readonly []
      * Set general configuration parameter
      * @param initData
      */
-    setOverrides(initData: InitDataDefinition & GlobalInitDataDefinition): void;
+    setOverrides(initData?: InitDataDefinition & GlobalInitDataDefinition): void;
     toggleConfigureInRoom(): void;
     switch2D(): void;
     switch3D(): void;
@@ -8747,7 +8415,7 @@ export declare class RoomlePlanner<P extends readonly PluginName[] = readonly []
      * Has to be overridden by main class.
      * @hidden
      */
-    getMain(): Main;
+    getMain(): Main | undefined;
     update(): void;
     get callbacks(): RoomlePlannerUiCallback;
     set callbacks(callback: RoomlePlannerUiCallback);
@@ -8760,7 +8428,7 @@ export declare class RoomlePlanner<P extends readonly PluginName[] = readonly []
     onCloseHSC(): void;
     back(): void;
     backTo(_cssClass: string): void;
-    getConfigurator(): Configurator;
+    getConfigurator(): Configurator | null;
     getCurrentSkin(): Promise<RapiSkin>;
     /**
      * Returns the runtime component id of the plan object with the given id
@@ -8807,6 +8475,7 @@ export declare class RoomlePlanner<P extends readonly PluginName[] = readonly []
      */
     mergeItems(itemList: PlanObject[]): void;
     getScene(): Scene;
+    getSceneManager(): PlannerSceneManager;
     updateScene(): void;
     getCameraOffset(): CanvasOffset;
     setCameraOffset(offset: CanvasOffset): void;
@@ -8995,7 +8664,7 @@ export declare class RoomlePlanner<P extends readonly PluginName[] = readonly []
     downloadHomagIxExportPoC(): Promise<any>;
     externalObjectsCompletelyLoaded(): void;
     configureExternalObjectApi(configurationJson: string | ExternalObjectApiConfiguration): Promise<void>;
-    loadExternalObjectLibrary(libraryId: string): Promise<void>;
+    loadExternalObjectLibrary(libraryId: string, prefetchedArticleJson?: Promise<unknown>): Promise<void>;
     loadExternalObjectMasterData(masterDataJson: string | object): void;
     getInitialExternalObjectGroup(): Promise<PosGroup | null>;
     loadNewExternalObjectInIsolation(groupObject: object): Promise<LoadExternalObjectGroupResult[]>;
@@ -9131,6 +8800,7 @@ export declare class RoomlePlanner<P extends readonly PluginName[] = readonly []
      */
     redo(): Promise<void>;
     setHomagIntelligence(homagIntelligence: HomagIntelligence): void;
+    private _getSubArticleId;
     newPosDataFromId(id: string): Promise<PosGroup>;
     /**
      * deprecated, use placeOrder() instead
@@ -9150,7 +8820,7 @@ export declare class RoomlePlanner<P extends readonly PluginName[] = readonly []
     fetchPrice(planId?: string, orderHeader?: HiOrderHeader): Promise<any>;
     getOrderManagerGroupData(planId?: string): Promise<HiOrderData>;
     getRapiAccess(): RapiAccess;
-    getElementOpenCloseAnimation(planElement: PlanElementViewModel): AnimationKeyAndValue | null;
+    getElementOpenCloseAnimation(planElement: PlanElementViewModel, componentIds?: number[]): AnimationKeyAndValue | null;
     /**
      * Sets the distance between a construction element (door/window) and a wall edge.
      *
@@ -9338,6 +9008,45 @@ export declare class RoomlePlannerUiCallback extends UiCallback implements Exter
 
 export declare type RoomlePlannerWithExtObjs = RoomlePlanner<['external-objects']>;
 
+export declare abstract class RoomleRenderer<RendererType extends WebGLRenderer | WebGPURenderer> {
+    _creator_: string;
+    renderer: RendererType;
+    protected isConfiguratorMode: boolean;
+    protected isCameraMoving: boolean;
+    protected cameraType: Enumify_4<typeof CAMERA_TYPE>;
+    protected shadowNeedsUpdate: boolean;
+    protected boundingBox: Box3;
+    protected boundingBoxNeedsUpdate: boolean;
+    protected constructor(creator: string, renderer: RendererType);
+    get isConfiguring(): boolean;
+    dispose(): void;
+    setSize(width: number, height: number): void;
+    getSize(target: Vector2): Vector2;
+    setCameraType(cameraType: Enumify_4<typeof CAMERA_TYPE>): void;
+    movingCameraStarts(): void;
+    movingCameraStops(): void;
+    forceShadowUpdates(_updateBakedGroundShadow: boolean): void;
+    clear(): void;
+    updateBounds(geometryBounds: Box3): void;
+    switchToConfigurator(): void;
+    switchToPlanner(_renderMode: PlannerRenderMode): void;
+    abstract setShadingType(shadingType: SceneShadingType): void;
+    abstract setAutoQuality(autoQuality: boolean): void;
+    abstract setQualityLevel(qualityLevel: QualityLevel): void;
+    abstract getQualityLevel(): QualityLevel;
+    abstract setQualityMap(qualityMap: QualityMap): void;
+    abstract setCustomShadingParameters(customShadingParameters?: CustomShadingParameters, customShadingParametersMoc?: CustomShadingParameters): void;
+    abstract loadLutImages(luts: LutImageDefinition[]): void;
+    abstract render(scene: Scene, camera: Camera): void;
+    abstract showGUI(updateCallback: () => void): void;
+    abstract setOnQualityLevelChangeCallback(callback: (qualityLevel: QualityLevel) => void): void;
+    abstract clearCache(): void;
+    abstract highlightObjects(selectedMeshes: Object3D[]): void;
+    abstract setGroundShadow(enabled: boolean): void;
+    abstract enableUiInteractionMode(): void;
+    abstract disableUiInteractionMode(): void;
+}
+
 export declare class RoomleSdk {
     static getConfigurator(initData?: InitDataDefinition, context?: string): Promise<Configurator>;
     static getPlanner(initData?: InitDataDefinition, context?: string): Promise<Planner>;
@@ -9398,69 +9107,6 @@ export declare class RoomleToolsCore implements Context, ExternalEmbeddable<Room
 export declare interface RoomleToolsCoreUICallback {
 }
 
-export declare class RoomleWebGLRenderer {
-    _creator_: string;
-    static enableRectAreaLightShadow: boolean;
-    private static rectAreaLightsNeedsUpdate;
-    private static updateNearAndFarPlaneOfPerspectiveCamera;
-    private _renderer;
-    private _sceneRenderer;
-    private SceneRendererGUI;
-    private configuratorMode;
-    private uiInteractionMode;
-    private _movingCamera;
-    private _cameraType;
-    private _boundingBox;
-    private _boundingBoxNeedsUpdate;
-    private _cacheNeedsUpdate;
-    private _shadowNeedsUpdate;
-    private _bakedGroundShadowNeedsUpdate;
-    private _customShadingParameters;
-    private _customShadingParametersMoc;
-    private _fpsCounter;
-    private _onQualityLevelChange;
-    get renderer(): WebGLRenderer | WebGPURenderer;
-    get sceneRenderer(): SceneRenderer;
-    get isConfiguring(): boolean;
-    get screenSpaceShadowParameters(): ScreenSpaceShadowMapParameters;
-    get shadowAndAoPassParameters(): ShadowAndAoPassParameters;
-    get bakedGroundContactShadowParameters(): BakedGroundContactShadowParameters;
-    get groundReflectionParameters(): GroundReflectionParameters;
-    get outlineParameters(): OutlineParameters;
-    constructor(creator: string, renderer: WebGLRenderer | WebGPURenderer, width: number, height: number, linearAoFilter?: boolean);
-    dispose(): void;
-    setSize(width: number, height: number): void;
-    getSize(target: Vector2): Vector2;
-    setCameraType(cameraType: Enumify_3<typeof CAMERA_TYPE>): void;
-    setShadingType(shadingType: SceneShadingType): void;
-    setAutoQuality(autoQuality: boolean): void;
-    setQualityLevel(qualityLevel: QualityLevel): void;
-    setQualityMap(qualityMap: QualityMap): void;
-    setCustomShadingParameters(customShadingParameters?: CustomShadingParameters, customShadingParametersMoc?: CustomShadingParameters): void;
-    enableUiInteractionMode(): void;
-    disableUiInteractionMode(): void;
-    private loadRectAreLight;
-    private updateRectAreaLight;
-    private updateCeilingLights;
-    private updateLampLights;
-    private _setQualityLevel;
-    clearCache(): void;
-    forceShadowUpdates(updateBakedGroundShadow: boolean): void;
-    setGroundShadow(enabled: boolean): void;
-    switchToConfigurator(): void;
-    switchToPlanner(renderMode: RenderMode): void;
-    updateBounds(geometryBounds?: Box3): void;
-    movingCameraStarts(): void;
-    movingCameraStops(): void;
-    highlightObjects(selectedMeshes: Object3D[]): void;
-    render(scene: Scene, camera: Camera): void;
-    private _doUpdatesBeforeRender;
-    private createRenderCamera;
-    showGUI(updateCallback: () => void): void;
-    clear(): void;
-    setOnQualityLevelChangeCallback(callback: (qualityLevel: QualityLevel) => void): void;
-}
-
 export declare interface RoomLightSourceDistribution {
     ceilingId: number;
     floorId: number;
@@ -9513,13 +9159,13 @@ export declare abstract class SceneEventHandler<EventType> extends EventDispatch
 }
 
 export declare class SceneEventInfo {
-    component: RoomleComponent;
-    preview: PreviewComponent;
+    component: RoomleComponent | undefined;
+    preview: PreviewComponent | undefined;
     resetCamera: boolean;
     consecutive: boolean;
     type: INPUT_EVENT_TYPE;
     forceRender: boolean;
-    reason: CancelSelectionReasons;
+    reason: CancelSelectionReasons | undefined;
     constructor(data: {
         component?: RoomleComponent;
         preview?: PreviewComponent;
@@ -9532,11 +9178,11 @@ export declare class SceneEventInfo {
 }
 
 export declare class SceneEventInfo_2 {
-    planElementViewModel: PlanElementViewModel;
+    planElementViewModel?: PlanElementViewModel;
     resetCamera: boolean;
     state: PLANNER_SCENE_EVENT_STATE;
     oldState: PLANNER_SCENE_EVENT_STATE;
-    reason: CancelSelectionReasons;
+    reason?: CancelSelectionReasons;
     constructor(data: {
         planElementViewModel?: PlanElementViewModel;
         resetCamera?: boolean;
@@ -9589,7 +9235,7 @@ export declare abstract class SceneManager implements Context, LifeCycleCallback
     protected _renderLoopFunction: (() => void) | null;
     protected _renderListener: (() => void) | null;
     protected _stopRendering: boolean;
-    protected _roomleRenderer: Nullable_2<RoomleWebGLRenderer>;
+    protected _roomleRenderer: GenericRoomleRenderer | null;
     private _forceRender;
     private _lastChange;
     private _running;
@@ -9610,6 +9256,8 @@ export declare abstract class SceneManager implements Context, LifeCycleCallback
     addEventListener(_listener: LifeCycleCallbacks): void;
     removeEventListener(_listener: LifeCycleCallbacks): void;
     get lightCache(): LightCache | null;
+    getRoomleRenderer(): GenericRoomleRenderer;
+    getRenderer(): WebGLRenderer | WebGPURenderer | null;
     protected _changeCameraBehaviour(cameraBehaviour: CameraBehaviour): void;
     protected onCameraChanged(): void;
     cameraBehaviourChanged(updateDistance?: boolean): void;
@@ -9682,6 +9330,7 @@ export declare abstract class SceneManager implements Context, LifeCycleCallback
     protected _hasCameraControl2D(): boolean;
     protected _getCameraControl2D(): CameraControl2D;
     protected _getCameraControlFirstPerson(): CameraControlFirstPerson;
+    createUSDZExport(): Promise<Uint8Array<ArrayBuffer>>;
     exportUSDZ(): Promise<void>;
     createExportGLB(objectFilter?: (object: Object3D) => boolean): Promise<ArrayBuffer | null>;
     exportGLB(): Promise<void>;
@@ -9700,107 +9349,6 @@ export declare interface ScenePluginHooks {
     needsUiScene(): boolean;
 }
 
-export declare class SceneRenderer {
-    _creator_: string;
-    parameters: SceneRendererParameters;
-    debugOutput: string;
-    outputColorSpace: string;
-    toneMapping: string;
-    linearAoFilter: boolean;
-    environmentLights: boolean;
-    enableObjectSelection: boolean;
-    groundLevel: number;
-    uiInteractionMode: boolean;
-    renderer: WebGLRenderer | WebGPURenderer;
-    width: number;
-    height: number;
-    boundingVolume: SceneVolume;
-    boundingVolumeSet: boolean;
-    renderCacheManager: RenderCacheManager;
-    private _renderPassManager;
-    private _shadowAndAoGroundPlane;
-    outlineRenderer: OutlineRenderer;
-    selectedObjects: Object3D[];
-    private _copyMaterial?;
-    readonly groundGroup: Group;
-    private _shadingType;
-    private _qualityLevel;
-    private _qualityMap;
-    private _customShadingParameters;
-    private _initData;
-    get sceneRenderPass(): SceneRenderPass;
-    get bakedGroundContactShadowPass(): BakedGroundContactShadowPass;
-    get gBufferRenderPass(): GBufferRenderPass;
-    get groundReflectionPass(): GroundReflectionPass;
-    get screenSpaceShadowMapPass(): ScreenSpaceShadowMapPass;
-    get shadowAndAoPass(): ShadowAndAoPass;
-    get lutPassParameters(): LutPassParameters;
-    get lutMaps(): string[];
-    get debugPass(): DebugPass;
-    get shadowAndAoGroundPlane(): ShadowGroundPlane;
-    constructor(creator: string, renderer: WebGLRenderer | WebGPURenderer, width: number, height: number, linearAoFilter?: boolean);
-    private _addEventListeners;
-    dispose(): void;
-    setSize(width: number, height: number): void;
-    loadLutImages(luts: LutImageDefinition[]): void;
-    getQualityLevel(): QualityLevel;
-    setShadingType(shadingType: SceneShadingType): void;
-    setQualityLevel(qualityLevel: QualityLevel): void;
-    setQualityMap(qualityMap: QualityMap): void;
-    setCustomShadingParameters(customShadingParameters: CustomShadingParameters | null): void;
-    setQualityMapAndShadingParameters(qualityMap: QualityMap, customShadingParameters: CustomShadingParameters | null): void;
-    applyCurrentParameters(): void;
-    requestUpdateOfPasses(): void;
-    clearCache(): void;
-    forceShadowUpdates(updateBakedGroundShadow: boolean): void;
-    forceLutPassUpdate(): void;
-    updateParameters(parameters: SceneRendererChangeParameters): void;
-    addRectAreaLight(rectAreaLight: RectAreaLight, parent: Object3D): void;
-    updateRectAreaLights(rectAreaLights: RectAreaLight[], parent: Object3D): void;
-    createShadowFromLightSources(parent: Object3D, lightSources: LightSource[]): void;
-    selectObjects(selectedObjects: Object3D[]): void;
-    updateBounds(bounds: Box3, scaleShadowAndAo: boolean): void;
-    updateNearAndFarPlaneOfPerspectiveCamera(camera: PerspectiveCamera, minimumFar?: number): void;
-    private _forceEnvironmentMapUpdate;
-    private _updateEnvironment;
-    render(scene: Scene, camera: Camera): void;
-}
-
-export declare interface SceneRendererChangeParameters {
-    shadowType?: string;
-    shAndAoPassParameters?: ShadowAndAoPassParameters;
-    screenSpaceShadowMapParameters?: ScreenSpaceShadowMapParameters;
-    groundReflectionParameters?: GroundReflectionParameters;
-    bakedGroundContactShadowParameters?: BakedGroundContactShadowParameters;
-    outlineParameters?: OutlineParameters;
-    effectSuspendFrames?: number;
-    effectFadeInFrames?: number;
-    suspendGroundReflection?: boolean;
-    shadowOnCameraChange?: ShadowBlurType;
-}
-
-export declare interface SceneRendererParameters {
-    gBufferRenderTargetParameters: GBufferParameters;
-    shAndAoPassParameters: ShadowAndAoPassParameters;
-    screenSpaceShadowMapParameters: ScreenSpaceShadowMapParameters;
-    groundReflectionParameters: GroundReflectionParameters;
-    bakedGroundContactShadowParameters: BakedGroundContactShadowParameters;
-    outlineParameters: OutlineParameters;
-    effectSuspendFrames: number;
-    effectFadeInFrames: number;
-    suspendGroundReflection: boolean;
-    shadowOnCameraChange: ShadowBlurType;
-}
-
-export declare class SceneRenderPass extends RenderPass {
-    drawGround: boolean;
-    drawWithDebugMaterial: boolean;
-    grayDebugMaterial: MeshStandardMaterial;
-    constructor(renderPassManager: RenderPassManager);
-    dispose(): void;
-    renderPass(renderer: WebGLRenderer | WebGPURenderer): void;
-}
-
 export declare interface SceneSettings {
     environment: EnvironmentSetting;
     lights: DynamicLight[];
@@ -9808,88 +9356,6 @@ export declare interface SceneSettings {
 
 export declare type SceneShadingType = Enumify_2<typeof SCENE_SHADING_TYPES>;
 
-export declare class SceneVolume {
-    bounds: Box3;
-    size: Vector3;
-    center: Vector3;
-    maxSceneDistanceFromCenter: number;
-    maxSceneDistanceFrom0: number;
-    updateFromBox(boundingBox: Box3): void;
-    updateCameraViewVolumeFromBounds(camera: Camera): void;
-    getNearAndFarForPerspectiveCamera(cameraPosition: Vector3, backScale?: number): number[];
-}
-
-export declare interface ScreenSpaceShadowMapConstructorParameters {
-    samples?: number;
-    shadowMapSize?: number;
-    alwaysUpdate?: boolean;
-    enableShadowMap?: boolean;
-    layers?: Layers | null;
-    shadowLightSourceType?: ShadowLightSourceType;
-    maximumNumberOfLightSources?: number;
-    directionalDependency?: number;
-    directionalExponent?: number;
-    groundBoundary?: number;
-    fadeOutDistance?: number;
-    fadeOutBlur?: number;
-}
-
-export declare interface ScreenSpaceShadowMapParameters {
-    [key: string]: any;
-    alwaysUpdate: boolean;
-    enableShadowMap: boolean;
-    enableGroundBoundary: boolean;
-    layers: Layers | null;
-    shadowLightSourceType: ShadowLightSourceType;
-    maximumNumberOfLightSources: number;
-    directionalDependency: number;
-    directionalExponent: number;
-    groundBoundary: number;
-    fadeOutDistance: number;
-    fadeOutBlur: number;
-}
-
-export declare class ScreenSpaceShadowMapPass extends RenderPass {
-    parameters: ScreenSpaceShadowMapParameters;
-    needsUpdate: boolean;
-    drawGround: boolean;
-    shadowTypeNeedsUpdate: boolean;
-    shadowConfiguration: ShadowTypeConfiguration;
-    private _shadowLightSources;
-    private _shadowMapPassOverrideMaterialCache;
-    private _viewportSize;
-    private _samples;
-    private _shadowScale;
-    private _groundMapScale;
-    private _shadowMapSize;
-    castShadow: boolean;
-    private _shadowRenderTarget;
-    private _cameraUpdate;
-    get shadowTexture(): Texture;
-    set shadowOnGround(value: boolean);
-    constructor(renderPassManager: RenderPassManager, viewportSize: Vector2, parameters: ScreenSpaceShadowMapConstructorParameters);
-    private _getScreenSpaceShadowMapParameters;
-    dispose(): void;
-    updateParameters(parameters: ScreenSpaceShadowMapParameters): void;
-    updateBounds(sceneBounds: SceneVolume, scaleShadow: number): void;
-    forceShadowUpdate(): void;
-    getShadowLightSources(): Light[];
-    findShadowLightSource(lightSource: Light): Light | undefined;
-    addRectAreaLight(rectAreaLight: RectAreaLight, parent: Object3D): void;
-    updateRectAreaLights(rectAreaLights: RectAreaLight[], parent: Object3D): void;
-    createShadowFromLightSources(parent: Object3D, lightSources: LightSource[]): void;
-    private _addShadowFromLightSources;
-    private _createShadowLightSourceArray;
-    setSize(width: number, height: number): void;
-    updatePositionAndTarget(): void;
-    renderPass(renderer: WebGLRenderer | WebGPURenderer): void;
-    private _renderSimpleShadowMapFromShadowLightSources;
-    private _getSortedShadowLightSources;
-    private _setShadowLightSourcesIntensity;
-    private _updateShadowType;
-    switchType(type: string): boolean;
-}
-
 export declare interface ScriptData {
     name: string;
     id: string;
@@ -9903,6 +9369,10 @@ export declare class ScriptLoader implements Context {
         id: string;
     }): Promise<unknown>;
     loadScripts(scripts: ScriptData[]): Promise<any[]>;
+    resolveKernelPaths(type: 'configurator' | 'planner' | 'tools'): {
+        wasm: string;
+        loader: string;
+    };
     cleanUp(): void;
 }
 
@@ -9925,144 +9395,11 @@ export declare interface SelectionPayload {
     permissionToDelete?: number;
 }
 
-export declare const SHADOW_BLUR_TYPES: {
-    readonly OFF: "off";
-    readonly HARD: "hard";
-    readonly POISSON: "poisson";
-    readonly FULL: "full";
-};
-
-export declare const SHADOW_LIGHT_SOURCE_TYPES: {
-    readonly DIRECTION_LIGHT_SHADOW: "DirectionalLightShadow";
-    readonly SPOT_LIGHT_SHADOW: "SpotLightShadow";
+export declare const SET_WALL_MATERIAL_TYPE: {
+    readonly INTERIOR: "interior";
+    readonly EXTERIOR: "exterior";
 };
 
-export declare class ShadowAndAoPass extends RenderPass {
-    static shadowTransform: Matrix4;
-    parameters: ShadowAndAoPassParameters;
-    needsUpdate: boolean;
-    renderToRenderTarget: boolean;
-    shadowAndAoPassSettings: ShadowAndAoPassSettings;
-    private _width;
-    private _height;
-    private _samples;
-    private _aoAndSoftShadowRenderTarget?;
-    private _softShadowPass?;
-    private _aoPass?;
-    private _fadeRenderTarget?;
-    private _poissonDenoisePass?;
-    private _copyMaterial;
-    private _blendMaterial;
-    private _blendAoAndShadowMaterial;
-    private _cameraUpdate;
-    private _finalTexture;
-    private _onlyHardShadow;
-    get aoAndSoftShadowRenderTarget(): WebGLRenderTarget;
-    get aoRenderPass(): AORenderPass;
-    get softShadowPass(): PoissonDenoiseRenderPass;
-    get fadeRenderTarget(): WebGLRenderTarget;
-    get denoisePass(): DenoisePass;
-    get denoiseRenderTargetTexture(): Texture | null;
-    get finalTexture(): Texture | null;
-    constructor(renderPassManager: RenderPassManager, width: number, height: number, samples: number, parameters?: ShadowAndAoPassConstructorParameters);
-    dispose(): void;
-    setSize(width: number, height: number): void;
-    updateParameters(parameters: ShadowAndAoPassParameters): void;
-    private _updatePassParameters;
-    updateBounds(sceneBounds: SceneVolume, _shadowAndAoScale: number): void;
-    private _getRenderConditions;
-    renderPass(renderer: WebGLRenderer | WebGPURenderer): void;
-    private _setRenderState;
-    private _evaluateIfUpdateIsNeeded;
-    private _renderShadowAndAo;
-    private _renderAo;
-    private _renderSoftShadow;
-    private _renderDynamicShadow;
-    private _renderDenoise;
-    renderToTarget(renderer: WebGLRenderer): void;
-}
-
-export declare interface ShadowAndAoPassConstructorParameters {
-    enabled?: boolean;
-    applyToMaterial?: boolean;
-    aoIntensity?: number;
-    shadowIntensity?: number;
-    aoOnGround?: boolean;
-    shadowOnGround?: boolean;
-    alwaysUpdate?: boolean;
-    progressiveDenoiseIterations?: number;
-    shadow?: ShadowParameters;
-    ao?: AORenderPassParameters;
-    poissonDenoise?: PoissonDenoisePassParameters;
-}
-
-export declare interface ShadowAndAoPassParameters {
-    enabled: boolean;
-    applyToMaterial: boolean;
-    aoIntensity: number;
-    shadowIntensity: number;
-    aoOnGround: boolean;
-    shadowOnGround: boolean;
-    alwaysUpdate: boolean;
-    progressiveDenoiseIterations: number;
-    shadow: ShadowParameters;
-    ao: AORenderPassParameters;
-    poissonDenoise: PoissonDenoisePassParameters;
-}
-
-export declare interface ShadowAndAoPassSettings {
-    shadowMapTexture: Texture | null;
-    shadowBlurType: ShadowBlurType;
-    shadowFadeInBlurType: ShadowBlurType;
-    shadowFadeInMix: number;
-    noOStaticFrames: number;
-}
-
-export declare type ShadowBlurType = Enumify_5<typeof SHADOW_BLUR_TYPES>;
-
-export declare class ShadowGroundPlane extends Mesh {
-    static alphaMap: boolean;
-    constructor(shadowMap: Texture | null, parameters?: ShadowGroundPlaneParameters);
-    setVisibility(visible: boolean): void;
-    setVisibilityLayers(visible: boolean): void;
-    setDepthWrite(write: boolean): void;
-    setReceiveShadow(receive: boolean): void;
-    setShadowMap(shadowMap: Texture | null): void;
-    updateMaterial(parameters: ShadowGroundPlaneParameters): void;
-}
-
-export declare interface ShadowGroundPlaneParameters {
-    opacity?: number;
-    polygonOffset?: number;
-}
-
-export declare type ShadowLightSourceType = Enumify_5<typeof SHADOW_LIGHT_SOURCE_TYPES>;
-
-export declare interface ShadowParameters {
-    [key: string]: any;
-    shadowRadius: number;
-}
-
-export declare class ShadowTypeConfiguration {
-    private static _noShadow;
-    private static _basicShadow;
-    private static _pcfShadow;
-    private static _vcmShadow;
-    types: Map<string, ShadowTypeParameters>;
-    private static _defaultType;
-    shadowType: string;
-    currentConfiguration: ShadowTypeParameters;
-    switchType(type: any): boolean;
-}
-
-export declare interface ShadowTypeParameters {
-    castShadow: boolean;
-    type: ShadowMapType;
-    bias: number;
-    normalBias: number;
-    radius: number;
-}
-
 export declare const enum SHORT_TYPES {
     UNKNOWN = 0,
     PLAN = 1,
@@ -10101,7 +9438,7 @@ export declare class StaticPlanObjectViewModel extends PlanObjectViewModel {
     private _addStaticItem;
     getRapiItem(): RapiItem;
     needsRapiItem(): boolean;
-    getGLBUrl(): string;
+    getGLBUrl(): string | null;
     update(): void;
 }