@smplrspace/smplr-loader 2.57.2-beta.0 → 2.57.2-beta.10

package/dist/generated/smplr.d.ts

@@ -1,31 +1,43 @@
+import type { AbstractEngine } from '@babylonjs/core/Engines/abstractEngine';
+import type { ActionManager } from '@babylonjs/core/Actions/actionManager';
 import { ArcRotateCamera } from '@babylonjs/core/Cameras/arcRotateCamera';
+import type { AssetsManager } from '@babylonjs/core/Misc/assetsManager';
+import type { CascadedShadowGenerator } from '@babylonjs/core/Lights/Shadows/cascadedShadowGenerator';
+import { Color4 } from '@babylonjs/core/Maths/math.color';
 import { CSSProperties } from 'react';
-import { Dispatch } from 'react';
+import type { DirectionalLight } from '@babylonjs/core/Lights/directionalLight';
 import { EasingOptions } from 'mapbox-gl';
+import { ExtractCFromProps } from 'mobx-state-tree/dist/internal';
 import { GetTokenSilentlyOptions } from '@auth0/auth0-spa-js';
+import type { HemisphericLight } from '@babylonjs/core/Lights/hemisphericLight';
 import { IArrayType } from 'mobx-state-tree';
+import { IMapType } from 'mobx-state-tree';
 import { IMaybe } from 'mobx-state-tree';
 import { IModelType } from 'mobx-state-tree';
 import { Instance } from 'mobx-state-tree';
 import { IOptionalIType } from 'mobx-state-tree';
 import { ISimpleType } from 'mobx-state-tree';
 import { IType } from 'mobx-state-tree';
+import { ITypeUnion } from 'mobx-state-tree';
 import { LogoutOptions } from '@auth0/auth0-spa-js';
 import { MapMouseEvent } from 'mapbox-gl';
+import { Matrix } from '@babylonjs/core/Maths/math.vector';
 import { Mesh } from '@babylonjs/core/Meshes/mesh';
-import { default as NoSleep_2 } from 'nosleep.js';
+import { ModelCreationType } from 'mobx-state-tree';
+import { ModelInstanceType } from 'mobx-state-tree';
+import { ModelSnapshotType } from 'mobx-state-tree';
 import { _NotCustomized } from 'mobx-state-tree';
+import type { PBRMetallicRoughnessMaterial } from '@babylonjs/core/Materials/PBR/pbrMetallicRoughnessMaterial';
 import { RedirectLoginOptions } from '@auth0/auth0-spa-js';
-import { Reducer } from 'react';
-import { ReducerAction } from 'react';
 import { RefObject } from 'react';
 import { Scene } from '@babylonjs/core/scene';
+import type { ShadowGenerator } from '@babylonjs/core/Lights/Shadows/shadowGenerator';
 import { SnapshotIn } from 'mobx-state-tree';
 import { SnapshotOut } from 'mobx-state-tree';
-import { UniversalCamera } from '@babylonjs/core/Cameras/universalCamera';
 import { User as User_2 } from '@auth0/auth0-spa-js';
 import { Vector2 } from '@babylonjs/core/Maths/math';
