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

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 {
@@ -803,7 +627,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 +826,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;
@@ -1180,7 +1004,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 +1270,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;
@@ -1608,7 +1432,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 +1536,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 +1553,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 +1655,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 +1702,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 +1751,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
@@ -2365,7 +2188,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 +2215,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;
@@ -2524,24 +2332,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 +2361,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;
@@ -3423,63 +3198,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",
@@ -3665,64 +3384,6 @@ export declare interface GlueLogic {
     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 +3575,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;
@@ -4405,7 +4068,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 +4379,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 +4392,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 +4449,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 +4609,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;
 }
 
@@ -5034,8 +4673,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 +4712,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 +4762,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 +4863,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 +4940,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 +5067,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 +5209,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;
@@ -5818,7 +5334,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 +5355,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 +5365,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;
@@ -5934,6 +5451,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 +5553,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;
@@ -6228,13 +5750,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 +5791,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 +5804,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;
@@ -6323,7 +5845,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 +5865,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 +6271,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 +6621,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 {
@@ -7436,7 +6895,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 +6905,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 +6915,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 +6940,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,
@@ -7784,7 +7125,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 +7345,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,6 +8008,8 @@ 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;
@@ -8995,7 +8338,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[]>;
@@ -9150,7 +8493,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 +8681,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 +8780,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 +8832,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 +8851,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 +8908,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;
@@ -9700,107 +9019,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 +9026,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;
@@ -9925,144 +9061,6 @@ 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 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 +9099,7 @@ export declare class StaticPlanObjectViewModel extends PlanObjectViewModel {
     private _addStaticItem;
     getRapiItem(): RapiItem;
     needsRapiItem(): boolean;
-    getGLBUrl(): string;
+    getGLBUrl(): string | null;
     update(): void;
 }