-import { VRDeviceOrientationFreeCamera } from '@babylonjs/core/Cameras/VR/vrDeviceOrientationFreeCamera';
+import { Vector3 } from '@babylonjs/core/Maths/math.vector';
+import { Vector3 as Vector3_2 } from '@babylonjs/core/Maths/math';
 
 declare const AbstractSegment: IModelType<    {
 start: IModelType<    {
@@ -301,7 +313,7 @@ export declare type DataLayer<D extends UnknownData = NoData> = PointDataLayer<D
 export declare class DataLayerController<D extends UnknownData> {
     private dataLayer;
     private scene;
-    private dispatchDataLayersDefinition;
+    private store;
     private viewerRef;
     constructor(initOptions: DataLayerControllerInitOptions<D>);
     add(): void;
@@ -313,27 +325,10 @@ export declare class DataLayerController<D extends UnknownData> {
 declare interface DataLayerControllerInitOptions<D extends UnknownData> {
     dataLayer: DataLayer<D>;
     scene: SmplrScene;
-    dispatchDataLayersDefinition: DispatchDataLayersDefinitionFn;
+    store: IViewerStore;
     viewerRef: RefObject<ViewerRendererHandle>;
 }
 
-declare type DataLayersDefinitionActions<D extends UnknownData> = {
-    type: 'add';
-    layer: DataLayer<D>;
-} | {
-    type: 'update';
-    layer: Partial<Omit<DataLayer<D>, 'type'>>;
-} | {
-    type: 'remove';
-    layer: {
-        id: string;
-    };
-};
-
-declare type DataLayersDefinitionReducer<D extends UnknownData = UnknownData> = Reducer<DataLayersDefinitionState<D>, DataLayersDefinitionActions<D>>;
-
-declare type DataLayersDefinitionState<D extends UnknownData> = Record<string, DataLayer<D>>;
-
 declare type DeepPartial<T> = T extends object ? {
     [P in keyof T]?: DeepPartial<T[P]>;
 } : T;
@@ -359,7 +354,11 @@ declare type DeskConfiguration = {
 
 declare type DeskSide = 'feet' | 'plank' | 'drawers';
 
-declare type DispatchDataLayersDefinitionFn = Dispatch<ReducerAction<DataLayersDefinitionReducer>>;
+declare interface Dimensions {
+    length: number;
+    height: number;
+    width: number;
+}
 
 export declare interface DottedPolylineDataLayer<D extends UnknownData = NoData> extends BaseDataLayer<PolylineData, D> {
     id: string;
@@ -377,6 +376,28 @@ export declare interface DottedPolylineDataLayer<D extends UnknownData = NoData>
     disableElevationCorrection?: boolean;
 }
 
+declare const DottedPolylineViewerDataLayer: IModelType<    {
+definition: IType<DottedPolylineDataLayer<UnknownData>, DottedPolylineDataLayer<UnknownData>, DottedPolylineDataLayer<UnknownData>>;
+compiledTooltipTemplate: IMaybe<IType<    {
+fn: (dataElement: UnknownData) => string;
+}, {
+fn: (dataElement: UnknownData) => string;
+}, {
+fn: (dataElement: UnknownData) => string;
+}>>;
+touchCount: IOptionalIType<ISimpleType<number>, [undefined]>;
+} & {
+type: ISimpleType<LayerType.DottedPolyline>;
+}, {
+readonly renderableDefinition: RenderableDataLayer<DottedPolylineDataLayer<UnknownData>>;
+readonly renderState: ViewerDataLayerRenderState<DottedPolylineDataLayer<UnknownData>>;
+readonly persistentTooltipSources: PersistentTooltipSource[];
+} & {
+setCompiledTooltipTemplate(compiledTemplate: (dataElement: UnknownData) => string): void;
+touch(): void;
+updateDefinition(updates: Partial<Omit<DottedPolylineDataLayer<UnknownData>, "type">>): void;
+}, _NotCustomized, _NotCustomized>;
+
 declare const drawColorSwatches: ({ containerId, ...swatchesProps }: ColorSwatchesProps & {
     containerId: string;
 }) => void;
@@ -411,6 +432,12 @@ export declare type EditorOptions = {
     container: HTMLElement;
 });
 
+declare interface ElementRenderState {
+    render?: boolean;
+    includeLayers?: string[];
+    omitLayers?: string[];
+}
+
 export declare interface EmbeddedEditorUser {
     id: string;
     name?: string;
@@ -538,6 +565,28 @@ export declare interface FurnitureDataLayer<D extends UnknownData = NoData> exte
     color?: string | ((dataElement: FurnitureData & D) => string);
 }
 
+declare const FurnitureViewerDataLayer: IModelType<    {
+definition: IType<FurnitureDataLayer<UnknownData>, FurnitureDataLayer<UnknownData>, FurnitureDataLayer<UnknownData>>;
+compiledTooltipTemplate: IMaybe<IType<    {
+fn: (dataElement: UnknownData) => string;
+}, {
+fn: (dataElement: UnknownData) => string;
+}, {
+fn: (dataElement: UnknownData) => string;
+}>>;
+touchCount: IOptionalIType<ISimpleType<number>, [undefined]>;
+} & {
+type: ISimpleType<LayerType.Furniture>;
+}, {
+readonly renderableDefinition: RenderableDataLayer<FurnitureDataLayer<UnknownData>>;
+readonly renderState: ViewerDataLayerRenderState<FurnitureDataLayer<UnknownData>>;
+readonly persistentTooltipSources: PersistentTooltipSource[];
+} & {
+setCompiledTooltipTemplate(compiledTemplate: (dataElement: UnknownData) => string): void;
+touch(): void;
+updateDefinition(updates: Partial<Omit<FurnitureDataLayer<UnknownData>, "type">>): void;
+}, _NotCustomized, _NotCustomized>;
+
 export declare interface GeoPoint {
     lng: number;
     lat: number;
@@ -764,6 +813,14 @@ declare type GroundFootprintGetter<C> = (args: {
     configuration: Partial<C>;
 }) => Vector2[];
 
+declare interface GroundMaterials {
+    indoor: PBRMetallicRoughnessMaterial;
+    grass: PBRMetallicRoughnessMaterial;
+    water: PBRMetallicRoughnessMaterial;
+    darkgrey: PBRMetallicRoughnessMaterial;
+    white: PBRMetallicRoughnessMaterial;
+}
+
 declare const GroundSegment: IModelType<    {
 start: IModelType<    {
 r: ISimpleType<number>;
@@ -834,6 +891,28 @@ declare interface HeatmapSpheresOptions {
 
 declare type HeatmapStyleOptions = HeatmapSpheresOptions | HeatmapGridOptions | HeatmapBarChartOptions;
 
+declare const HeatmapViewerDataLayer: IModelType<    {
+definition: IType<HeatmapDataLayer<UnknownData>, HeatmapDataLayer<UnknownData>, HeatmapDataLayer<UnknownData>>;
+compiledTooltipTemplate: IMaybe<IType<    {
+fn: (dataElement: UnknownData) => string;
+}, {
+fn: (dataElement: UnknownData) => string;
+}, {
+fn: (dataElement: UnknownData) => string;
+}>>;
+touchCount: IOptionalIType<ISimpleType<number>, [undefined]>;
+} & {
+type: ISimpleType<LayerType.Heatmap>;
+}, {
+readonly renderableDefinition: RenderableDataLayer<HeatmapDataLayer<UnknownData>>;
+readonly renderState: ViewerDataLayerRenderState<HeatmapDataLayer<UnknownData>>;
+readonly persistentTooltipSources: PersistentTooltipSource[];
+} & {
+setCompiledTooltipTemplate(compiledTemplate: (dataElement: UnknownData) => string): void;
+touch(): void;
+updateDefinition(updates: Partial<Omit<HeatmapDataLayer<UnknownData>, "type">>): void;
+}, _NotCustomized, _NotCustomized>;
+
 declare const Hole: IModelType<    {
 id: IOptionalIType<ISimpleType<string>, [undefined]>;
 type: IOptionalIType<ISimpleType<"hole">, [undefined]>;
@@ -892,6 +971,11 @@ removePoint(id: string): void;
 movePoint(id: string, { r, t }: SICanvasPoint): void;
 }, _NotCustomized, _NotCustomized>;
 
+declare interface HoveredDataElement {
+    layer: RenderableDataLayer<DataLayer<UnknownData>>;
+    element: UnknownData;
+}
+
 declare interface IAnnotation extends Instance<typeof Annotation> {
 }
 
@@ -923,6 +1007,10 @@ export declare interface IconDataLayer<D extends UnknownData = NoData> extends B
     disableElevationCorrection?: boolean;
 }
 
+declare type IconInstance<D extends UnknownData = NoData> = IconDataLayer<D>['data'][number] & {
+    __instanceIndex: number;
+};
+
 declare interface IconLegend extends Pick<IconsSwatchesProps, 'icons'> {
     type: 'icons';
 }
@@ -937,6 +1025,28 @@ declare interface IconsSwatchesProps {
     noLabels?: boolean;
 }
 
+declare const IconViewerDataLayer: IModelType<    {
+definition: IType<IconDataLayer<UnknownData>, IconDataLayer<UnknownData>, IconDataLayer<UnknownData>>;
+compiledTooltipTemplate: IMaybe<IType<    {
+fn: (dataElement: UnknownData) => string;
+}, {
+fn: (dataElement: UnknownData) => string;
+}, {
+fn: (dataElement: UnknownData) => string;
+}>>;
+touchCount: IOptionalIType<ISimpleType<number>, [undefined]>;
+} & {
+type: ISimpleType<LayerType.Icon>;
+}, {
+readonly renderableDefinition: RenderableDataLayer<IconDataLayer<UnknownData>>;
+readonly renderState: ViewerDataLayerRenderState<IconDataLayer<UnknownData>>;
+readonly persistentTooltipSources: PersistentTooltipSource[];
+} & {
+setCompiledTooltipTemplate(compiledTemplate: (dataElement: UnknownData) => string): void;
+touch(): void;
+updateDefinition(updates: Partial<Omit<IconDataLayer<UnknownData>, "type">>): void;
+}, _NotCustomized, _NotCustomized>;
+
 declare interface IGround extends Instance<typeof Ground> {
 }
 
@@ -947,6 +1057,33 @@ export declare type ImageSource = {
     blobIdOrHash: string;
 };
 
+declare interface Instance_2 extends SOObject {
+    __instanceIndex: number;
+    bufferIndex: number;
+    matrix: Matrix;
+}
+
+declare interface InternalSpaceRenderOptions {
+    compass?: boolean;
+    backgroundColor?: string;
+    filter: DeepPartial<Filter>;
+    walls: WallsRenderState;
+    grounds: ElementRenderState;
+    openings: ElementRenderState;
+    doors: ElementRenderState;
+    windows: ElementRenderState;
+    stairs: ElementRenderState;
+    flip: boolean;
+    objects: ElementRenderState;
+    annotations: ElementRenderState;
+    facade: boolean;
+    floorplan: {
+        render: boolean;
+        alpha: number;
+        elevationInCm: number;
+    };
+}
+
 declare interface IObject extends Instance<typeof Object_2> {
 }
 
@@ -958,6 +1095,9 @@ declare function isSpaceSid(s: string): s is SpaceSid;
 declare interface IStair extends Instance<typeof Stair> {
 }
 
+declare interface IViewerStore extends Instance<typeof ViewerStore> {
+}
+
 declare interface IWall extends Instance<typeof Wall> {
 }
 
@@ -1041,7 +1181,6 @@ declare interface JsonRoof {
 
 declare interface JsonSpace {
     levels: JsonLevel[];
-    camerasEnabled: SmplrCameraType[];
     compassDirection?: number;
     facade?: SOFacade;
     defaults: SOSpaceDefaults;
@@ -1132,6 +1271,14 @@ declare enum LayerType {
     Heatmap = "heatmap"
 }
 
+declare interface LegacySpaceRenderOptions extends Omit<SpaceRenderOptions, 'objects' | 'annotations' | 'doors' | 'windows' | 'openings'> {
+    objects?: boolean | SpaceRenderOptions['objects'];
+    annotations?: boolean | SpaceRenderOptions['annotations'];
+    doors?: boolean | SpaceRenderOptions['doors'];
+    windows?: boolean | SpaceRenderOptions['windows'];
+    openings?: boolean | SpaceRenderOptions['openings'];
+}
+
 declare type LegendConfig = NumericLegend | ColorSwatches | IconLegend;
 
 export declare type LegendPosition = 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right'
@@ -1893,6 +2040,35 @@ declare interface Material {
     layerOffset?: number;
 }
 
+declare interface MeshSmplrData {
+    type: string;
+    isInstanciated?: boolean;
+    instances?: Instance_2[] | null;
+    modelDimensions?: Dimensions;
+    baseHeightForLevel?: number[];
+    isInstanceVisible?: (instance: Instance_2) => boolean;
+    isInstanceSelected?: (instance: Instance_2) => boolean;
+    scalingFn?: (instance: Instance_2) => number | Vector3;
+    colorFn?: ((instance: Instance_2) => string | null | undefined) | null;
+    animationStartedAt?: number;
+    onDropCompute?: string[];
+    layer?: RenderableDataLayer<DataLayer<UnknownData>>;
+    partOfFacade?: boolean;
+    annotation?: SOAnnotation;
+    instance?: PolylineInstance<UnknownData> | IconInstance<UnknownData> | PolygonInstance<UnknownData>;
+    modelType?: 'gltf' | 'parametric';
+    mode?: CameraMode;
+    subtype?: 'fill' | 'stroke';
+    parametricModule?: ParametricObject;
+    parametricConfiguration?: Partial<ParametricObjectConfiguration>;
+    levelZOffsetUnits?: number;
+    pointDraggerIndex?: number;
+    normalStairsYPosition?: number;
+    levelIndex?: number;
+    initialColor?: Color4;
+    panelIndex?: number;
+}
+
 export declare type NoData = Record<string, never>;
 
 declare type NominalDimensionsGetter<C> = (args: {
@@ -2116,6 +2292,14 @@ declare interface OrbitCamera extends ArcRotateCamera {
     setMode: (mode: CameraMode) => void;
 }
 
+declare interface OrbitCameraParameters {
+    cameraDistanceForOverview: number;
+    upperRadiusLimit: number;
+    panningDistanceLimit: number;
+    maxDistanceFromGroundCenter: number;
+    maxZ: number;
+}
+
 export declare interface OrbitCameraPlacement {
     alpha: number;
     beta: number;
@@ -2134,10 +2318,17 @@ export declare interface OrbitCameraPlacementUpdate {
     };
 }
 
+declare interface OrbitCameraSample {
+    fov: number;
+    panningOriginTargetY: number;
+}
+
 declare interface OrientatedGeoPoint extends GeoPoint {
     heading: number;
 }
 
+declare type ParametricObject = typeof chair | typeof sofa | typeof cube | typeof desk | typeof screen_2 | typeof shelves | typeof table | typeof tableAndChairs | typeof triangularDesk;
+
 declare type ParametricObject2dRenderer<C> = (args: {
     scene: SmplrScene;
     width: number;
@@ -2181,6 +2372,13 @@ export declare interface PartialOrbitCameraPlacement {
     target?: Partial<Vector3Coord>;
 }
 
+declare interface PersistentTooltipSource {
+    layerId: string;
+    elementId: string | number;
+    html: string;
+    styleOverrides?: string;
+}
+
 export declare type PointData = BaseData & {
     position: SmplrCoord3d;
 };
@@ -2206,6 +2404,28 @@ export declare type PointMapDataLayerDefinition<D extends UnknownSpaceData = Spa
 
 declare type PointShapeOptions<D> = SphereOptions<D> | CubeOptions<D>;
 
+declare const PointViewerDataLayer: IModelType<    {
+definition: IType<PointDataLayer<UnknownData>, PointDataLayer<UnknownData>, PointDataLayer<UnknownData>>;
+compiledTooltipTemplate: IMaybe<IType<    {
+fn: (dataElement: UnknownData) => string;
+}, {
+fn: (dataElement: UnknownData) => string;
+}, {
+fn: (dataElement: UnknownData) => string;
+}>>;
+touchCount: IOptionalIType<ISimpleType<number>, [undefined]>;
+} & {
+type: ISimpleType<LayerType.Point>;
+}, {
+readonly renderableDefinition: RenderableDataLayer<PointDataLayer<UnknownData>>;
+readonly renderState: ViewerDataLayerRenderState<PointDataLayer<UnknownData>>;
+readonly persistentTooltipSources: PersistentTooltipSource[];
+} & {
+setCompiledTooltipTemplate(compiledTemplate: (dataElement: UnknownData) => string): void;
+touch(): void;
+updateDefinition(updates: Partial<Omit<PointDataLayer<UnknownData>, "type">>): void;
+}, _NotCustomized, _NotCustomized>;
+
 export declare type PolygonData = BaseData & {
     coordinates: SmplrCoord2d[] | SmplrCoord2d[][];
 };
@@ -2230,8 +2450,34 @@ export declare interface PolygonDataLayer<D extends UnknownData = NoData> extend
     disableElevationCorrection?: boolean;
 }
 
+declare type PolygonInstance<D extends UnknownData = NoData> = PolygonDataLayer<D>['data'][number] & {
+    __instanceIndex: number;
+};
+
 export declare type PolygonMapDataLayerDefinition<D extends UnknownSpaceData = SpaceNoData> = Omit<PolygonDataLayer<D>, 'type' | 'alpha' | 'onDrag' | 'onDrop' | 'disableReshape' | 'reshapeBoxColor' | 'disableElevationCorrection' | 'onClick' | 'onHover' | 'onHoverOut'> & MapDataLayerSharedDefinition<PolygonData, D>;
 
+declare const PolygonViewerDataLayer: IModelType<    {
+definition: IType<PolygonDataLayer<UnknownData>, PolygonDataLayer<UnknownData>, PolygonDataLayer<UnknownData>>;
+compiledTooltipTemplate: IMaybe<IType<    {
+fn: (dataElement: UnknownData) => string;
+}, {
+fn: (dataElement: UnknownData) => string;
+}, {
+fn: (dataElement: UnknownData) => string;
+}>>;
+touchCount: IOptionalIType<ISimpleType<number>, [undefined]>;
+} & {
+type: ISimpleType<LayerType.Polygon>;
+}, {
+readonly renderableDefinition: RenderableDataLayer<PolygonDataLayer<UnknownData>>;
+readonly renderState: ViewerDataLayerRenderState<PolygonDataLayer<UnknownData>>;
+readonly persistentTooltipSources: PersistentTooltipSource[];
+} & {
+setCompiledTooltipTemplate(compiledTemplate: (dataElement: UnknownData) => string): void;
+touch(): void;
+updateDefinition(updates: Partial<Omit<PolygonDataLayer<UnknownData>, "type">>): void;
+}, _NotCustomized, _NotCustomized>;
+
 export declare type PolylineData = BaseData & {
     coordinates: SmplrCoord3d[];
 };
@@ -2273,6 +2519,40 @@ declare type PolylineDataLayerScale<D extends UnknownData = NoData> = PolylineDa
     stepSize?: number;
 };
 
+declare type PolylineInstance<D extends UnknownData = NoData> = PolylineDataLayer<D>['data'][number] & {
+    __instanceIndex: number;
+};
+
+declare const PolylineViewerDataLayer: IModelType<    {
+definition: IType<PolylineDataLayer<UnknownData>, PolylineDataLayer<UnknownData>, PolylineDataLayer<UnknownData>>;
+compiledTooltipTemplate: IMaybe<IType<    {
+fn: (dataElement: UnknownData) => string;
+}, {
+fn: (dataElement: UnknownData) => string;
+}, {
+fn: (dataElement: UnknownData) => string;
+}>>;
+touchCount: IOptionalIType<ISimpleType<number>, [undefined]>;
+} & {
+type: ISimpleType<LayerType.Polyline>;
+}, {
+readonly renderableDefinition: RenderableDataLayer<PolylineDataLayer<UnknownData>>;
+readonly renderState: ViewerDataLayerRenderState<PolylineDataLayer<UnknownData>>;
+readonly persistentTooltipSources: PersistentTooltipSource[];
+} & {
+setCompiledTooltipTemplate(compiledTemplate: (dataElement: UnknownData) => string): void;
+touch(): void;
+updateDefinition(updates: Partial<Omit<PolylineDataLayer<UnknownData>, "type">>): void;
+}, _NotCustomized, _NotCustomized>;
+
+declare interface PositionedPersistentTooltip {
+    key: string;
+    html: string;
+    styleOverrides?: string;
+    top: number;
+    left: number;
+}
+
 export declare type PosterData = PosterDataByPosition | PosterDataByCoordinate;
 
 declare type PosterDataByCoordinate = BaseData & {
@@ -2313,6 +2593,28 @@ export declare interface PosterDataLayer<D extends UnknownData = NoData> extends
     };
 }
 
+declare const PosterViewerDataLayer: IModelType<    {
+definition: IType<PosterDataLayer<UnknownData>, PosterDataLayer<UnknownData>, PosterDataLayer<UnknownData>>;
+compiledTooltipTemplate: IMaybe<IType<    {
+fn: (dataElement: UnknownData) => string;
+}, {
+fn: (dataElement: UnknownData) => string;
+}, {
+fn: (dataElement: UnknownData) => string;
+}>>;
+touchCount: IOptionalIType<ISimpleType<number>, [undefined]>;
+} & {
+type: ISimpleType<LayerType.Poster>;
+}, {
+readonly renderableDefinition: RenderableDataLayer<PosterDataLayer<UnknownData>>;
+readonly renderState: ViewerDataLayerRenderState<PosterDataLayer<UnknownData>>;
+readonly persistentTooltipSources: PersistentTooltipSource[];
+} & {
+setCompiledTooltipTemplate(compiledTemplate: (dataElement: UnknownData) => string): void;
+touch(): void;
+updateDefinition(updates: Partial<Omit<PosterDataLayer<UnknownData>, "type">>): void;
+}, _NotCustomized, _NotCustomized>;
+
 export declare class QueryClient {
     private options;
     private client;
@@ -2659,6 +2961,18 @@ declare const render3d_8: ParametricObject3dRenderer<TableAndChairsConfiguration
 
 declare const render3d_9: ParametricObject3dRenderer<TriangularDeskConfiguration>;
 
+declare interface RenderableDataLayer<LayerDefinition> {
+    definition: LayerDefinition;
+    compiledTooltipTemplate?: (dataElement: UnknownData) => string;
+}
+
+declare enum RenderPhase {
+    Space = "space",
+    Floorplans = "floorplans",
+    Objects = "objects",
+    ObjectPlaceholders = "object-placeholders"
+}
+
 declare const Roof: IModelType<    {
 id: IOptionalIType<ISimpleType<string>, [undefined]>;
 type: IOptionalIType<ISimpleType<"roof">, [undefined]>;
@@ -2845,15 +3159,27 @@ declare interface SIAnnotation extends SnapshotIn<typeof Annotation> {
 declare interface SICanvasPoint extends SnapshotIn<typeof CanvasPoint> {
 }
 
+declare interface SIDottedPolylineViewerDataLayer extends SnapshotIn<typeof DottedPolylineViewerDataLayer> {
+}
+
+declare interface SIFurnitureViewerDataLayer extends SnapshotIn<typeof FurnitureViewerDataLayer> {
+}
+
 declare interface SIGround extends SnapshotIn<typeof Ground> {
 }
 
 declare interface SIGroundSegment extends SnapshotIn<typeof GroundSegment> {
 }
 
+declare interface SIHeatmapViewerDataLayer extends SnapshotIn<typeof HeatmapViewerDataLayer> {
+}
+
 declare interface SIHole extends SnapshotIn<typeof Hole> {
 }
 
+declare interface SIIconViewerDataLayer extends SnapshotIn<typeof IconViewerDataLayer> {
+}
+
 declare interface SILevel extends Instance<typeof Level> {
 }
 
@@ -2869,9 +3195,23 @@ declare interface SIObjectDimensions extends SnapshotIn<typeof ObjectDimensions>
 declare interface SIObjectRotation extends SnapshotIn<typeof ObjectRotation> {
 }
 
+declare interface SIPointViewerDataLayer extends SnapshotIn<typeof PointViewerDataLayer> {
+}
+
+declare interface SIPolygonViewerDataLayer extends SnapshotIn<typeof PolygonViewerDataLayer> {
+}
+
+declare interface SIPolylineViewerDataLayer extends SnapshotIn<typeof PolylineViewerDataLayer> {
+}
+
+declare interface SIPosterViewerDataLayer extends SnapshotIn<typeof PosterViewerDataLayer> {
+}
+
 declare interface SIStair extends SnapshotIn<typeof Stair> {
 }
 
+declare type SIViewerDataLayer = SIPointViewerDataLayer | SIIconViewerDataLayer | SIPosterViewerDataLayer | SIPolylineViewerDataLayer | SIDottedPolylineViewerDataLayer | SIPolygonViewerDataLayer | SIFurnitureViewerDataLayer | SIHeatmapViewerDataLayer;
+
 declare interface SIWall extends SnapshotIn<typeof Wall> {
 }
 
@@ -2884,14 +3224,7 @@ declare interface SIWallOpeningDimensions extends SnapshotIn<typeof WallOpeningD
 declare interface SIWallOpeningPosition extends SnapshotIn<typeof WallOpeningPosition> {
 }
 
-declare type SmplrCamera = OrbitCamera | UniversalCamera | VrCamera;
-
-declare enum SmplrCameraType {
-    Orbit = "orbit",
-    Walkin = "walkin",
-    Game = "game",
-    Vr = "vr"
-}
+declare type SmplrCamera = OrbitCamera;
 
 export declare interface SmplrCoord2d {
     levelIndex: number;
@@ -2903,6 +3236,11 @@ export declare interface SmplrCoord3d extends SmplrCoord2d {
     elevation: number;
 }
 
+declare interface SmplrMesh extends Mesh {
+    smplrData: MeshSmplrData;
+    startAnimation?: () => void;
+}
+
 declare interface SmplrRenderLoop {
     enabled: boolean;
     pendingChanges: Record<number, string>;
@@ -2916,15 +3254,19 @@ declare interface SmplrRenderLoop {
 declare interface SmplrScene extends Scene {
     _smplr_renderLoop: SmplrRenderLoop;
     _smplr_interactive?: boolean;
-    _smplr_baseHeightForLevel?: number[];
     cameras: SmplrCamera[];
 }
 
+declare type SmplrShadowGenerator = ShadowGenerator | CascadedShadowGenerator;
+
 declare const smplrToCssColor: (c: string) => string;
 
 declare interface SOAbstractSegment extends SnapshotOut<typeof AbstractSegment> {
 }
 
+declare interface SOAnnotation extends SnapshotOut<typeof Annotation> {
+}
+
 declare interface SOCanvasPoint extends SnapshotOut<typeof CanvasPoint> {
 }
 
@@ -2952,6 +3294,12 @@ declare interface SOFloorplan extends SnapshotOut<typeof Floorplan> {
 declare interface SOGroundSegment extends SnapshotOut<typeof GroundSegment> {
 }
 
+declare interface SOLevel extends SnapshotOut<typeof Level> {
+}
+
+declare interface SOObject extends SnapshotOut<typeof Object_2> {
+}
+
 declare interface SORoofOptions extends SnapshotOut<typeof RoofOptions> {
 }
 
@@ -2976,7 +3324,7 @@ export declare class Space {
     private scene;
     private container;
     private setPickHandler;
-    private dispatchDataLayersDefinition;
+    private store;
     private dataLayerControllers;
     private viewerRef;
     constructor(options: SpaceOptions);
@@ -3616,7 +3964,6 @@ layers: string[];
 }): void;
 clear(): void;
 }, _NotCustomized, _NotCustomized>>, [undefined]>;
-camerasEnabled: IOptionalIType<IArrayType<ISimpleType<SmplrCameraType>>, [undefined]>;
 compassDirection: IMaybe<ISimpleType<number>>;
 facade: IMaybe<IModelType<    {
 url: ISimpleType<string>;
@@ -4096,7 +4443,18 @@ declare interface Vector3Coord extends Vector2Coord {
     z: number;
 }
 
-export declare const version = "2.57.2-beta.0";
+export declare const version = "2.57.2-beta.10";
+
+declare interface ViewerDataLayerRenderState<Definition = DataLayer<UnknownData>> {
+    definition: Definition;
+    touchCount: number;
+    compiledTooltipTemplate?: (dataElement: UnknownData) => string;
+}
+
+declare interface ViewerLights {
+    directionalLight: DirectionalLight;
+    hemisphericLight: HemisphericLight;
+}
 
 declare interface ViewerRendererHandle {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -4117,17 +4475,549 @@ declare interface ViewerRendererHandle {
     setHideNavigationButtons: (value: boolean) => void
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     getFurnitureElementInstance: (furnitureId: string | string[]) => any
+    // per-level base heights, consumed by DataLayerController's screen projection
+    getBaseHeightForLevel: () => number[]
     addEventListener: EventEmitter['addListener']
     removeEventListener: EventEmitter['removeListener']
     clearEventListeners: EventEmitter['clearUserDefinedListeners']
     clearAllEventListeners: EventEmitter['clearAllUserDefinedListeners']
 }
 
-declare interface VrCamera extends VRDeviceOrientationFreeCamera {
-    smplrData: {
-        persisted: boolean;
-    };
-    noSleep: NoSleep_2;
+declare const ViewerStore: IModelType<    {
+initialRenderOptionsInput: IType<LegacySpaceRenderOptions, LegacySpaceRenderOptions, LegacySpaceRenderOptions>;
+renderOptions: IOptionalIType<IType<InternalSpaceRenderOptions, InternalSpaceRenderOptions, InternalSpaceRenderOptions>, [undefined]>;
+filterHash: IMaybe<ISimpleType<string>>;
+spaceHash: IMaybe<ISimpleType<string>>;
+objectsHash: IMaybe<ISimpleType<string>>;
+levels: IType<SOLevel[], SOLevel[], SOLevel[]>;
+defaults: IType<SOSpaceDefaults, SOSpaceDefaults, SOSpaceDefaults>;
+includeLevels: IType<number[], number[], number[]>;
+visibleLevels: IOptionalIType<IType<number[], number[], number[]>, [undefined]>;
+initialTopShownLevel: IMaybe<ISimpleType<number>>;
+mode: IOptionalIType<ISimpleType<CameraMode>, [undefined]>;
+initialCameraPlacement: IMaybe<IType<PartialOrbitCameraPlacement, PartialOrbitCameraPlacement, PartialOrbitCameraPlacement>>;
+moreOptionsVisible: IOptionalIType<ISimpleType<boolean>, [undefined]>;
+levelsDropdownOpen: IOptionalIType<ISimpleType<boolean>, [undefined]>;
+goToLevel: IOptionalIType<ISimpleType<string>, [undefined]>;
+hideLevelPicker: IOptionalIType<ISimpleType<boolean>, [undefined]>;
+hideNavigationButtons: IOptionalIType<ISimpleType<boolean>, [undefined]>;
+showStructuralWalls: IOptionalIType<ISimpleType<boolean>, [undefined]>;
+showAnnotations: IOptionalIType<ISimpleType<boolean>, [undefined]>;
+showCompass: IOptionalIType<ISimpleType<boolean>, [undefined]>;
+showFacade: IOptionalIType<ISimpleType<boolean>, [undefined]>;
+persistentTooltipsVisible: IOptionalIType<ISimpleType<boolean>, [undefined]>;
+dataLayers: IMapType<ITypeUnion<ModelCreationType<ExtractCFromProps<    {
+definition: IType<PointDataLayer<UnknownData>, PointDataLayer<UnknownData>, PointDataLayer<UnknownData>>;
+compiledTooltipTemplate: IMaybe<IType<    {
+fn: (dataElement: UnknownData) => string;
+}, {
+fn: (dataElement: UnknownData) => string;
+}, {
+fn: (dataElement: UnknownData) => string;
+}>>;
+touchCount: IOptionalIType<ISimpleType<number>, [undefined]>;
+} & {
+type: ISimpleType<import("src/viewer/data-layers/dataLayerTypes").LayerType.Point>;
+}>> | ModelCreationType<ExtractCFromProps<    {
+definition: IType<IconDataLayer<UnknownData>, IconDataLayer<UnknownData>, IconDataLayer<UnknownData>>;
+compiledTooltipTemplate: IMaybe<IType<    {
+fn: (dataElement: UnknownData) => string;
+}, {
+fn: (dataElement: UnknownData) => string;
+}, {
+fn: (dataElement: UnknownData) => string;
+}>>;
+touchCount: IOptionalIType<ISimpleType<number>, [undefined]>;
+} & {
+type: ISimpleType<import("src/viewer/data-layers/dataLayerTypes").LayerType.Icon>;
+}>> | ModelCreationType<ExtractCFromProps<    {
+definition: IType<PosterDataLayer<UnknownData>, PosterDataLayer<UnknownData>, PosterDataLayer<UnknownData>>;
+compiledTooltipTemplate: IMaybe<IType<    {
+fn: (dataElement: UnknownData) => string;
+}, {
+fn: (dataElement: UnknownData) => string;
+}, {
+fn: (dataElement: UnknownData) => string;
+}>>;
+touchCount: IOptionalIType<ISimpleType<number>, [undefined]>;
+} & {
+type: ISimpleType<import("src/viewer/data-layers/dataLayerTypes").LayerType.Poster>;
+}>> | ModelCreationType<ExtractCFromProps<    {
+definition: IType<PolylineDataLayer<UnknownData>, PolylineDataLayer<UnknownData>, PolylineDataLayer<UnknownData>>;
+compiledTooltipTemplate: IMaybe<IType<    {
+fn: (dataElement: UnknownData) => string;
+}, {
+fn: (dataElement: UnknownData) => string;
+}, {
+fn: (dataElement: UnknownData) => string;
+}>>;
+touchCount: IOptionalIType<ISimpleType<number>, [undefined]>;
+} & {
+type: ISimpleType<import("src/viewer/data-layers/dataLayerTypes").LayerType.Polyline>;
+}>> | ModelCreationType<ExtractCFromProps<    {
+definition: IType<DottedPolylineDataLayer<UnknownData>, DottedPolylineDataLayer<UnknownData>, DottedPolylineDataLayer<UnknownData>>;
+compiledTooltipTemplate: IMaybe<IType<    {
+fn: (dataElement: UnknownData) => string;
+}, {
+fn: (dataElement: UnknownData) => string;
+}, {
+fn: (dataElement: UnknownData) => string;
+}>>;
+touchCount: IOptionalIType<ISimpleType<number>, [undefined]>;
+} & {
+type: ISimpleType<import("src/viewer/data-layers/dataLayerTypes").LayerType.DottedPolyline>;
+}>> | ModelCreationType<ExtractCFromProps<    {
+definition: IType<PolygonDataLayer<UnknownData>, PolygonDataLayer<UnknownData>, PolygonDataLayer<UnknownData>>;
+compiledTooltipTemplate: IMaybe<IType<    {
+fn: (dataElement: UnknownData) => string;
+}, {
+fn: (dataElement: UnknownData) => string;
+}, {
+fn: (dataElement: UnknownData) => string;
+}>>;
+touchCount: IOptionalIType<ISimpleType<number>, [undefined]>;
+} & {
+type: ISimpleType<import("src/viewer/data-layers/dataLayerTypes").LayerType.Polygon>;
+}>> | ModelCreationType<ExtractCFromProps<    {
+definition: IType<FurnitureDataLayer<UnknownData>, FurnitureDataLayer<UnknownData>, FurnitureDataLayer<UnknownData>>;
+compiledTooltipTemplate: IMaybe<IType<    {
+fn: (dataElement: UnknownData) => string;
+}, {
+fn: (dataElement: UnknownData) => string;
+}, {
+fn: (dataElement: UnknownData) => string;
+}>>;
+touchCount: IOptionalIType<ISimpleType<number>, [undefined]>;
+} & {
+type: ISimpleType<import("src/viewer/data-layers/dataLayerTypes").LayerType.Furniture>;
+}>> | ModelCreationType<ExtractCFromProps<    {
+definition: IType<HeatmapDataLayer<UnknownData>, HeatmapDataLayer<UnknownData>, HeatmapDataLayer<UnknownData>>;
+compiledTooltipTemplate: IMaybe<IType<    {
+fn: (dataElement: UnknownData) => string;
+}, {
+fn: (dataElement: UnknownData) => string;
+}, {
+fn: (dataElement: UnknownData) => string;
+}>>;
+touchCount: IOptionalIType<ISimpleType<number>, [undefined]>;
+} & {
+type: ISimpleType<import("src/viewer/data-layers/dataLayerTypes").LayerType.Heatmap>;
+}>>, ModelSnapshotType<    {
+definition: IType<PointDataLayer<UnknownData>, PointDataLayer<UnknownData>, PointDataLayer<UnknownData>>;
+compiledTooltipTemplate: IMaybe<IType<    {
+fn: (dataElement: UnknownData) => string;
+}, {
+fn: (dataElement: UnknownData) => string;
+}, {
+fn: (dataElement: UnknownData) => string;
+}>>;
+touchCount: IOptionalIType<ISimpleType<number>, [undefined]>;
+} & {
+type: ISimpleType<import("src/viewer/data-layers/dataLayerTypes").LayerType.Point>;
+}> | ModelSnapshotType<    {
+definition: IType<IconDataLayer<UnknownData>, IconDataLayer<UnknownData>, IconDataLayer<UnknownData>>;
+compiledTooltipTemplate: IMaybe<IType<    {
+fn: (dataElement: UnknownData) => string;
+}, {
+fn: (dataElement: UnknownData) => string;
+}, {
+fn: (dataElement: UnknownData) => string;
+}>>;
+touchCount: IOptionalIType<ISimpleType<number>, [undefined]>;
+} & {
+type: ISimpleType<import("src/viewer/data-layers/dataLayerTypes").LayerType.Icon>;
+}> | ModelSnapshotType<    {
+definition: IType<PosterDataLayer<UnknownData>, PosterDataLayer<UnknownData>, PosterDataLayer<UnknownData>>;
+compiledTooltipTemplate: IMaybe<IType<    {
+fn: (dataElement: UnknownData) => string;
+}, {
+fn: (dataElement: UnknownData) => string;
+}, {
+fn: (dataElement: UnknownData) => string;
+}>>;
+touchCount: IOptionalIType<ISimpleType<number>, [undefined]>;
+} & {
+type: ISimpleType<import("src/viewer/data-layers/dataLayerTypes").LayerType.Poster>;
+}> | ModelSnapshotType<    {
+definition: IType<PolylineDataLayer<UnknownData>, PolylineDataLayer<UnknownData>, PolylineDataLayer<UnknownData>>;
+compiledTooltipTemplate: IMaybe<IType<    {
+fn: (dataElement: UnknownData) => string;
+}, {
+fn: (dataElement: UnknownData) => string;
+}, {
+fn: (dataElement: UnknownData) => string;
+}>>;
+touchCount: IOptionalIType<ISimpleType<number>, [undefined]>;
+} & {
+type: ISimpleType<import("src/viewer/data-layers/dataLayerTypes").LayerType.Polyline>;
+}> | ModelSnapshotType<    {
+definition: IType<DottedPolylineDataLayer<UnknownData>, DottedPolylineDataLayer<UnknownData>, DottedPolylineDataLayer<UnknownData>>;
+compiledTooltipTemplate: IMaybe<IType<    {
+fn: (dataElement: UnknownData) => string;
+}, {
+fn: (dataElement: UnknownData) => string;
+}, {
+fn: (dataElement: UnknownData) => string;
+}>>;
+touchCount: IOptionalIType<ISimpleType<number>, [undefined]>;
+} & {
+type: ISimpleType<import("src/viewer/data-layers/dataLayerTypes").LayerType.DottedPolyline>;
+}> | ModelSnapshotType<    {
+definition: IType<PolygonDataLayer<UnknownData>, PolygonDataLayer<UnknownData>, PolygonDataLayer<UnknownData>>;
+compiledTooltipTemplate: IMaybe<IType<    {
+fn: (dataElement: UnknownData) => string;
+}, {
+fn: (dataElement: UnknownData) => string;
+}, {
+fn: (dataElement: UnknownData) => string;
+}>>;
+touchCount: IOptionalIType<ISimpleType<number>, [undefined]>;
+} & {
+type: ISimpleType<import("src/viewer/data-layers/dataLayerTypes").LayerType.Polygon>;
+}> | ModelSnapshotType<    {
+definition: IType<FurnitureDataLayer<UnknownData>, FurnitureDataLayer<UnknownData>, FurnitureDataLayer<UnknownData>>;
+compiledTooltipTemplate: IMaybe<IType<    {
+fn: (dataElement: UnknownData) => string;
+}, {
+fn: (dataElement: UnknownData) => string;
+}, {
+fn: (dataElement: UnknownData) => string;
+}>>;
+touchCount: IOptionalIType<ISimpleType<number>, [undefined]>;
+} & {
+type: ISimpleType<import("src/viewer/data-layers/dataLayerTypes").LayerType.Furniture>;
+}> | ModelSnapshotType<    {
+definition: IType<HeatmapDataLayer<UnknownData>, HeatmapDataLayer<UnknownData>, HeatmapDataLayer<UnknownData>>;
+compiledTooltipTemplate: IMaybe<IType<    {
+fn: (dataElement: UnknownData) => string;
+}, {
+fn: (dataElement: UnknownData) => string;
+}, {
+fn: (dataElement: UnknownData) => string;
+}>>;
+touchCount: IOptionalIType<ISimpleType<number>, [undefined]>;
+} & {
+type: ISimpleType<import("src/viewer/data-layers/dataLayerTypes").LayerType.Heatmap>;
+}>, ModelInstanceType<    {
+definition: IType<PointDataLayer<UnknownData>, PointDataLayer<UnknownData>, PointDataLayer<UnknownData>>;
+compiledTooltipTemplate: IMaybe<IType<    {
+fn: (dataElement: UnknownData) => string;
+}, {
+fn: (dataElement: UnknownData) => string;
+}, {
+fn: (dataElement: UnknownData) => string;
+}>>;
+touchCount: IOptionalIType<ISimpleType<number>, [undefined]>;
+} & {
+type: ISimpleType<import("src/viewer/data-layers/dataLayerTypes").LayerType.Point>;
+}, {
+readonly renderableDefinition: RenderableDataLayer<PointDataLayer<UnknownData>>;
+readonly renderState: ViewerDataLayerRenderState<PointDataLayer<UnknownData>>;
+readonly persistentTooltipSources: PersistentTooltipSource[];
+} & {
+setCompiledTooltipTemplate(compiledTemplate: (dataElement: UnknownData) => string): void;
+touch(): void;
+updateDefinition(updates: Partial<Omit<PointDataLayer<UnknownData>, "type">>): void;
+}> | ModelInstanceType<    {
+definition: IType<IconDataLayer<UnknownData>, IconDataLayer<UnknownData>, IconDataLayer<UnknownData>>;
+compiledTooltipTemplate: IMaybe<IType<    {
+fn: (dataElement: UnknownData) => string;
+}, {
+fn: (dataElement: UnknownData) => string;
+}, {
+fn: (dataElement: UnknownData) => string;
+}>>;
+touchCount: IOptionalIType<ISimpleType<number>, [undefined]>;
+} & {
+type: ISimpleType<import("src/viewer/data-layers/dataLayerTypes").LayerType.Icon>;
+}, {
+readonly renderableDefinition: RenderableDataLayer<IconDataLayer<UnknownData>>;
+readonly renderState: ViewerDataLayerRenderState<IconDataLayer<UnknownData>>;
+readonly persistentTooltipSources: PersistentTooltipSource[];
+} & {
+setCompiledTooltipTemplate(compiledTemplate: (dataElement: UnknownData) => string): void;
+touch(): void;
+updateDefinition(updates: Partial<Omit<IconDataLayer<UnknownData>, "type">>): void;
+}> | ModelInstanceType<    {
+definition: IType<PosterDataLayer<UnknownData>, PosterDataLayer<UnknownData>, PosterDataLayer<UnknownData>>;
+compiledTooltipTemplate: IMaybe<IType<    {
+fn: (dataElement: UnknownData) => string;
+}, {
+fn: (dataElement: UnknownData) => string;
+}, {
+fn: (dataElement: UnknownData) => string;
+}>>;
+touchCount: IOptionalIType<ISimpleType<number>, [undefined]>;
+} & {
+type: ISimpleType<import("src/viewer/data-layers/dataLayerTypes").LayerType.Poster>;
+}, {
+readonly renderableDefinition: RenderableDataLayer<PosterDataLayer<UnknownData>>;
+readonly renderState: ViewerDataLayerRenderState<PosterDataLayer<UnknownData>>;
+readonly persistentTooltipSources: PersistentTooltipSource[];
+} & {
+setCompiledTooltipTemplate(compiledTemplate: (dataElement: UnknownData) => string): void;
+touch(): void;
+updateDefinition(updates: Partial<Omit<PosterDataLayer<UnknownData>, "type">>): void;
+}> | ModelInstanceType<    {
+definition: IType<PolylineDataLayer<UnknownData>, PolylineDataLayer<UnknownData>, PolylineDataLayer<UnknownData>>;
+compiledTooltipTemplate: IMaybe<IType<    {
+fn: (dataElement: UnknownData) => string;
+}, {
+fn: (dataElement: UnknownData) => string;
+}, {
+fn: (dataElement: UnknownData) => string;
+}>>;
+touchCount: IOptionalIType<ISimpleType<number>, [undefined]>;
+} & {
+type: ISimpleType<import("src/viewer/data-layers/dataLayerTypes").LayerType.Polyline>;
+}, {
+readonly renderableDefinition: RenderableDataLayer<PolylineDataLayer<UnknownData>>;
+readonly renderState: ViewerDataLayerRenderState<PolylineDataLayer<UnknownData>>;
+readonly persistentTooltipSources: PersistentTooltipSource[];
+} & {
+setCompiledTooltipTemplate(compiledTemplate: (dataElement: UnknownData) => string): void;
+touch(): void;
+updateDefinition(updates: Partial<Omit<PolylineDataLayer<UnknownData>, "type">>): void;
+}> | ModelInstanceType<    {
+definition: IType<DottedPolylineDataLayer<UnknownData>, DottedPolylineDataLayer<UnknownData>, DottedPolylineDataLayer<UnknownData>>;
+compiledTooltipTemplate: IMaybe<IType<    {
+fn: (dataElement: UnknownData) => string;
+}, {
+fn: (dataElement: UnknownData) => string;
+}, {
+fn: (dataElement: UnknownData) => string;
+}>>;
+touchCount: IOptionalIType<ISimpleType<number>, [undefined]>;
+} & {
+type: ISimpleType<import("src/viewer/data-layers/dataLayerTypes").LayerType.DottedPolyline>;
+}, {
+readonly renderableDefinition: RenderableDataLayer<DottedPolylineDataLayer<UnknownData>>;
+readonly renderState: ViewerDataLayerRenderState<DottedPolylineDataLayer<UnknownData>>;
+readonly persistentTooltipSources: PersistentTooltipSource[];
+} & {
+setCompiledTooltipTemplate(compiledTemplate: (dataElement: UnknownData) => string): void;
+touch(): void;
+updateDefinition(updates: Partial<Omit<DottedPolylineDataLayer<UnknownData>, "type">>): void;
+}> | ModelInstanceType<    {
+definition: IType<PolygonDataLayer<UnknownData>, PolygonDataLayer<UnknownData>, PolygonDataLayer<UnknownData>>;
+compiledTooltipTemplate: IMaybe<IType<    {
+fn: (dataElement: UnknownData) => string;
+}, {
+fn: (dataElement: UnknownData) => string;
+}, {
+fn: (dataElement: UnknownData) => string;
+}>>;
+touchCount: IOptionalIType<ISimpleType<number>, [undefined]>;
+} & {
+type: ISimpleType<import("src/viewer/data-layers/dataLayerTypes").LayerType.Polygon>;
+}, {
+readonly renderableDefinition: RenderableDataLayer<PolygonDataLayer<UnknownData>>;
+readonly renderState: ViewerDataLayerRenderState<PolygonDataLayer<UnknownData>>;
+readonly persistentTooltipSources: PersistentTooltipSource[];
+} & {
+setCompiledTooltipTemplate(compiledTemplate: (dataElement: UnknownData) => string): void;
+touch(): void;
+updateDefinition(updates: Partial<Omit<PolygonDataLayer<UnknownData>, "type">>): void;
+}> | ModelInstanceType<    {
+definition: IType<FurnitureDataLayer<UnknownData>, FurnitureDataLayer<UnknownData>, FurnitureDataLayer<UnknownData>>;
+compiledTooltipTemplate: IMaybe<IType<    {
+fn: (dataElement: UnknownData) => string;
+}, {
+fn: (dataElement: UnknownData) => string;
+}, {
+fn: (dataElement: UnknownData) => string;
+}>>;
+touchCount: IOptionalIType<ISimpleType<number>, [undefined]>;
+} & {
+type: ISimpleType<import("src/viewer/data-layers/dataLayerTypes").LayerType.Furniture>;
+}, {
+readonly renderableDefinition: RenderableDataLayer<FurnitureDataLayer<UnknownData>>;
+readonly renderState: ViewerDataLayerRenderState<FurnitureDataLayer<UnknownData>>;
+readonly persistentTooltipSources: PersistentTooltipSource[];
+} & {
+setCompiledTooltipTemplate(compiledTemplate: (dataElement: UnknownData) => string): void;
+touch(): void;
+updateDefinition(updates: Partial<Omit<FurnitureDataLayer<UnknownData>, "type">>): void;
+}> | ModelInstanceType<    {
+definition: IType<HeatmapDataLayer<UnknownData>, HeatmapDataLayer<UnknownData>, HeatmapDataLayer<UnknownData>>;
+compiledTooltipTemplate: IMaybe<IType<    {
+fn: (dataElement: UnknownData) => string;
+}, {
+fn: (dataElement: UnknownData) => string;
+}, {
+fn: (dataElement: UnknownData) => string;
+}>>;
+touchCount: IOptionalIType<ISimpleType<number>, [undefined]>;
+} & {
+type: ISimpleType<import("src/viewer/data-layers/dataLayerTypes").LayerType.Heatmap>;
+}, {
+readonly renderableDefinition: RenderableDataLayer<HeatmapDataLayer<UnknownData>>;
+readonly renderState: ViewerDataLayerRenderState<HeatmapDataLayer<UnknownData>>;
+readonly persistentTooltipSources: PersistentTooltipSource[];
+} & {
+setCompiledTooltipTemplate(compiledTemplate: (dataElement: UnknownData) => string): void;
+touch(): void;
+updateDefinition(updates: Partial<Omit<HeatmapDataLayer<UnknownData>, "type">>): void;
+}>>>;
+}, {
+engine: AbstractEngine | null;
+canvas: HTMLCanvasElement | null;
+scene: SmplrScene | null;
+hoveredDataElement: HoveredDataElement | null;
+pickHandler: {
+onPick: OnPickFn;
+} | null;
+tooltip: ViewerTooltipData | null;
+persistentTooltipsViewportTick: number;
+lights: ViewerLights | null;
+shadowGenerator: SmplrShadowGenerator | null;
+useCascadedShadowMap: boolean;
+smplrWhite: PBRMetallicRoughnessMaterial | null;
+wallMaterial: PBRMetallicRoughnessMaterial | null;
+facadeWallMaterial: PBRMetallicRoughnessMaterial | null;
+structuralWallMaterial: PBRMetallicRoughnessMaterial | null;
+glassMaterial: PBRMetallicRoughnessMaterial | null;
+shellMaterial: PBRMetallicRoughnessMaterial | null;
+shellGroundMaterial: PBRMetallicRoughnessMaterial | null;
+metalMaterial: PBRMetallicRoughnessMaterial | null;
+groundMaterials: GroundMaterials | null;
+meshes: SmplrMesh[];
+compassMeshes: SmplrMesh[];
+assetsManager: AssetsManager | null;
+facadeAssetsManager: AssetsManager | null;
+actionManager: ActionManager | null;
+spaceRendered: boolean;
+floorplanRendered: boolean;
+objectPlaceholdersRendered: boolean;
+objectsRendered: boolean;
+sceneReadySent: boolean;
+handledEngineError: boolean;
+logoLoaderHidden: boolean;
+renderDoneTick: number;
+sceneEnvironmentTick: number;
+objectMeshesTick: number;
+facadeTick: number;
+} & {
+readonly levelCount: number;
+readonly includedLevels: SOLevel[];
+readonly baseHeightForLevel: number[];
+} & {
+readonly spaceBoundingBox: CanvasBoundingBox;
+readonly spaceVerticalExtent: number;
+} & {
+readonly spaceBoundingBoxExtent: number;
+readonly spaceCenterAtFloor: Vector2;
+} & {
+readonly isInitialVisibleLevels: boolean;
+readonly topVisibleLevelIndex: number;
+orbitCameraParameters(camera: OrbitCameraSample | undefined): OrbitCameraParameters;
+} & {
+readonly visibleLevelsHash: string;
+readonly safeTopVisibleLevelIndex: number;
+readonly sceneReady: boolean;
+readonly logoLoaderCanHide: boolean;
+readonly sceneEnvironmentReady: boolean;
+readonly renderFilter: Filter;
+} & {
+readonly showRenderLoader: boolean;
+} & {
+readonly groundCenter: Vector3_2;
+} & {
+readonly dataLayersRenderState: Record<string, ViewerDataLayerRenderState<DataLayer<UnknownData>>>;
+readonly furnitureLayerDefinitions: RenderableDataLayer<FurnitureDataLayer<UnknownData>>[];
+readonly singleLevelLayerIds: string[];
+readonly legendItems: DataLayer<UnknownData>[];
+readonly persistentTooltipSources: PersistentTooltipSource[];
+readonly spaceHasNoAnnotations: boolean;
+} & {
+getPersistentTooltips(scene: SmplrScene, viewer: ViewerRendererHandle | null): PositionedPersistentTooltip[];
+} & {
+setSpace({ levels, defaults }: {
+levels: SOLevel[];
+defaults: SOSpaceDefaults;
+}): void;
+setVisibleLevels(levelIndices: number[], noDefaultGroundFloorIn2d?: boolean): void;
+mergeRenderOptions(options: LegacySpaceRenderOptions): void;
+resetRenderOptionsToDefault(): void;
+resetRenderOptionsToInitial(): void;
+setFilterHash(filterHash: string | undefined): void;
+setSpaceHash(spaceHash: string | undefined): void;
+setObjectsHash(objectsHash: string | undefined): void;
+} & {
+syncIncludedLevelsToVisibleLevels(): void;
+syncModeToVisibleLevels(): void;
+showUpToLevel(topLevelIndex: number): void;
+showAllLevels(): void;
+} & {
+setIncludeLevels(levelIndices?: number[]): void;
+setMode(mode: CameraMode): void;
+setMoreOptionsVisible(visible: boolean): void;
+setLevelsDropdownOpen(open: boolean): void;
+appendGoToLevelDigit(digit: string): void;
+resetGoToLevel(): void;
+setHideLevelPicker(hide: boolean): void;
+setHideNavigationButtons(hide: boolean): void;
+toggleShowStructuralWalls(): void;
+toggleShowAnnotations(): void;
+toggleShowCompass(): void;
+toggleShowFacade(): void;
+} & {
+addDataLayer(layer: SIViewerDataLayer): void;
+updateDataLayerDefinition(layerId: string, updates: Partial<Omit<DataLayer<UnknownData>, 'type'>>): void;
+removeDataLayer(layerId: string): void;
+touchFurnitureLayers(): void;
+setSceneObjects({ engine, canvas, scene, }: {
+engine: AbstractEngine;
+canvas: HTMLCanvasElement;
+scene: SmplrScene;
+}): void;
+clearSceneObjects(): void;
+setSceneEnvironment({ lights, shadowGenerator, smplrWhite, wallMaterial, facadeWallMaterial, structuralWallMaterial, glassMaterial, shellMaterial, shellGroundMaterial, metalMaterial, groundMaterials, }: {
+lights: ViewerLights;
+shadowGenerator: SmplrShadowGenerator | null;
+smplrWhite: PBRMetallicRoughnessMaterial;
+wallMaterial: PBRMetallicRoughnessMaterial;
+facadeWallMaterial: PBRMetallicRoughnessMaterial;
+structuralWallMaterial: PBRMetallicRoughnessMaterial;
+glassMaterial: PBRMetallicRoughnessMaterial;
+shellMaterial: PBRMetallicRoughnessMaterial;
+shellGroundMaterial: PBRMetallicRoughnessMaterial;
+metalMaterial: PBRMetallicRoughnessMaterial;
+groundMaterials: GroundMaterials;
+}): void;
+enableCascadedShadowMapFallback(): void;
+setMeshes(meshes: SmplrMesh[]): void;
+setCompassMeshes(compassMeshes: SmplrMesh[]): void;
+bumpObjectMeshesTick(): void;
+bumpFacadeTick(): void;
+setAssetsManager(assetsManager: AssetsManager | null): void;
+setFacadeAssetsManager(facadeAssetsManager: AssetsManager | null): void;
+setActionManager(actionManager: ActionManager): void;
+markRenderDone(phase: RenderPhase): void;
+resetRenderPhase(phase: RenderPhase): void;
+markEngineErrorHandled(): void;
+markLogoLoaderHidden(): void;
+markSceneReadySent(): void;
+clearSceneVolatiles(): void;
+setHoveredDataElement(hoveredDataElement: HoveredDataElement): void;
+clearHoveredDataElement(): void;
+setPickHandler(pickHandler: {
+onPick: OnPickFn;
+} | null): void;
+setTooltip(tooltip: ViewerTooltipData): void;
+clearTooltip(): void;
+showPersistentTooltips(): void;
+hidePersistentTooltips(): void;
+refreshPersistentTooltipPositions(): void;
+} & {
+afterCreate(): void;
+}, _NotCustomized, _NotCustomized>;
+
+declare interface ViewerTooltipData {
+    html: string;
+    top: number;
+    left: number;
+    styleOverrides?: string;
 }
 
 declare const Wall: IModelType<    {
@@ -4542,6 +5432,13 @@ removeOpening(id: string): void;
 regenerateIds(randomizer: string): void;
 }, _NotCustomized, _NotCustomized>;
 
+declare interface WallsRenderState extends ElementRenderState {
+    render: boolean;
+    alpha: number;
+    showStructuralWalls: boolean;
+    maxHeightCm?: number;
+}
+
 declare type WallType = 'normal' | 'structural' | 'shell' | 'norender';
 
 export { }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smplrspace/smplr-loader",
-  "version": "2.57.2-beta.0",
+  "version": "2.57.2-beta.10",
   "description": "NPM package to load a typed Smplr.js from CDN easily",
   "type": "module",
   "files": [