@smplrspace/smplr-loader 2.31.0 → 2.31.1-beta.1

package/dist/generated/smplr.d.ts

@@ -3,11 +3,16 @@ import { CSSProperties } from 'react';
 import { Dispatch } from 'react';
 import { EasingOptions } from 'mapbox-gl';
 import { GetTokenSilentlyOptions } from '@auth0/auth0-spa-js';
+import { IArrayType } 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 { LogoutOptions } from '@auth0/auth0-spa-js';
+import { MapMouseEvent } from 'mapbox-gl';
+import { Mesh } from '@babylonjs/core/Meshes/mesh';
 import { default as NoSleep_2 } from 'nosleep.js';
 import { _NotCustomized } from 'mobx-state-tree';
 import { RedirectLoginOptions } from '@auth0/auth0-spa-js';
@@ -15,11 +20,60 @@ import { Reducer } from 'react';
 import { ReducerAction } from 'react';
 import { RefObject } from 'react';
 import { Scene } from '@babylonjs/core/scene';
+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';
 
+declare const AbstractSegment: IModelType<    {
+start: IModelType<    {
+r: ISimpleType<number>;
+t: ISimpleType<number>;
+} & {
+id: IOptionalIType<ISimpleType<string>, [undefined]>;
+}, {
+regenerateId(randomizer: string): void;
+}, _NotCustomized, _NotCustomized>;
+end: IModelType<    {
+r: ISimpleType<number>;
+t: ISimpleType<number>;
+} & {
+id: IOptionalIType<ISimpleType<string>, [undefined]>;
+}, {
+regenerateId(randomizer: string): void;
+}, _NotCustomized, _NotCustomized>;
+}, {
+readonly centerPoint: SOCanvasPoint;
+}, _NotCustomized, _NotCustomized>;
+
+declare const Annotation: IModelType<    {
+id: IOptionalIType<ISimpleType<string>, [undefined]>;
+type: IOptionalIType<ISimpleType<AnnotationType>, [undefined]>;
+name: IOptionalIType<ISimpleType<string>, [undefined]>;
+r: IOptionalIType<ISimpleType<number>, [undefined]>;
+t: IOptionalIType<ISimpleType<number>, [undefined]>;
+height: IMaybe<ISimpleType<number>>;
+size: IMaybe<ISimpleType<number>>;
+media: IMaybe<ISimpleType<string>>;
+is360: IOptionalIType<ISimpleType<boolean>, [undefined]>;
+direction: IMaybe<ISimpleType<number>>;
+}, {
+setType(type: AnnotationType): void;
+rename(name: string): void;
+moveTo({ r, t }: CanvasCoord): void;
+setHeight(height: number): void;
+setSize(size: number): void;
+remove(): void;
+setMedia(url: string | undefined): void;
+setIs360(is360: boolean): void;
+setDirection(angle: number | undefined): void;
+regenerateId(randomizer: string): void;
+}, _NotCustomized, _NotCustomized>;
+
+declare type AnnotationType = 'classic' | 'entrance';
+
 declare interface Auth0ContextValue {
     isAuthenticated: boolean;
     user: User | null;
@@ -55,8 +109,42 @@ declare interface BaseDataLayer<T, D extends UnknownData> {
     legend?: LegendConfig;
 }
 
+declare interface BaseOption<C, K extends keyof C> {
+    name: K;
+    description?: string;
+    disabledIf?: (args: {
+        configuration: C | Options<C>[];
+    }) => boolean;
+}
+
+declare type BooleanOption<C, K extends keyof C> = BaseOption<C, K> & {
+    type: 'boolean';
+    defaultValue: boolean | undefined;
+};
+
 export declare type CameraMode = '2d' | '3d'
 
+declare interface CanvasBoundingBox {
+    minR: number;
+    maxR: number;
+    minT: number;
+    maxT: number;
+}
+
+declare interface CanvasCoord {
+    r: number;
+    t: number;
+}
+
+declare const CanvasPoint: IModelType<    {
+r: ISimpleType<number>;
+t: ISimpleType<number>;
+} & {
+id: IOptionalIType<ISimpleType<string>, [undefined]>;
+}, {
+regenerateId(randomizer: string): void;
+}, _NotCustomized, _NotCustomized>;
+
 declare const categoryScale: <C extends string>({ categories, nodata, }: CategoryScaleOptions<C>) => (category: C) => string;
 
 declare interface CategoryScaleOptions<C extends string> {
@@ -72,6 +160,24 @@ declare const categorySwatches: <C extends string>({ categories, nodata, exclude
     label: string;
 }[];
 
+declare namespace chair {
+    export {
+        key,
+        ChairStyle,
+        ChairConfiguration,
+        options,
+        render3d,
+        render2d,
+        getNominalDimensions
+    }
+}
+
+declare type ChairConfiguration = {
+    style: ChairStyle;
+};
+
+declare type ChairStyle = 'chair' | 'office-chair' | 'stool';
+
 declare namespace Color {
     export {
         drawColorSwatches,
@@ -112,6 +218,23 @@ declare interface ColorSwatchesProps {
 
 declare const cssToSmplrColor: (c: string) => string;
 
+declare namespace cube {
+    export {
+        key_2 as key,
+        CubeConfiguration,
+        options_2 as options,
+        render3d_2 as render3d,
+        render2d_2 as render2d,
+        getNominalDimensions_2 as getNominalDimensions,
+        getGroundFootprint
+    }
+}
+
+declare type CubeConfiguration = {
+    glass: boolean;
+    crossed: boolean;
+};
+
 declare interface CubeOptions<D> {
     shape: 'cube';
     size?: number;
@@ -167,6 +290,27 @@ declare type DeepPartial<T> = T extends object ? {
     [P in keyof T]?: DeepPartial<T[P]>;
 } : T;
 
+declare namespace desk {
+    export {
+        key_3 as key,
+        DeskConfiguration,
+        options_3 as options,
+        render3d_3 as render3d,
+        render2d_3 as render2d,
+        getNominalDimensions_3 as getNominalDimensions,
+        getGroundFootprint_2 as getGroundFootprint
+    }
+}
+
+declare type DeskConfiguration = {
+    leftSide: DeskSide;
+    rightSide: DeskSide;
+    drawerBar: boolean;
+    seat: chair.ChairStyle | 'none';
+};
+
+declare type DeskSide = 'feet' | 'plank' | 'drawers';
+
 declare interface Dimensions {
     length: number;
     height: number;
@@ -316,6 +460,181 @@ declare interface GeoPoint {
     lat: number;
 }
 
+declare interface Georeference {
+    location: OrientatedGeoPoint & {
+        scaleCorrection: number;
+    };
+    anchor: CanvasCoord & {
+        levelIndex: number;
+    };
+    cameraPlacement: MapCameraPlacement;
+}
+
+declare const getGroundFootprint: GroundFootprintGetter<CubeConfiguration>;
+
+declare const getGroundFootprint_2: GroundFootprintGetter<DeskConfiguration>;
+
+declare const getNominalDimensions: NominalDimensionsGetter<ChairConfiguration>;
+
+declare const getNominalDimensions_2: NominalDimensionsGetter<CubeConfiguration>;
+
+declare const getNominalDimensions_3: NominalDimensionsGetter<DeskConfiguration>;
+
+declare const getNominalDimensions_4: NominalDimensionsGetter<ScreenConfiguration>;
+
+declare const getNominalDimensions_5: NominalDimensionsGetter<ShelvesConfiguration>;
+
+declare const getNominalDimensions_6: NominalDimensionsGetter<TableConfiguration>;
+
+declare const getNominalDimensions_7: NominalDimensionsGetter<TableAndChairsConfiguration>;
+
+declare const getNominalDimensions_8: NominalDimensionsGetter<TriangularDeskConfiguration>;
+
+declare const Ground: IModelType<    {
+id: IOptionalIType<ISimpleType<string>, [undefined]>;
+type: IOptionalIType<ISimpleType<"ground">, [undefined]>;
+name: IOptionalIType<ISimpleType<string>, [undefined]>;
+options: IOptionalIType<IModelType<    {
+type: IOptionalIType<ISimpleType<"normal" | "shell" | "norender">, [undefined]>;
+baseHeight: IMaybe<ISimpleType<number>>;
+thickness: IMaybe<ISimpleType<number>>;
+contour: IMaybe<ISimpleType<number>>;
+style: IOptionalIType<ISimpleType<string>, [undefined]>;
+external: IOptionalIType<ISimpleType<boolean>, [undefined]>;
+}, {
+setType(type: "normal" | "shell" | "norender"): void;
+setBaseHeight(baseHeight: number): void;
+setThickness(thickness: number): void;
+setContour(contour: number): void;
+setStyle(style: string): void;
+setExternal(external: boolean): void;
+}, _NotCustomized, _NotCustomized>, [undefined]>;
+segments: IArrayType<IModelType<    {
+start: IModelType<    {
+r: ISimpleType<number>;
+t: ISimpleType<number>;
+} & {
+id: IOptionalIType<ISimpleType<string>, [undefined]>;
+}, {
+regenerateId(randomizer: string): void;
+}, _NotCustomized, _NotCustomized>;
+end: IModelType<    {
+r: ISimpleType<number>;
+t: ISimpleType<number>;
+} & {
+id: IOptionalIType<ISimpleType<string>, [undefined]>;
+}, {
+regenerateId(randomizer: string): void;
+}, _NotCustomized, _NotCustomized>;
+}, {
+readonly centerPoint: SOCanvasPoint;
+} & {
+regenerateIds(randomizer: string): void;
+}, _NotCustomized, _NotCustomized>>;
+holes: IArrayType<IModelType<    {
+id: IOptionalIType<ISimpleType<string>, [undefined]>;
+type: IOptionalIType<ISimpleType<"hole">, [undefined]>;
+name: IOptionalIType<ISimpleType<string>, [undefined]>;
+segments: IArrayType<IModelType<    {
+start: IModelType<    {
+r: ISimpleType<number>;
+t: ISimpleType<number>;
+} & {
+id: IOptionalIType<ISimpleType<string>, [undefined]>;
+}, {
+regenerateId(randomizer: string): void;
+}, _NotCustomized, _NotCustomized>;
+end: IModelType<    {
+r: ISimpleType<number>;
+t: ISimpleType<number>;
+} & {
+id: IOptionalIType<ISimpleType<string>, [undefined]>;
+}, {
+regenerateId(randomizer: string): void;
+}, _NotCustomized, _NotCustomized>;
+}, {
+readonly centerPoint: SOCanvasPoint;
+} & {
+regenerateIds(randomizer: string): void;
+}, _NotCustomized, _NotCustomized>>;
+}, {
+getGround(): IGround;
+} & {
+newInParent(): void;
+removeInParent(): void;
+clearInEditor(id: string): void;
+regenerateIds(randomizer: string): void;
+} & {
+rename(name: string): void;
+} & {
+readonly points: SOCanvasPoint[];
+readonly geometry: SegmentGeometry;
+} & {
+addPoint({ r, t }: SICanvasPoint): void;
+addPointAfter({ pointId }: {
+pointId: string;
+}): void;
+close(): void;
+removePoint(id: string): void;
+} & {
+movePoint(id: string, { r, t }: SICanvasPoint): void;
+}, _NotCustomized, _NotCustomized>>;
+}, {
+newInParent(): void;
+removeInParent(): void;
+clearInEditor(id: string): void;
+regenerateIds(randomizer: string): void;
+} & {
+rename(name: string): void;
+addHole(hole?: Omit<SIHole, 'segments'> & {
+segments: SOGroundSegment[];
+}): void;
+removeHole(holeId: string): void;
+replaceSegments(segments: SIGroundSegment[]): void;
+} & {
+readonly points: SOCanvasPoint[];
+readonly geometry: SegmentGeometry;
+} & {
+addPoint({ r, t }: SICanvasPoint): void;
+addPointAfter({ pointId }: {
+pointId: string;
+}): void;
+close(): void;
+removePoint(id: string): void;
+} & {
+movePoint(id: string, { r, t }: SICanvasPoint): void;
+}, _NotCustomized, _NotCustomized>;
+
+declare type GroundFootprintGetter<C> = (args: {
+    width: number;
+    length: number;
+    closed: boolean;
+    configuration: Partial<C>;
+}) => Vector2[];
+
+declare const GroundSegment: IModelType<    {
+start: IModelType<    {
+r: ISimpleType<number>;
+t: ISimpleType<number>;
+} & {
+id: IOptionalIType<ISimpleType<string>, [undefined]>;
+}, {
+regenerateId(randomizer: string): void;
+}, _NotCustomized, _NotCustomized>;
+end: IModelType<    {
+r: ISimpleType<number>;
+t: ISimpleType<number>;
+} & {
+id: IOptionalIType<ISimpleType<string>, [undefined]>;
+}, {
+regenerateId(randomizer: string): void;
+}, _NotCustomized, _NotCustomized>;
+}, {
+readonly centerPoint: SOCanvasPoint;
+} & {
+regenerateIds(randomizer: string): void;
+}, _NotCustomized, _NotCustomized>;
+
 declare interface HeatmapBarChartOptions {
     style: 'bar-chart';
     height: (interpolatedValue: number) => number;
@@ -353,6 +672,61 @@ declare interface HeatmapSpheresOptions {
 
 declare type HeatmapStyleOptions = HeatmapSpheresOptions | HeatmapGridOptions | HeatmapBarChartOptions;
 
+declare const Hole: IModelType<    {
+id: IOptionalIType<ISimpleType<string>, [undefined]>;
+type: IOptionalIType<ISimpleType<"hole">, [undefined]>;
+name: IOptionalIType<ISimpleType<string>, [undefined]>;
+segments: IArrayType<IModelType<    {
+start: IModelType<    {
+r: ISimpleType<number>;
+t: ISimpleType<number>;
+} & {
+id: IOptionalIType<ISimpleType<string>, [undefined]>;
+}, {
+regenerateId(randomizer: string): void;
+}, _NotCustomized, _NotCustomized>;
+end: IModelType<    {
+r: ISimpleType<number>;
+t: ISimpleType<number>;
+} & {
+id: IOptionalIType<ISimpleType<string>, [undefined]>;
+}, {
+regenerateId(randomizer: string): void;
+}, _NotCustomized, _NotCustomized>;
+}, {
+readonly centerPoint: SOCanvasPoint;
+} & {
+regenerateIds(randomizer: string): void;
+}, _NotCustomized, _NotCustomized>>;
+}, {
+getGround(): IGround;
+} & {
+newInParent(): void;
+removeInParent(): void;
+clearInEditor(id: string): void;
+regenerateIds(randomizer: string): void;
+} & {
+rename(name: string): void;
+} & {
+readonly points: SOCanvasPoint[];
+readonly geometry: SegmentGeometry;
+} & {
+addPoint({ r, t }: SICanvasPoint): void;
+addPointAfter({ pointId }: {
+pointId: string;
+}): void;
+close(): void;
+removePoint(id: string): void;
+} & {
+movePoint(id: string, { r, t }: SICanvasPoint): void;
+}, _NotCustomized, _NotCustomized>;
+
+declare interface IAnnotation extends Instance<typeof Annotation> {
+}
+
+declare interface ICanvasPoint extends Instance<typeof CanvasPoint> {
+}
+
 export declare type IconData = BaseData & {
     position: SmplrCoord3d;
 };
@@ -391,6 +765,43 @@ declare interface IconsSwatchesProps {
     noLabels?: boolean;
 }
 
+declare interface IGround extends Instance<typeof Ground> {
+}
+
+declare interface IObject extends Instance<typeof Object_2> {
+}
+
+declare interface IRoof extends Instance<typeof Roof> {
+}
+
+declare interface IStair extends Instance<typeof Stair> {
+}
+
+declare interface IWall extends Instance<typeof Wall> {
+}
+
+declare interface IWallOpening extends Instance<typeof WallOpening> {
+}
+
+declare interface IWallSegment extends Instance<typeof WallSegment> {
+}
+
+declare const key = "chair";
+
+declare const key_2 = "cube";
+
+declare const key_3 = "desk";
+
+declare const key_4 = "screen";
+
+declare const key_5 = "shelves";
+
+declare const key_6 = "table";
+
+declare const key_7 = "tableAndChairs";
+
+declare const key_8 = "triangularDesk";
+
 declare type LegendConfig = NumericLegend | ColorSwatches | IconLegend;
 
 declare interface LegendProps {
@@ -402,6 +813,485 @@ declare interface LegendProps {
     correctColor?: boolean;
 }
 
+declare const Level: IModelType<    {
+name: IOptionalIType<ISimpleType<string>, [undefined]>;
+initials: IOptionalIType<ISimpleType<string>, [undefined]>;
+autoInitials: IOptionalIType<ISimpleType<boolean>, [undefined]>;
+grounds: IOptionalIType<IArrayType<IModelType<    {
+id: IOptionalIType<ISimpleType<string>, [undefined]>;
+type: IOptionalIType<ISimpleType<"ground">, [undefined]>;
+name: IOptionalIType<ISimpleType<string>, [undefined]>;
+options: IOptionalIType<IModelType<    {
+type: IOptionalIType<ISimpleType<"normal" | "shell" | "norender">, [undefined]>;
+baseHeight: IMaybe<ISimpleType<number>>;
+thickness: IMaybe<ISimpleType<number>>;
+contour: IMaybe<ISimpleType<number>>;
+style: IOptionalIType<ISimpleType<string>, [undefined]>;
+external: IOptionalIType<ISimpleType<boolean>, [undefined]>;
+}, {
+setType(type: "normal" | "shell" | "norender"): void;
+setBaseHeight(baseHeight: number): void;
+setThickness(thickness: number): void;
+setContour(contour: number): void;
+setStyle(style: string): void;
+setExternal(external: boolean): void;
+}, _NotCustomized, _NotCustomized>, [undefined]>;
+segments: IArrayType<IModelType<    {
+start: IModelType<    {
+r: ISimpleType<number>;
+t: ISimpleType<number>;
+} & {
+id: IOptionalIType<ISimpleType<string>, [undefined]>;
+}, {
+regenerateId(randomizer: string): void;
+}, _NotCustomized, _NotCustomized>;
+end: IModelType<    {
+r: ISimpleType<number>;
+t: ISimpleType<number>;
+} & {
+id: IOptionalIType<ISimpleType<string>, [undefined]>;
+}, {
+regenerateId(randomizer: string): void;
+}, _NotCustomized, _NotCustomized>;
+}, {
+readonly centerPoint: SOCanvasPoint;
+} & {
+regenerateIds(randomizer: string): void;
+}, _NotCustomized, _NotCustomized>>;
+holes: IArrayType<IModelType<    {
+id: IOptionalIType<ISimpleType<string>, [undefined]>;
+type: IOptionalIType<ISimpleType<"hole">, [undefined]>;
+name: IOptionalIType<ISimpleType<string>, [undefined]>;
+segments: IArrayType<IModelType<    {
+start: IModelType<    {
+r: ISimpleType<number>;
+t: ISimpleType<number>;
+} & {
+id: IOptionalIType<ISimpleType<string>, [undefined]>;
+}, {
+regenerateId(randomizer: string): void;
+}, _NotCustomized, _NotCustomized>;
+end: IModelType<    {
+r: ISimpleType<number>;
+t: ISimpleType<number>;
+} & {
+id: IOptionalIType<ISimpleType<string>, [undefined]>;
+}, {
+regenerateId(randomizer: string): void;
+}, _NotCustomized, _NotCustomized>;
+}, {
+readonly centerPoint: SOCanvasPoint;
+} & {
+regenerateIds(randomizer: string): void;
+}, _NotCustomized, _NotCustomized>>;
+}, {
+getGround(): IGround;
+} & {
+newInParent(): void;
+removeInParent(): void;
+clearInEditor(id: string): void;
+regenerateIds(randomizer: string): void;
+} & {
+rename(name: string): void;
+} & {
+readonly points: SOCanvasPoint[];
+readonly geometry: SegmentGeometry;
+} & {
+addPoint({ r, t }: SICanvasPoint): void;
+addPointAfter({ pointId }: {
+pointId: string;
+}): void;
+close(): void;
+removePoint(id: string): void;
+} & {
+movePoint(id: string, { r, t }: SICanvasPoint): void;
+}, _NotCustomized, _NotCustomized>>;
+}, {
+newInParent(): void;
+removeInParent(): void;
+clearInEditor(id: string): void;
+regenerateIds(randomizer: string): void;
+} & {
+rename(name: string): void;
+addHole(hole?: (Omit<SIHole, "segments"> & {
+segments: SOGroundSegment[];
+}) | undefined): void;
+removeHole(holeId: string): void;
+replaceSegments(segments: SIGroundSegment[]): void;
+} & {
+readonly points: SOCanvasPoint[];
+readonly geometry: SegmentGeometry;
+} & {
+addPoint({ r, t }: SICanvasPoint): void;
+addPointAfter({ pointId }: {
+pointId: string;
+}): void;
+close(): void;
+removePoint(id: string): void;
+} & {
+movePoint(id: string, { r, t }: SICanvasPoint): void;
+}, _NotCustomized, _NotCustomized>>, [undefined]>;
+walls: IOptionalIType<IArrayType<IModelType<    {
+id: IOptionalIType<ISimpleType<string>, [undefined]>;
+type: IOptionalIType<ISimpleType<"wall">, [undefined]>;
+name: IOptionalIType<ISimpleType<string>, [undefined]>;
+options: IOptionalIType<IModelType<    {
+type: IOptionalIType<ISimpleType<"normal" | "shell" | "norender" | "structural">, [undefined]>;
+cap: IOptionalIType<ISimpleType<"flat" | "round">, [undefined]>;
+height: IMaybe<ISimpleType<number>>;
+thickness: IMaybe<ISimpleType<number>>;
+autoFacade: IOptionalIType<ISimpleType<boolean>, [undefined]>;
+partOfFacade: IOptionalIType<ISimpleType<boolean>, [undefined]>;
+}, {
+setType(type: "normal" | "shell" | "norender" | "structural"): void;
+setCap(cap: "flat" | "round"): void;
+setHeight(height: number): void;
+setThickness(thickness: number): void;
+setAutoFacade(autoFacade: boolean): void;
+setPartOfFacade(partOfFacade: boolean): void;
+}, _NotCustomized, _NotCustomized>, [undefined]>;
+segments: IArrayType<IModelType<    {
+start: IModelType<    {
+r: ISimpleType<number>;
+t: ISimpleType<number>;
+} & {
+id: IOptionalIType<ISimpleType<string>, [undefined]>;
+}, {
+regenerateId(randomizer: string): void;
+}, _NotCustomized, _NotCustomized>;
+end: IModelType<    {
+r: ISimpleType<number>;
+t: ISimpleType<number>;
+} & {
+id: IOptionalIType<ISimpleType<string>, [undefined]>;
+}, {
+regenerateId(randomizer: string): void;
+}, _NotCustomized, _NotCustomized>;
+} & {
+id: IOptionalIType<ISimpleType<string>, [undefined]>;
+openings: IArrayType<IModelType<    {
+id: IOptionalIType<ISimpleType<string>, [undefined]>;
+name: IOptionalIType<ISimpleType<string>, [undefined]>;
+type: ISimpleType<"door" | "window">;
+dimensions: IOptionalIType<IModelType<    {
+width: IMaybe<ISimpleType<number>>;
+height: IMaybe<ISimpleType<number>>;
+baseHeight: IMaybe<ISimpleType<number>>;
+}, {}, _NotCustomized, _NotCustomized>, [undefined]>;
+position: IMaybe<IModelType<    {
+from: ISimpleType<"start" | "end">;
+distance: ISimpleType<number>;
+}, {}, _NotCustomized, _NotCustomized>>;
+options: IOptionalIType<IModelType<    {
+style: IOptionalIType<ISimpleType<string>, [undefined]>;
+nbOfPanels: IOptionalIType<ISimpleType<number>, [undefined]>;
+nbOfPanelsVertically: IOptionalIType<ISimpleType<number>, [undefined]>;
+twoPanels: IOptionalIType<ISimpleType<boolean>, [undefined]>;
+centerSplit: IOptionalIType<ISimpleType<boolean>, [undefined]>;
+swapKnob: IOptionalIType<ISimpleType<boolean>, [undefined]>;
+swapInOut: IOptionalIType<ISimpleType<boolean>, [undefined]>;
+swapPanels: IOptionalIType<ISimpleType<boolean>, [undefined]>;
+glass: IOptionalIType<ISimpleType<boolean>, [undefined]>;
+openFrom: IOptionalIType<ISimpleType<string>, [undefined]>;
+panelsOpened: IOptionalIType<ISimpleType<number>, [undefined]>;
+openAngle: IOptionalIType<ISimpleType<number>, [undefined]>;
+railingHeight: IMaybe<ISimpleType<number>>;
+railingStyle: IOptionalIType<ISimpleType<string>, [undefined]>;
+}, {
+setStyle(style: string): void;
+setNbOfPanels(nbOfPanels: number): void;
+setNbOfPanelsVertically(nbOfPanelsVertically: number): void;
+setCenterSplit(centerSplit: boolean): void;
+setSwapKnob(swapKnob: boolean): void;
+setSwapInOut(swapInOut: boolean): void;
+setSwapPanels(swapPanels: boolean): void;
+setTwoPanels(twoPanels: boolean): void;
+setGlass(glass: boolean): void;
+setOpenFrom(openFrom: string): void;
+setPanelsOpened(panelsOpened: number): void;
+setOpenAngle(openAngle: number): void;
+setRailingHeight(railingHeight: number): void;
+setRailingStyle(railingStyle: string): void;
+}, _NotCustomized, _NotCustomized>, [undefined]>;
+}, {
+readonly segment: IWallSegment;
+} & {
+readonly feature: IWall;
+readonly direction: number;
+} & {
+readonly orientation: "horizontal" | "vertical";
+} & {
+verifyOpeningPosition(): void;
+regenerateId(randomizer: string): void;
+} & {
+rename(name: string): void;
+resize(dimensions: Partial<SIWallOpeningDimensions>): void;
+moveTo(position: SIWallOpeningPosition): void;
+moveInDirection(direction: URDL, distance?: number): void;
+remove(): void;
+}, _NotCustomized, _NotCustomized>>;
+}, {
+readonly centerPoint: SOCanvasPoint;
+} & {
+readonly centerPoint: SOCanvasPoint;
+} & {
+addOpening(opening: SIWallOpening): void;
+removeOpening(id: string): void;
+regenerateIds(randomizer: string): void;
+}, _NotCustomized, _NotCustomized>>;
+}, {
+newInParent(): void;
+removeInParent(): void;
+clearInEditor(id: string): void;
+regenerateIds(randomizer: string): void;
+} & {
+rename(name: string): void;
+} & {
+readonly points: SOCanvasPoint[];
+readonly geometry: SegmentGeometry;
+} & {
+addPoint({ r, t }: SICanvasPoint): void;
+addPointAfter({ pointId }: {
+pointId: string;
+}): void;
+close(): void;
+removePoint(id: string): void;
+} & {
+movePoint(id: string, { r, t }: SICanvasPoint): void;
+}, _NotCustomized, _NotCustomized>>, [undefined]>;
+roofs: IOptionalIType<IArrayType<IModelType<    {
+id: IOptionalIType<ISimpleType<string>, [undefined]>;
+type: IOptionalIType<ISimpleType<"roof">, [undefined]>;
+name: IOptionalIType<ISimpleType<string>, [undefined]>;
+options: IOptionalIType<IModelType<    {
+baseHeight: IMaybe<ISimpleType<number>>;
+topHeight: IMaybe<ISimpleType<number>>;
+angle: IMaybe<ISimpleType<number>>;
+}, {
+setBaseHeight(baseHeight: number): void;
+setTopHeight(topHeight: number): void;
+setAngle(angle: number): void;
+}, _NotCustomized, _NotCustomized>, [undefined]>;
+segments: IArrayType<IModelType<    {
+start: IModelType<    {
+r: ISimpleType<number>;
+t: ISimpleType<number>;
+} & {
+id: IOptionalIType<ISimpleType<string>, [undefined]>;
+}, {
+regenerateId(randomizer: string): void;
+}, _NotCustomized, _NotCustomized>;
+end: IModelType<    {
+r: ISimpleType<number>;
+t: ISimpleType<number>;
+} & {
+id: IOptionalIType<ISimpleType<string>, [undefined]>;
+}, {
+regenerateId(randomizer: string): void;
+}, _NotCustomized, _NotCustomized>;
+} & {
+id: IOptionalIType<ISimpleType<string>, [undefined]>;
+base: IOptionalIType<ISimpleType<boolean>, [undefined]>;
+}, {
+readonly centerPoint: SOCanvasPoint;
+} & {
+regenerateIds(randomizer: string): void;
+}, _NotCustomized, _NotCustomized>>;
+}, {
+newInParent(): void;
+removeInParent(): void;
+clearInEditor(id: string): void;
+regenerateIds(randomizer: string): void;
+} & {
+rename(name: string): void;
+setBaseSegmentById(id: string): void;
+} & {
+readonly points: SOCanvasPoint[];
+readonly geometry: SegmentGeometry;
+} & {
+addPoint({ r, t }: SICanvasPoint): void;
+addPointAfter({ pointId }: {
+pointId: string;
+}): void;
+close(): void;
+removePoint(id: string): void;
+} & {
+movePoint(id: string, { r, t }: SICanvasPoint): void;
+}, _NotCustomized, _NotCustomized>>, [undefined]>;
+stairs: IArrayType<IModelType<    {
+id: IOptionalIType<ISimpleType<string>, [undefined]>;
+name: IOptionalIType<ISimpleType<string>, [undefined]>;
+bottomSegment: IArrayType<IModelType<    {
+r: ISimpleType<number>;
+t: ISimpleType<number>;
+} & {
+id: IOptionalIType<ISimpleType<string>, [undefined]>;
+}, {
+regenerateId(randomizer: string): void;
+}, _NotCustomized, _NotCustomized>>;
+topSegment: IArrayType<IModelType<    {
+r: ISimpleType<number>;
+t: ISimpleType<number>;
+} & {
+id: IOptionalIType<ISimpleType<string>, [undefined]>;
+}, {
+regenerateId(randomizer: string): void;
+}, _NotCustomized, _NotCustomized>>;
+baseHeight: IMaybe<ISimpleType<number>>;
+height: IMaybe<ISimpleType<number>>;
+style: IOptionalIType<ISimpleType<"slope" | "thin" | "thick" | "block">, [undefined]>;
+}, {
+rename(name: string): void;
+setBaseHeight(baseHeight: number): void;
+setHeight(height: number): void;
+setStyle(style: "slope" | "thin" | "thick" | "block"): void;
+moveBy({ dr, dt }: {
+dr: number;
+dt: number;
+}): void;
+remove(): void;
+regenerateIds(randomizer: string): void;
+}, _NotCustomized, _NotCustomized>>;
+annotations: IArrayType<IModelType<    {
+id: IOptionalIType<ISimpleType<string>, [undefined]>;
+type: IOptionalIType<ISimpleType<AnnotationType>, [undefined]>;
+name: IOptionalIType<ISimpleType<string>, [undefined]>;
+r: IOptionalIType<ISimpleType<number>, [undefined]>;
+t: IOptionalIType<ISimpleType<number>, [undefined]>;
+height: IMaybe<ISimpleType<number>>;
+size: IMaybe<ISimpleType<number>>;
+media: IMaybe<ISimpleType<string>>;
+is360: IOptionalIType<ISimpleType<boolean>, [undefined]>;
+direction: IMaybe<ISimpleType<number>>;
+}, {
+setType(type: AnnotationType): void;
+rename(name: string): void;
+moveTo({ r, t }: CanvasCoord): void;
+setHeight(height: number): void;
+setSize(size: number): void;
+remove(): void;
+setMedia(url: string | undefined): void;
+setIs360(is360: boolean): void;
+setDirection(angle: number | undefined): void;
+regenerateId(randomizer: string): void;
+}, _NotCustomized, _NotCustomized>>;
+objects: IArrayType<IModelType<    {
+catalogId: ISimpleType<string>;
+id: IOptionalIType<ISimpleType<string>, [undefined]>;
+name: IOptionalIType<ISimpleType<string>, [undefined]>;
+levelIndex: IOptionalIType<ISimpleType<number>, [undefined]>;
+position: IOptionalIType<IModelType<    {
+x: ISimpleType<number>;
+z: ISimpleType<number>;
+} & {
+elevation: ISimpleType<number>;
+}, {}, _NotCustomized, _NotCustomized>, [undefined]>;
+rotation: IOptionalIType<IModelType<    {
+pitch: IOptionalIType<ISimpleType<number>, [undefined]>;
+yaw: IOptionalIType<ISimpleType<number>, [undefined]>;
+roll: IOptionalIType<ISimpleType<number>, [undefined]>;
+}, {}, _NotCustomized, _NotCustomized>, [undefined]>;
+dimensions: IOptionalIType<IModelType<    {
+length: IMaybe<ISimpleType<number>>;
+width: IMaybe<ISimpleType<number>>;
+height: IMaybe<ISimpleType<number>>;
+}, {
+readonly safeValues: {
+length: number;
+width: number;
+height: number;
+};
+}, _NotCustomized, _NotCustomized>, [undefined]>;
+configuration: IMaybe<IType<Partial<ParametricObjectConfiguration>, Partial<ParametricObjectConfiguration>, Partial<ParametricObjectConfiguration>>>;
+external: IOptionalIType<ISimpleType<boolean>, [undefined]>;
+}, {
+rename(name: string): void;
+moveTo(position: Partial<SILevelCoord3d>): void;
+setLevelIndex(levelIndex: number): void;
+resize(dimensions: Partial<SIObjectDimensions>): void;
+rotate(rotation: Partial<SIObjectRotation>): void;
+configure(configurationChanges: Partial<ParametricObjectConfiguration>): void;
+remove(): void;
+regenerateId(randomizer: string): void;
+setExternal(external: boolean): void;
+}, _NotCustomized, _NotCustomized>>;
+floorplan: IOptionalIType<IModelType<    {
+url: IMaybe<ISimpleType<string>>;
+data: IMaybe<ISimpleType<string>>;
+r: IOptionalIType<ISimpleType<number>, [undefined]>;
+t: IOptionalIType<ISimpleType<number>, [undefined]>;
+scale: IOptionalIType<ISimpleType<number>, [undefined]>;
+flipped: IOptionalIType<ISimpleType<boolean>, [undefined]>;
+}, {
+isNil(): boolean;
+} & {
+setUrl(url: string): void;
+setData(data: string | undefined): void;
+moveTo({ r, t }: CanvasCoord): void;
+setScale(scale: number): void;
+setFlipped(flipped: boolean): void;
+remove(): void;
+} & {
+rescaleByFactor(factor: number, imageOnly?: boolean): void;
+}, _NotCustomized, _NotCustomized>, [undefined]>;
+}, {
+readonly hash: string;
+readonly points: ICanvasPoint[];
+} & {
+readonly boundingBox: CanvasBoundingBox | null;
+readonly centerPoint: CanvasCoord | null;
+readonly autoGroundHash: string;
+getHash({ only, ignore }: {
+only: any;
+ignore: any;
+}): string;
+readonly isEmpty: boolean;
+readonly openings: IWallOpening[];
+} & {
+readonly doors: IWallOpening[];
+readonly windows: IWallOpening[];
+readonly initialsFromName: string;
+} & {
+rename(name: string): void;
+setInitials(initials: string): void;
+setAutoInitials(enabled: boolean): void;
+newGround(ground?: Omit<SIGround, 'segments'> & {
+segments: SOGroundSegment[];
+}, forceId?: string): void;
+removeGround(id: string): void;
+removeAllGrounds(): void;
+newWall(wall?: Omit<SIWall, 'segments'> & {
+segments: SOAbstractSegment[] | SOWallSegment[];
+}): void;
+removeWall(id: string): void;
+removeAllWalls(): void;
+newRoof(): void;
+removeRoof(id: string): void;
+removeAllRoofs(): void;
+addStairs(stairs?: SIStair): void;
+removeStairs(id: string): void;
+removeAllStairs(): void;
+addAnnotation(annotation: SIAnnotation): void;
+removeAnnotation(id: string): void;
+removeAllAnnotations(): void;
+addObject(object: SIObject): void;
+removeObject(id: string): void;
+removeAllObjects(): void;
+setObjectsLevelIndex(levelIndex: number): void;
+updateObjectsLevelIndex(updater: (levelIndex: number) => number): void;
+regenerateIds(randomizer: string): void;
+} & {
+addObjects(objects: SIObject[]): void;
+clear(): void;
+}, _NotCustomized, _NotCustomized>;
+
+declare const LevelCoord3d: IModelType<    {
+x: ISimpleType<number>;
+z: ISimpleType<number>;
+} & {
+elevation: ISimpleType<number>;
+}, {}, _NotCustomized, _NotCustomized>;
+
 declare interface LimitedPointerEvent {
     pointerX: number;
     pointerY: number;
@@ -424,13 +1314,20 @@ declare class Map_2 {
     remove: () => void;
     mapbox(): mapboxgl.Map | undefined;
     startViewer(options: MapViewerOptions): Promise<void>;
+    addPointDataLayer<D extends UnknownSpaceData>(definition: PointMapDataLayerDefinition<D>): void;
+    updatePointDataLayer<D extends UnknownSpaceData>(definitionUpdates: Partial<PointMapDataLayerDefinition<D>>): void;
+    addPolygonDataLayer<D extends UnknownSpaceData>(definition: PolygonMapDataLayerDefinition<D>): void;
+    updatePolygonDataLayer<D extends UnknownSpaceData>(definitionUpdates: Partial<PolygonMapDataLayerDefinition<D>>): void;
+    removeDataLayer(id: string): void;
+    removeAllDataLayers(): void;
+    getDataElementPositionOnScreen(layerId: string, elementId: string): ScreenXY | null;
     setStyle(style: string): void;
     setDefaultStyle(): void;
     addSpaces(spaces: GeojsonSpace[]): void;
     addSpacesById(spaceIds: string[]): void;
     removeSpacesById(spaceIds: string[]): void;
     removeAllSpaces(): void;
-    updateRenderOptions(options: PartialMapSpaceRenderOptions): void;
+    updateRenderOptions(options: PartialMapRenderOptions): void;
     showOsmBuildings(): void;
     hideOsmBuildings(): void;
     toggleOsmBuildings(): void;
@@ -464,6 +1361,12 @@ export declare interface MapCameraPlacement {
     center: GeoPoint;
 }
 
+declare interface MapDataLayerSharedDefinition<T, D extends UnknownSpaceData> {
+    onClick?: (dataElement: T & D, event: MapMouseEvent) => void;
+    onHover?: (dataElement: T & D, event: MapMouseEvent) => void;
+    onHoverOut?: (dataElement: T & D, event: MapMouseEvent) => void;
+}
+
 export declare type MapOptions = {
     clientToken: string;
     disableErrorReporting?: boolean;
@@ -475,7 +1378,7 @@ export declare type MapOptions = {
     container: HTMLElement;
 });
 
-export declare interface MapSpaceRenderOptions {
+export declare interface MapRenderOptions {
     footprint: {
         render: boolean;
         color: string;
@@ -505,9 +1408,10 @@ export declare interface MapViewerOptions {
     onError?: (errorMessage: string) => void;
     experimental__standardStyle?: boolean;
     onSpaceClick?: ({ space, levelIndex }: {
-        space: GeojsonSpace | undefined;
+        space: ValidGeojsonSpace | undefined;
         levelIndex: number;
     }) => void;
+    legendPosition?: 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
 }
 
 declare interface Material {
@@ -520,10 +1424,38 @@ declare interface Material {
 
 export declare type NoData = Record<string, never>;
 
+declare type NominalDimensionsGetter<C> = (args: {
+    length: number;
+    width: number;
+    height: number;
+    previousDimensions: {
+        length: number;
+        width: number;
+        height: number;
+    };
+    configuration: C;
+}) => {
+    nLength: number;
+    nWidth: number;
+    nHeight: number;
+};
+
 declare interface NonInteractiveDataLayer<T, D extends UnknownData> {
     legend?: LegendConfig;
 }
 
+declare type NumberOption<C, K extends keyof C> = BaseOption<C, K> & {
+    type: 'number';
+    defaultValue: number | undefined;
+    inputProps: {
+        placeholder: string;
+        min: number;
+        max: number;
+        step: number;
+        precision: number;
+    };
+};
+
 declare interface NumericLegend extends Pick<LegendProps, 'colorScale' | 'domain' | 'ticks'> {
     type: 'numeric';
 }
@@ -574,6 +1506,65 @@ declare interface NumericScaleOptions {
     zeroAsNoData?: boolean;
 }
 
+declare const Object_2: IModelType<    {
+catalogId: ISimpleType<string>;
+id: IOptionalIType<ISimpleType<string>, [undefined]>;
+name: IOptionalIType<ISimpleType<string>, [undefined]>;
+levelIndex: IOptionalIType<ISimpleType<number>, [undefined]>;
+position: IOptionalIType<IModelType<    {
+x: ISimpleType<number>;
+z: ISimpleType<number>;
+} & {
+elevation: ISimpleType<number>;
+}, {}, _NotCustomized, _NotCustomized>, [undefined]>;
+rotation: IOptionalIType<IModelType<    {
+pitch: IOptionalIType<ISimpleType<number>, [undefined]>;
+yaw: IOptionalIType<ISimpleType<number>, [undefined]>;
+roll: IOptionalIType<ISimpleType<number>, [undefined]>;
+}, {}, _NotCustomized, _NotCustomized>, [undefined]>;
+dimensions: IOptionalIType<IModelType<    {
+length: IMaybe<ISimpleType<number>>;
+width: IMaybe<ISimpleType<number>>;
+height: IMaybe<ISimpleType<number>>;
+}, {
+readonly safeValues: {
+length: number;
+width: number;
+height: number;
+};
+}, _NotCustomized, _NotCustomized>, [undefined]>;
+configuration: IMaybe<IType<Partial<ParametricObjectConfiguration>, Partial<ParametricObjectConfiguration>, Partial<ParametricObjectConfiguration>>>;
+external: IOptionalIType<ISimpleType<boolean>, [undefined]>;
+}, {
+rename(name: string): void;
+moveTo(position: Partial<SILevelCoord3d>): void;
+setLevelIndex(levelIndex: number): void;
+resize(dimensions: Partial<SIObjectDimensions>): void;
+rotate(rotation: Partial<SIObjectRotation>): void;
+configure(configurationChanges: Partial<ParametricObjectConfiguration>): void;
+remove(): void;
+regenerateId(randomizer: string): void;
+setExternal(external: boolean): void;
+}, _NotCustomized, _NotCustomized>;
+
+declare const ObjectDimensions: IModelType<    {
+length: IMaybe<ISimpleType<number>>;
+width: IMaybe<ISimpleType<number>>;
+height: IMaybe<ISimpleType<number>>;
+}, {
+readonly safeValues: {
+length: number;
+width: number;
+height: number;
+};
+}, _NotCustomized, _NotCustomized>;
+
+declare const ObjectRotation: IModelType<    {
+pitch: IOptionalIType<ISimpleType<number>, [undefined]>;
+yaw: IOptionalIType<ISimpleType<number>, [undefined]>;
+roll: IOptionalIType<ISimpleType<number>, [undefined]>;
+}, {}, _NotCustomized, _NotCustomized>;
+
 declare type OmitOptional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
 
 export declare type OnPickFn = (args: { coordinates: SmplrCoord3d; furnitureId?: string }) => void | Promise<void>
@@ -594,6 +1585,28 @@ export declare interface Opening {
 
 declare type OpeningType = 'door' | 'window';
 
+declare type Option_2<C, K extends keyof C> = BooleanOption<C, K> | NumberOption<C, K> | SelectOption<C, K>;
+
+declare type Options<C> = {
+    [K in keyof C]: Option_2<C, K>;
+}[keyof C];
+
+declare const options: Options<ChairConfiguration>[];
+
+declare const options_2: Options<CubeConfiguration>[];
+
+declare const options_3: Options<DeskConfiguration>[];
+
+declare const options_4: Options<ScreenConfiguration>[];
+
+declare const options_5: Options<ShelvesConfiguration>[];
+
+declare const options_6: Options<TableConfiguration>[];
+
+declare const options_7: Options<TableAndChairsConfiguration>[];
+
+declare const options_8: Options<TriangularDeskConfiguration>[];
+
 declare interface OrbitCamera extends ArcRotateCamera {
     smplrData: {
         persisted: boolean;
@@ -629,6 +1642,37 @@ export declare interface OrbitCameraPlacementUpdate {
     };
 }
 
+declare interface OrientatedGeoPoint extends GeoPoint {
+    heading: number;
+}
+
+declare type ParametricObject2dRenderer<C> = (args: {
+    scene: SmplrScene;
+    width: number;
+    length: number;
+    configuration: Partial<C>;
+    renderFilter?: Filter;
+    newCamera?: boolean;
+    minimumLayerGap?: number;
+    defaults: SOSpaceDefaults;
+}) => {
+    stroke?: Mesh;
+    fill: Mesh;
+};
+
+declare type ParametricObject3dRenderer<C> = (args: {
+    scene: SmplrScene;
+    width: number;
+    length: number;
+    height: number;
+    configuration: Partial<C>;
+    renderFilter?: Filter;
+    newCamera?: boolean;
+    minimumLayerGap?: number;
+}) => Mesh;
+
+declare type ParametricObjectConfiguration = chair.ChairConfiguration | cube.CubeConfiguration | desk.DeskConfiguration | screen_2.ScreenConfiguration | shelves.ShelvesConfiguration | table.TableConfiguration | tableAndChairs.TableAndChairsConfiguration | triangularDesk.TriangularDeskConfiguration;
+
 export declare interface PartialMapCameraPlacement {
     pitch?: number;
     bearing?: number;
@@ -636,7 +1680,7 @@ export declare interface PartialMapCameraPlacement {
     center?: GeoPoint;
 }
 
-export declare type PartialMapSpaceRenderOptions = DeepPartial<MapSpaceRenderOptions>;
+export declare type PartialMapRenderOptions = DeepPartial<MapRenderOptions>;
 
 export declare interface PartialOrbitCameraPlacement {
     alpha?: number;
@@ -666,6 +1710,8 @@ export declare type PointDataLayer<D extends UnknownData = NoData> = BaseDataLay
     disableElevationCorrection?: boolean;
 } & PointShapeOptions<D>;
 
+declare type PointMapDataLayerDefinition<D extends UnknownSpaceData = SpaceNoData> = Omit<PointDataLayer<D>, 'type' | 'onDrag' | 'onDrop' | 'disableElevationCorrection' | 'onClick' | 'onHover' | 'onHoverOut'> & MapDataLayerSharedDefinition<PointData, D>;
+
 declare type PointShapeOptions<D> = SphereOptions<D> | CubeOptions<D>;
 
 export declare type PolygonData = BaseData & {
@@ -692,6 +1738,8 @@ export declare interface PolygonDataLayer<D extends UnknownData = NoData> extend
     disableElevationCorrection?: boolean;
 }
 
+declare type PolygonMapDataLayerDefinition<D extends UnknownSpaceData = SpaceNoData> = Omit<PolygonDataLayer<D>, 'type' | 'alpha' | 'onDrag' | 'onDrop' | 'disableReshape' | 'reshapeBoxColor' | 'disableElevationCorrection' | 'onClick' | 'onHover' | 'onHoverOut'> & MapDataLayerSharedDefinition<PolygonData, D>;
+
 export declare type PolylineData = BaseData & {
     coordinates: SmplrCoord3d[];
 };
@@ -930,24 +1978,216 @@ declare const ragSwatches: <C extends string>({ categories, colors, nodata, excl
     label: string;
 }[];
 
-export declare interface RoomWithHoles {
-    room: SmplrCoord2d[];
-    holes: SmplrCoord2d[][];
-    coordinates: SmplrCoord2d[][];
-}
+declare const render2d: ParametricObject2dRenderer<ChairConfiguration & {
+    closed?: boolean;
+}>;
 
-declare interface ScreenXY {
-    screenX: number;
-    screenY: number;
-}
+declare const render2d_2: ParametricObject2dRenderer<CubeConfiguration>;
 
-export declare interface SessionOptions {
-    loadingMessage?: string;
-    onReady?: () => void;
-    onError?: (errorMessage: string) => void;
-}
+declare const render2d_3: ParametricObject2dRenderer<DeskConfiguration>;
 
-declare type SmplrCamera = OrbitCamera | UniversalCamera | VrCamera;
+declare const render2d_4: ParametricObject2dRenderer<ScreenConfiguration>;
+
+declare const render2d_5: ParametricObject2dRenderer<ShelvesConfiguration>;
+
+declare const render2d_6: ParametricObject2dRenderer<TableConfiguration>;
+
+declare const render2d_7: ParametricObject2dRenderer<TableAndChairsConfiguration>;
+
+declare const render2d_8: ParametricObject2dRenderer<TriangularDeskConfiguration>;
+
+declare const render3d: ParametricObject3dRenderer<ChairConfiguration>;
+
+declare const render3d_2: ParametricObject3dRenderer<CubeConfiguration>;
+
+declare const render3d_3: ParametricObject3dRenderer<DeskConfiguration>;
+
+declare const render3d_4: ParametricObject3dRenderer<ScreenConfiguration>;
+
+declare const render3d_5: ParametricObject3dRenderer<ShelvesConfiguration>;
+
+declare const render3d_6: ParametricObject3dRenderer<TableConfiguration>;
+
+declare const render3d_7: ParametricObject3dRenderer<TableAndChairsConfiguration>;
+
+declare const render3d_8: ParametricObject3dRenderer<TriangularDeskConfiguration>;
+
+declare const Roof: IModelType<    {
+id: IOptionalIType<ISimpleType<string>, [undefined]>;
+type: IOptionalIType<ISimpleType<"roof">, [undefined]>;
+name: IOptionalIType<ISimpleType<string>, [undefined]>;
+options: IOptionalIType<IModelType<    {
+baseHeight: IMaybe<ISimpleType<number>>;
+topHeight: IMaybe<ISimpleType<number>>;
+angle: IMaybe<ISimpleType<number>>;
+}, {
+setBaseHeight(baseHeight: number): void;
+setTopHeight(topHeight: number): void;
+setAngle(angle: number): void;
+}, _NotCustomized, _NotCustomized>, [undefined]>;
+segments: IArrayType<IModelType<    {
+start: IModelType<    {
+r: ISimpleType<number>;
+t: ISimpleType<number>;
+} & {
+id: IOptionalIType<ISimpleType<string>, [undefined]>;
+}, {
+regenerateId(randomizer: string): void;
+}, _NotCustomized, _NotCustomized>;
+end: IModelType<    {
+r: ISimpleType<number>;
+t: ISimpleType<number>;
+} & {
+id: IOptionalIType<ISimpleType<string>, [undefined]>;
+}, {
+regenerateId(randomizer: string): void;
+}, _NotCustomized, _NotCustomized>;
+} & {
+id: IOptionalIType<ISimpleType<string>, [undefined]>;
+base: IOptionalIType<ISimpleType<boolean>, [undefined]>;
+}, {
+readonly centerPoint: SOCanvasPoint;
+} & {
+regenerateIds(randomizer: string): void;
+}, _NotCustomized, _NotCustomized>>;
+}, {
+newInParent(): void;
+removeInParent(): void;
+clearInEditor(id: string): void;
+regenerateIds(randomizer: string): void;
+} & {
+rename(name: string): void;
+setBaseSegmentById(id: string): void;
+} & {
+readonly points: SOCanvasPoint[];
+readonly geometry: SegmentGeometry;
+} & {
+addPoint({ r, t }: SICanvasPoint): void;
+addPointAfter({ pointId }: {
+pointId: string;
+}): void;
+close(): void;
+removePoint(id: string): void;
+} & {
+movePoint(id: string, { r, t }: SICanvasPoint): void;
+}, _NotCustomized, _NotCustomized>;
+
+export declare interface RoomWithHoles {
+    room: SmplrCoord2d[];
+    holes: SmplrCoord2d[][];
+    coordinates: SmplrCoord2d[][];
+}
+
+declare namespace screen_2 {
+    export {
+        key_4 as key,
+        ScreenConfiguration,
+        options_4 as options,
+        render3d_4 as render3d,
+        render2d_4 as render2d,
+        getNominalDimensions_4 as getNominalDimensions
+    }
+}
+
+declare type ScreenConfiguration = {
+    foot: 'television' | 'computer' | 'no-foot';
+};
+
+declare interface ScreenXY {
+    screenX: number;
+    screenY: number;
+}
+
+declare type SegmentGeometry = 'point' | 'unknown' | 'polygon' | 'line';
+
+declare type SelectOption<C, K extends keyof C> = BaseOption<C, K> & {
+    type: 'select';
+    defaultValue: C[K] | undefined;
+    possibleValues: C[K][];
+};
+
+export declare interface SessionOptions {
+    loadingMessage?: string;
+    onReady?: () => void;
+    onError?: (errorMessage: string) => void;
+}
+
+declare namespace shelves {
+    export {
+        key_5 as key,
+        ShelvesConfiguration,
+        options_5 as options,
+        render3d_5 as render3d,
+        render2d_5 as render2d,
+        getNominalDimensions_5 as getNominalDimensions
+    }
+}
+
+declare type ShelvesConfiguration = {
+    rows: number;
+    columns: number;
+    doors: 'no-doors' | 'swing-doors' | 'sliding-doors' | 'drawers';
+    doorPanels: number;
+    doorRows: number;
+    doorColumns: number;
+    frameThickness: number;
+    glassDoor: boolean;
+    backPanel: boolean;
+};
+
+declare interface SIAnnotation extends SnapshotIn<typeof Annotation> {
+}
+
+declare interface SICanvasPoint extends SnapshotIn<typeof CanvasPoint> {
+}
+
+declare interface SIGround extends SnapshotIn<typeof Ground> {
+}
+
+declare interface SIGroundSegment extends SnapshotIn<typeof GroundSegment> {
+}
+
+declare interface SIHole extends SnapshotIn<typeof Hole> {
+}
+
+declare interface SILevel extends Instance<typeof Level> {
+}
+
+declare interface SILevelCoord3d extends SnapshotIn<typeof LevelCoord3d> {
+}
+
+declare interface SIObject extends SnapshotIn<typeof Object_2> {
+}
+
+declare interface SIObjectDimensions extends SnapshotIn<typeof ObjectDimensions> {
+}
+
+declare interface SIObjectRotation extends SnapshotIn<typeof ObjectRotation> {
+}
+
+declare interface SIStair extends SnapshotIn<typeof Stair> {
+}
+
+declare interface SIWall extends SnapshotIn<typeof Wall> {
+}
+
+declare interface SIWallOpening extends SnapshotIn<typeof WallOpening> {
+}
+
+declare interface SIWallOpeningDimensions extends SnapshotIn<typeof WallOpeningDimensions> {
+}
+
+declare interface SIWallOpeningPosition extends SnapshotIn<typeof WallOpeningPosition> {
+}
+
+declare type SmplrCamera = OrbitCamera | UniversalCamera | VrCamera;
+
+declare enum SmplrCameraType {
+    Orbit = "orbit",
+    Walkin = "walkin",
+    Game = "game",
+    Vr = "vr"
+}
 
 export declare interface SmplrCoord2d {
     levelIndex: number;
@@ -978,9 +2218,27 @@ declare interface SmplrScene extends Scene {
 
 declare const smplrToCssColor: (c: string) => string;
 
+declare interface SOAbstractSegment extends SnapshotOut<typeof AbstractSegment> {
+}
+
+declare interface SOCanvasPoint extends SnapshotOut<typeof CanvasPoint> {
+}
+
+declare interface SOGroundSegment extends SnapshotOut<typeof GroundSegment> {
+}
+
+declare interface SOSpace extends SnapshotOut<typeof Space_2> {
+}
+
+declare interface SOSpaceDefaults extends SnapshotOut<typeof SpaceDefaults> {
+}
+
 declare interface SOWallOpeningOptions extends SnapshotOut<typeof WallOpeningOptions> {
 }
 
+declare interface SOWallSegment extends SnapshotOut<typeof WallSegment> {
+}
+
 export declare class Space {
     private options;
     private viewerStarted;
@@ -1046,6 +2304,615 @@ export declare class Space {
     }): Promise<string>;
 }
 
+declare const Space_2: IModelType<    {
+levels: IOptionalIType<IArrayType<IModelType<    {
+name: IOptionalIType<ISimpleType<string>, [undefined]>;
+initials: IOptionalIType<ISimpleType<string>, [undefined]>;
+autoInitials: IOptionalIType<ISimpleType<boolean>, [undefined]>;
+grounds: IOptionalIType<IArrayType<IModelType<    {
+id: IOptionalIType<ISimpleType<string>, [undefined]>;
+type: IOptionalIType<ISimpleType<"ground">, [undefined]>;
+name: IOptionalIType<ISimpleType<string>, [undefined]>;
+options: IOptionalIType<IModelType<    {
+type: IOptionalIType<ISimpleType<"normal" | "shell" | "norender">, [undefined]>;
+baseHeight: IMaybe<ISimpleType<number>>;
+thickness: IMaybe<ISimpleType<number>>;
+contour: IMaybe<ISimpleType<number>>;
+style: IOptionalIType<ISimpleType<string>, [undefined]>;
+external: IOptionalIType<ISimpleType<boolean>, [undefined]>;
+}, {
+setType(type: "normal" | "shell" | "norender"): void;
+setBaseHeight(baseHeight: number): void;
+setThickness(thickness: number): void;
+setContour(contour: number): void;
+setStyle(style: string): void;
+setExternal(external: boolean): void;
+}, _NotCustomized, _NotCustomized>, [undefined]>;
+segments: IArrayType<IModelType<    {
+start: IModelType<    {
+r: ISimpleType<number>;
+t: ISimpleType<number>;
+} & {
+id: IOptionalIType<ISimpleType<string>, [undefined]>;
+}, {
+regenerateId(randomizer: string): void;
+}, _NotCustomized, _NotCustomized>;
+end: IModelType<    {
+r: ISimpleType<number>;
+t: ISimpleType<number>;
+} & {
+id: IOptionalIType<ISimpleType<string>, [undefined]>;
+}, {
+regenerateId(randomizer: string): void;
+}, _NotCustomized, _NotCustomized>;
+}, {
+readonly centerPoint: SOCanvasPoint;
+} & {
+regenerateIds(randomizer: string): void;
+}, _NotCustomized, _NotCustomized>>;
+holes: IArrayType<IModelType<    {
+id: IOptionalIType<ISimpleType<string>, [undefined]>;
+type: IOptionalIType<ISimpleType<"hole">, [undefined]>;
+name: IOptionalIType<ISimpleType<string>, [undefined]>;
+segments: IArrayType<IModelType<    {
+start: IModelType<    {
+r: ISimpleType<number>;
+t: ISimpleType<number>;
+} & {
+id: IOptionalIType<ISimpleType<string>, [undefined]>;
+}, {
+regenerateId(randomizer: string): void;
+}, _NotCustomized, _NotCustomized>;
+end: IModelType<    {
+r: ISimpleType<number>;
+t: ISimpleType<number>;
+} & {
+id: IOptionalIType<ISimpleType<string>, [undefined]>;
+}, {
+regenerateId(randomizer: string): void;
+}, _NotCustomized, _NotCustomized>;
+}, {
+readonly centerPoint: SOCanvasPoint;
+} & {
+regenerateIds(randomizer: string): void;
+}, _NotCustomized, _NotCustomized>>;
+}, {
+getGround(): IGround;
+} & {
+newInParent(): void;
+removeInParent(): void;
+clearInEditor(id: string): void;
+regenerateIds(randomizer: string): void;
+} & {
+rename(name: string): void;
+} & {
+readonly points: SOCanvasPoint[];
+readonly geometry: SegmentGeometry;
+} & {
+addPoint({ r, t }: SICanvasPoint): void;
+addPointAfter({ pointId }: {
+pointId: string;
+}): void;
+close(): void;
+removePoint(id: string): void;
+} & {
+movePoint(id: string, { r, t }: SICanvasPoint): void;
+}, _NotCustomized, _NotCustomized>>;
+}, {
+newInParent(): void;
+removeInParent(): void;
+clearInEditor(id: string): void;
+regenerateIds(randomizer: string): void;
+} & {
+rename(name: string): void;
+addHole(hole?: (Omit<SIHole, "segments"> & {
+segments: SOGroundSegment[];
+}) | undefined): void;
+removeHole(holeId: string): void;
+replaceSegments(segments: SIGroundSegment[]): void;
+} & {
+readonly points: SOCanvasPoint[];
+readonly geometry: SegmentGeometry;
+} & {
+addPoint({ r, t }: SICanvasPoint): void;
+addPointAfter({ pointId }: {
+pointId: string;
+}): void;
+close(): void;
+removePoint(id: string): void;
+} & {
+movePoint(id: string, { r, t }: SICanvasPoint): void;
+}, _NotCustomized, _NotCustomized>>, [undefined]>;
+walls: IOptionalIType<IArrayType<IModelType<    {
+id: IOptionalIType<ISimpleType<string>, [undefined]>;
+type: IOptionalIType<ISimpleType<"wall">, [undefined]>;
+name: IOptionalIType<ISimpleType<string>, [undefined]>;
+options: IOptionalIType<IModelType<    {
+type: IOptionalIType<ISimpleType<"normal" | "shell" | "norender" | "structural">, [undefined]>;
+cap: IOptionalIType<ISimpleType<"flat" | "round">, [undefined]>;
+height: IMaybe<ISimpleType<number>>;
+thickness: IMaybe<ISimpleType<number>>;
+autoFacade: IOptionalIType<ISimpleType<boolean>, [undefined]>;
+partOfFacade: IOptionalIType<ISimpleType<boolean>, [undefined]>;
+}, {
+setType(type: "normal" | "shell" | "norender" | "structural"): void;
+setCap(cap: "flat" | "round"): void;
+setHeight(height: number): void;
+setThickness(thickness: number): void;
+setAutoFacade(autoFacade: boolean): void;
+setPartOfFacade(partOfFacade: boolean): void;
+}, _NotCustomized, _NotCustomized>, [undefined]>;
+segments: IArrayType<IModelType<    {
+start: IModelType<    {
+r: ISimpleType<number>;
+t: ISimpleType<number>;
+} & {
+id: IOptionalIType<ISimpleType<string>, [undefined]>;
+}, {
+regenerateId(randomizer: string): void;
+}, _NotCustomized, _NotCustomized>;
+end: IModelType<    {
+r: ISimpleType<number>;
+t: ISimpleType<number>;
+} & {
+id: IOptionalIType<ISimpleType<string>, [undefined]>;
+}, {
+regenerateId(randomizer: string): void;
+}, _NotCustomized, _NotCustomized>;
+} & {
+id: IOptionalIType<ISimpleType<string>, [undefined]>;
+openings: IArrayType<IModelType<    {
+id: IOptionalIType<ISimpleType<string>, [undefined]>;
+name: IOptionalIType<ISimpleType<string>, [undefined]>;
+type: ISimpleType<"door" | "window">;
+dimensions: IOptionalIType<IModelType<    {
+width: IMaybe<ISimpleType<number>>;
+height: IMaybe<ISimpleType<number>>;
+baseHeight: IMaybe<ISimpleType<number>>;
+}, {}, _NotCustomized, _NotCustomized>, [undefined]>;
+position: IMaybe<IModelType<    {
+from: ISimpleType<"start" | "end">;
+distance: ISimpleType<number>;
+}, {}, _NotCustomized, _NotCustomized>>;
+options: IOptionalIType<IModelType<    {
+style: IOptionalIType<ISimpleType<string>, [undefined]>;
+nbOfPanels: IOptionalIType<ISimpleType<number>, [undefined]>;
+nbOfPanelsVertically: IOptionalIType<ISimpleType<number>, [undefined]>;
+twoPanels: IOptionalIType<ISimpleType<boolean>, [undefined]>;
+centerSplit: IOptionalIType<ISimpleType<boolean>, [undefined]>;
+swapKnob: IOptionalIType<ISimpleType<boolean>, [undefined]>;
+swapInOut: IOptionalIType<ISimpleType<boolean>, [undefined]>;
+swapPanels: IOptionalIType<ISimpleType<boolean>, [undefined]>;
+glass: IOptionalIType<ISimpleType<boolean>, [undefined]>;
+openFrom: IOptionalIType<ISimpleType<string>, [undefined]>;
+panelsOpened: IOptionalIType<ISimpleType<number>, [undefined]>;
+openAngle: IOptionalIType<ISimpleType<number>, [undefined]>;
+railingHeight: IMaybe<ISimpleType<number>>;
+railingStyle: IOptionalIType<ISimpleType<string>, [undefined]>;
+}, {
+setStyle(style: string): void;
+setNbOfPanels(nbOfPanels: number): void;
+setNbOfPanelsVertically(nbOfPanelsVertically: number): void;
+setCenterSplit(centerSplit: boolean): void;
+setSwapKnob(swapKnob: boolean): void;
+setSwapInOut(swapInOut: boolean): void;
+setSwapPanels(swapPanels: boolean): void;
+setTwoPanels(twoPanels: boolean): void;
+setGlass(glass: boolean): void;
+setOpenFrom(openFrom: string): void;
+setPanelsOpened(panelsOpened: number): void;
+setOpenAngle(openAngle: number): void;
+setRailingHeight(railingHeight: number): void;
+setRailingStyle(railingStyle: string): void;
+}, _NotCustomized, _NotCustomized>, [undefined]>;
+}, {
+readonly segment: IWallSegment;
+} & {
+readonly feature: IWall;
+readonly direction: number;
+} & {
+readonly orientation: "horizontal" | "vertical";
+} & {
+verifyOpeningPosition(): void;
+regenerateId(randomizer: string): void;
+} & {
+rename(name: string): void;
+resize(dimensions: Partial<SIWallOpeningDimensions>): void;
+moveTo(position: SIWallOpeningPosition): void;
+moveInDirection(direction: URDL, distance?: number): void;
+remove(): void;
+}, _NotCustomized, _NotCustomized>>;
+}, {
+readonly centerPoint: SOCanvasPoint;
+} & {
+readonly centerPoint: SOCanvasPoint;
+} & {
+addOpening(opening: SIWallOpening): void;
+removeOpening(id: string): void;
+regenerateIds(randomizer: string): void;
+}, _NotCustomized, _NotCustomized>>;
+}, {
+newInParent(): void;
+removeInParent(): void;
+clearInEditor(id: string): void;
+regenerateIds(randomizer: string): void;
+} & {
+rename(name: string): void;
+} & {
+readonly points: SOCanvasPoint[];
+readonly geometry: SegmentGeometry;
+} & {
+addPoint({ r, t }: SICanvasPoint): void;
+addPointAfter({ pointId }: {
+pointId: string;
+}): void;
+close(): void;
+removePoint(id: string): void;
+} & {
+movePoint(id: string, { r, t }: SICanvasPoint): void;
+}, _NotCustomized, _NotCustomized>>, [undefined]>;
+roofs: IOptionalIType<IArrayType<IModelType<    {
+id: IOptionalIType<ISimpleType<string>, [undefined]>;
+type: IOptionalIType<ISimpleType<"roof">, [undefined]>;
+name: IOptionalIType<ISimpleType<string>, [undefined]>;
+options: IOptionalIType<IModelType<    {
+baseHeight: IMaybe<ISimpleType<number>>;
+topHeight: IMaybe<ISimpleType<number>>;
+angle: IMaybe<ISimpleType<number>>;
+}, {
+setBaseHeight(baseHeight: number): void;
+setTopHeight(topHeight: number): void;
+setAngle(angle: number): void;
+}, _NotCustomized, _NotCustomized>, [undefined]>;
+segments: IArrayType<IModelType<    {
+start: IModelType<    {
+r: ISimpleType<number>;
+t: ISimpleType<number>;
+} & {
+id: IOptionalIType<ISimpleType<string>, [undefined]>;
+}, {
+regenerateId(randomizer: string): void;
+}, _NotCustomized, _NotCustomized>;
+end: IModelType<    {
+r: ISimpleType<number>;
+t: ISimpleType<number>;
+} & {
+id: IOptionalIType<ISimpleType<string>, [undefined]>;
+}, {
+regenerateId(randomizer: string): void;
+}, _NotCustomized, _NotCustomized>;
+} & {
+id: IOptionalIType<ISimpleType<string>, [undefined]>;
+base: IOptionalIType<ISimpleType<boolean>, [undefined]>;
+}, {
+readonly centerPoint: SOCanvasPoint;
+} & {
+regenerateIds(randomizer: string): void;
+}, _NotCustomized, _NotCustomized>>;
+}, {
+newInParent(): void;
+removeInParent(): void;
+clearInEditor(id: string): void;
+regenerateIds(randomizer: string): void;
+} & {
+rename(name: string): void;
+setBaseSegmentById(id: string): void;
+} & {
+readonly points: SOCanvasPoint[];
+readonly geometry: SegmentGeometry;
+} & {
+addPoint({ r, t }: SICanvasPoint): void;
+addPointAfter({ pointId }: {
+pointId: string;
+}): void;
+close(): void;
+removePoint(id: string): void;
+} & {
+movePoint(id: string, { r, t }: SICanvasPoint): void;
+}, _NotCustomized, _NotCustomized>>, [undefined]>;
+stairs: IArrayType<IModelType<    {
+id: IOptionalIType<ISimpleType<string>, [undefined]>;
+name: IOptionalIType<ISimpleType<string>, [undefined]>;
+bottomSegment: IArrayType<IModelType<    {
+r: ISimpleType<number>;
+t: ISimpleType<number>;
+} & {
+id: IOptionalIType<ISimpleType<string>, [undefined]>;
+}, {
+regenerateId(randomizer: string): void;
+}, _NotCustomized, _NotCustomized>>;
+topSegment: IArrayType<IModelType<    {
+r: ISimpleType<number>;
+t: ISimpleType<number>;
+} & {
+id: IOptionalIType<ISimpleType<string>, [undefined]>;
+}, {
+regenerateId(randomizer: string): void;
+}, _NotCustomized, _NotCustomized>>;
+baseHeight: IMaybe<ISimpleType<number>>;
+height: IMaybe<ISimpleType<number>>;
+style: IOptionalIType<ISimpleType<"slope" | "thin" | "thick" | "block">, [undefined]>;
+}, {
+rename(name: string): void;
+setBaseHeight(baseHeight: number): void;
+setHeight(height: number): void;
+setStyle(style: "slope" | "thin" | "thick" | "block"): void;
+moveBy({ dr, dt }: {
+dr: number;
+dt: number;
+}): void;
+remove(): void;
+regenerateIds(randomizer: string): void;
+}, _NotCustomized, _NotCustomized>>;
+annotations: IArrayType<IModelType<    {
+id: IOptionalIType<ISimpleType<string>, [undefined]>;
+type: IOptionalIType<ISimpleType<AnnotationType>, [undefined]>;
+name: IOptionalIType<ISimpleType<string>, [undefined]>;
+r: IOptionalIType<ISimpleType<number>, [undefined]>;
+t: IOptionalIType<ISimpleType<number>, [undefined]>;
+height: IMaybe<ISimpleType<number>>;
+size: IMaybe<ISimpleType<number>>;
+media: IMaybe<ISimpleType<string>>;
+is360: IOptionalIType<ISimpleType<boolean>, [undefined]>;
+direction: IMaybe<ISimpleType<number>>;
+}, {
+setType(type: AnnotationType): void;
+rename(name: string): void;
+moveTo({ r, t }: CanvasCoord): void;
+setHeight(height: number): void;
+setSize(size: number): void;
+remove(): void;
+setMedia(url: string | undefined): void;
+setIs360(is360: boolean): void;
+setDirection(angle: number | undefined): void;
+regenerateId(randomizer: string): void;
+}, _NotCustomized, _NotCustomized>>;
+objects: IArrayType<IModelType<    {
+catalogId: ISimpleType<string>;
+id: IOptionalIType<ISimpleType<string>, [undefined]>;
+name: IOptionalIType<ISimpleType<string>, [undefined]>;
+levelIndex: IOptionalIType<ISimpleType<number>, [undefined]>;
+position: IOptionalIType<IModelType<    {
+x: ISimpleType<number>;
+z: ISimpleType<number>;
+} & {
+elevation: ISimpleType<number>;
+}, {}, _NotCustomized, _NotCustomized>, [undefined]>;
+rotation: IOptionalIType<IModelType<    {
+pitch: IOptionalIType<ISimpleType<number>, [undefined]>;
+yaw: IOptionalIType<ISimpleType<number>, [undefined]>;
+roll: IOptionalIType<ISimpleType<number>, [undefined]>;
+}, {}, _NotCustomized, _NotCustomized>, [undefined]>;
+dimensions: IOptionalIType<IModelType<    {
+length: IMaybe<ISimpleType<number>>;
+width: IMaybe<ISimpleType<number>>;
+height: IMaybe<ISimpleType<number>>;
+}, {
+readonly safeValues: {
+length: number;
+width: number;
+height: number;
+};
+}, _NotCustomized, _NotCustomized>, [undefined]>;
+configuration: IMaybe<IType<Partial<ParametricObjectConfiguration>, Partial<ParametricObjectConfiguration>, Partial<ParametricObjectConfiguration>>>;
+external: IOptionalIType<ISimpleType<boolean>, [undefined]>;
+}, {
+rename(name: string): void;
+moveTo(position: Partial<SILevelCoord3d>): void;
+setLevelIndex(levelIndex: number): void;
+resize(dimensions: Partial<SIObjectDimensions>): void;
+rotate(rotation: Partial<SIObjectRotation>): void;
+configure(configurationChanges: Partial<ParametricObjectConfiguration>): void;
+remove(): void;
+regenerateId(randomizer: string): void;
+setExternal(external: boolean): void;
+}, _NotCustomized, _NotCustomized>>;
+floorplan: IOptionalIType<IModelType<    {
+url: IMaybe<ISimpleType<string>>;
+data: IMaybe<ISimpleType<string>>;
+r: IOptionalIType<ISimpleType<number>, [undefined]>;
+t: IOptionalIType<ISimpleType<number>, [undefined]>;
+scale: IOptionalIType<ISimpleType<number>, [undefined]>;
+flipped: IOptionalIType<ISimpleType<boolean>, [undefined]>;
+}, {
+isNil(): boolean;
+} & {
+setUrl(url: string): void;
+setData(data: string | undefined): void;
+moveTo({ r, t }: CanvasCoord): void;
+setScale(scale: number): void;
+setFlipped(flipped: boolean): void;
+remove(): void;
+} & {
+rescaleByFactor(factor: number, imageOnly?: boolean): void;
+}, _NotCustomized, _NotCustomized>, [undefined]>;
+}, {
+readonly hash: string;
+readonly points: ICanvasPoint[];
+} & {
+readonly boundingBox: CanvasBoundingBox | null;
+readonly centerPoint: CanvasCoord | null;
+readonly autoGroundHash: string;
+getHash({ only, ignore }: {
+only: any;
+ignore: any;
+}): string;
+readonly isEmpty: boolean;
+readonly openings: IWallOpening[];
+} & {
+readonly doors: IWallOpening[];
+readonly windows: IWallOpening[];
+readonly initialsFromName: string;
+} & {
+rename(name: string): void;
+setInitials(initials: string): void;
+setAutoInitials(enabled: boolean): void;
+newGround(ground?: (Omit<SIGround, "segments"> & {
+segments: SOGroundSegment[];
+}) | undefined, forceId?: string | undefined): void;
+removeGround(id: string): void;
+removeAllGrounds(): void;
+newWall(wall?: (Omit<SIWall, "segments"> & {
+segments: SOAbstractSegment[] | SOWallSegment[];
+}) | undefined): void;
+removeWall(id: string): void;
+removeAllWalls(): void;
+newRoof(): void;
+removeRoof(id: string): void;
+removeAllRoofs(): void;
+addStairs(stairs?: SIStair | undefined): void;
+removeStairs(id: string): void;
+removeAllStairs(): void;
+addAnnotation(annotation: SIAnnotation): void;
+removeAnnotation(id: string): void;
+removeAllAnnotations(): void;
+addObject(object: SIObject): void;
+removeObject(id: string): void;
+removeAllObjects(): void;
+setObjectsLevelIndex(levelIndex: number): void;
+updateObjectsLevelIndex(updater: (levelIndex: number) => number): void;
+regenerateIds(randomizer: string): void;
+} & {
+addObjects(objects: SIObject[]): void;
+clear(): void;
+}, _NotCustomized, _NotCustomized>>, [undefined]>;
+camerasEnabled: IOptionalIType<IArrayType<ISimpleType<SmplrCameraType>>, [undefined]>;
+compassDirection: IMaybe<ISimpleType<number>>;
+facade: IMaybe<IModelType<    {
+url: ISimpleType<string>;
+levelIndex: IOptionalIType<ISimpleType<number>, [undefined]>;
+position: IOptionalIType<IModelType<    {
+x: ISimpleType<number>;
+z: ISimpleType<number>;
+} & {
+elevation: ISimpleType<number>;
+}, {}, _NotCustomized, _NotCustomized>, [undefined]>;
+rotation: IOptionalIType<IModelType<    {
+pitch: IOptionalIType<ISimpleType<number>, [undefined]>;
+yaw: IOptionalIType<ISimpleType<number>, [undefined]>;
+roll: IOptionalIType<ISimpleType<number>, [undefined]>;
+}, {}, _NotCustomized, _NotCustomized>, [undefined]>;
+dimensions: IOptionalIType<IModelType<    {
+length: IMaybe<ISimpleType<number>>;
+width: IMaybe<ISimpleType<number>>;
+height: IMaybe<ISimpleType<number>>;
+}, {
+readonly safeValues: {
+length: number;
+width: number;
+height: number;
+};
+}, _NotCustomized, _NotCustomized>, [undefined]>;
+}, {}, _NotCustomized, _NotCustomized>>;
+defaults: IOptionalIType<IModelType<    {
+unit: IOptionalIType<ISimpleType<string>, [undefined]>;
+groundThickness: IOptionalIType<ISimpleType<number>, [undefined]>;
+wallHeight: IOptionalIType<ISimpleType<number>, [undefined]>;
+wallThickness: IOptionalIType<ISimpleType<number>, [undefined]>;
+roofBaseHeight: IOptionalIType<ISimpleType<number>, [undefined]>;
+roofTopHeight: IOptionalIType<ISimpleType<number>, [undefined]>;
+roofAngle: IOptionalIType<ISimpleType<number>, [undefined]>;
+doorWidth: IOptionalIType<ISimpleType<number>, [undefined]>;
+doorHeight: IOptionalIType<ISimpleType<number>, [undefined]>;
+doorBaseHeight: IOptionalIType<ISimpleType<number>, [undefined]>;
+windowWidth: IOptionalIType<ISimpleType<number>, [undefined]>;
+windowHeight: IOptionalIType<ISimpleType<number>, [undefined]>;
+windowBaseHeight: IOptionalIType<ISimpleType<number>, [undefined]>;
+railingHeight: IOptionalIType<ISimpleType<number>, [undefined]>;
+stairsStepSize: IOptionalIType<ISimpleType<number>, [undefined]>;
+annotationHeight: IOptionalIType<ISimpleType<number>, [undefined]>;
+annotationSize: IOptionalIType<ISimpleType<number>, [undefined]>;
+}, {
+setUnit(unit: string): void;
+setGroundThickness(groundThickness: number): void;
+setWallHeight(wallHeight: number): void;
+setWallThickness(wallThickness: number): void;
+setRoofBaseHeight(roofBaseHeight: number): void;
+setRoofTopHeight(roofTopHeight: number): void;
+setRoofAngle(roofAngle: number): void;
+setDoorWidth(doorWidth: number): void;
+setDoorHeight(doorHeight: number): void;
+setDoorBaseHeight(doorBaseHeight: number): void;
+setWindowWidth(windowWidth: number): void;
+setWindowHeight(windowHeight: number): void;
+setWindowBaseHeight(windowBaseHeight: number): void;
+setRailingHeight(railingHeight: number): void;
+setStairsStepSize(stairsStepSize: number): void;
+setAnnotationHeight(annotationHeight: number): void;
+setAnnotationSize(annotationSize: number): void;
+}, _NotCustomized, _NotCustomized>, [undefined]>;
+}, {
+readonly hash: string;
+} & {
+getHash({ only, ignore }: {
+only?: string[] | undefined;
+ignore?: string[] | undefined;
+}): string;
+readonly isEmpty: boolean;
+readonly grounds: IGround[];
+readonly walls: IWall[];
+readonly roofs: IRoof[];
+readonly stairs: IStair[];
+readonly objects: IObject[];
+readonly openings: IWallOpening[];
+readonly doors: IWallOpening[];
+readonly windows: IWallOpening[];
+readonly annotations: IAnnotation[];
+} & {
+addLevel(): void;
+clearLevel(levelIndex: number): void;
+removeLevel(levelIndex: number): void;
+setLevels(levels: SILevel[]): void;
+setCompassDirection(direction: number): void;
+regenerateIdsForLevel(levelIndex: number): void;
+} & {
+flip(): void;
+duplicateLevel(levelIndex: number): void;
+}, _NotCustomized, _NotCustomized>;
+
+declare const SpaceDefaults: IModelType<    {
+unit: IOptionalIType<ISimpleType<string>, [undefined]>;
+groundThickness: IOptionalIType<ISimpleType<number>, [undefined]>;
+wallHeight: IOptionalIType<ISimpleType<number>, [undefined]>;
+wallThickness: IOptionalIType<ISimpleType<number>, [undefined]>;
+roofBaseHeight: IOptionalIType<ISimpleType<number>, [undefined]>;
+roofTopHeight: IOptionalIType<ISimpleType<number>, [undefined]>;
+roofAngle: IOptionalIType<ISimpleType<number>, [undefined]>;
+doorWidth: IOptionalIType<ISimpleType<number>, [undefined]>;
+doorHeight: IOptionalIType<ISimpleType<number>, [undefined]>;
+doorBaseHeight: IOptionalIType<ISimpleType<number>, [undefined]>;
+windowWidth: IOptionalIType<ISimpleType<number>, [undefined]>;
+windowHeight: IOptionalIType<ISimpleType<number>, [undefined]>;
+windowBaseHeight: IOptionalIType<ISimpleType<number>, [undefined]>;
+railingHeight: IOptionalIType<ISimpleType<number>, [undefined]>;
+stairsStepSize: IOptionalIType<ISimpleType<number>, [undefined]>;
+annotationHeight: IOptionalIType<ISimpleType<number>, [undefined]>;
+annotationSize: IOptionalIType<ISimpleType<number>, [undefined]>;
+}, {
+setUnit(unit: string): void;
+setGroundThickness(groundThickness: number): void;
+setWallHeight(wallHeight: number): void;
+setWallThickness(wallThickness: number): void;
+setRoofBaseHeight(roofBaseHeight: number): void;
+setRoofTopHeight(roofTopHeight: number): void;
+setRoofAngle(roofAngle: number): void;
+setDoorWidth(doorWidth: number): void;
+setDoorHeight(doorHeight: number): void;
+setDoorBaseHeight(doorBaseHeight: number): void;
+setWindowWidth(windowWidth: number): void;
+setWindowHeight(windowHeight: number): void;
+setWindowBaseHeight(windowBaseHeight: number): void;
+setRailingHeight(railingHeight: number): void;
+setStairsStepSize(stairsStepSize: number): void;
+setAnnotationHeight(annotationHeight: number): void;
+setAnnotationSize(annotationSize: number): void;
+}, _NotCustomized, _NotCustomized>;
+
+export declare type SpaceNoData = NoData & {
+    id: string;
+    spaceId: SpaceSid;
+};
+
 export declare type SpaceOptions = {
     spaceId: string;
     spaceDefinition?: object;
@@ -1060,6 +2927,10 @@ export declare type SpaceOptions = {
     container: HTMLElement;
 });
 
+declare type SpacePrefix = typeof spacePrefix;
+
+declare const spacePrefix: "spc_";
+
 export declare interface SpaceRenderOptions {
     compass?: boolean
     annotations?: boolean
@@ -1087,6 +2958,8 @@ export declare interface SpaceRenderOptions {
     }
 }
 
+declare type SpaceSid = `${SpacePrefix}${string}`;
+
 export declare interface SpaceViewerOptions {
     mode?: CameraMode;
     preview?: boolean;
@@ -1123,6 +2996,80 @@ declare interface SphereOptions<D> {
     });
 }
 
+declare const Stair: IModelType<    {
+id: IOptionalIType<ISimpleType<string>, [undefined]>;
+name: IOptionalIType<ISimpleType<string>, [undefined]>;
+bottomSegment: IArrayType<IModelType<    {
+r: ISimpleType<number>;
+t: ISimpleType<number>;
+} & {
+id: IOptionalIType<ISimpleType<string>, [undefined]>;
+}, {
+regenerateId(randomizer: string): void;
+}, _NotCustomized, _NotCustomized>>;
+topSegment: IArrayType<IModelType<    {
+r: ISimpleType<number>;
+t: ISimpleType<number>;
+} & {
+id: IOptionalIType<ISimpleType<string>, [undefined]>;
+}, {
+regenerateId(randomizer: string): void;
+}, _NotCustomized, _NotCustomized>>;
+baseHeight: IMaybe<ISimpleType<number>>;
+height: IMaybe<ISimpleType<number>>;
+style: IOptionalIType<ISimpleType<Style>, [undefined]>;
+}, {
+rename(name: string): void;
+setBaseHeight(baseHeight: number): void;
+setHeight(height: number): void;
+setStyle(style: Style): void;
+moveBy({ dr, dt }: {
+dr: number;
+dt: number;
+}): void;
+remove(): void;
+regenerateIds(randomizer: string): void;
+}, _NotCustomized, _NotCustomized>;
+
+declare type Style = 'slope' | 'thin' | 'thick' | 'block';
+
+declare namespace table {
+    export {
+        key_6 as key,
+        TableShape,
+        TableConfiguration,
+        options_6 as options,
+        render3d_6 as render3d,
+        render2d_6 as render2d,
+        getNominalDimensions_6 as getNominalDimensions
+    }
+}
+
+declare namespace tableAndChairs {
+    export {
+        key_7 as key,
+        TableAndChairsConfiguration,
+        options_7 as options,
+        render3d_7 as render3d,
+        render2d_7 as render2d,
+        getNominalDimensions_7 as getNominalDimensions
+    }
+}
+
+declare type TableAndChairsConfiguration = {
+    shape: table.TableShape;
+    seat: chair.ChairStyle;
+    numberOfSeats: number;
+    seatsOnOneSide: boolean;
+    noEndSeat: boolean;
+};
+
+declare type TableConfiguration = {
+    shape: TableShape;
+};
+
+declare type TableShape = 'rectangle' | 'round';
+
 declare interface TakeScreenshotArgs {
     width?: number;
     height?: number;
@@ -1133,8 +3080,30 @@ declare interface TakeScreenshotArgs {
 declare const toString_2: () => string;
 export { toString_2 as toString }
 
+declare namespace triangularDesk {
+    export {
+        key_8 as key,
+        TriangularDeskConfiguration,
+        options_8 as options,
+        render3d_8 as render3d,
+        render2d_8 as render2d,
+        getNominalDimensions_8 as getNominalDimensions
+    }
+}
+
+declare type TriangularDeskConfiguration = {
+    seat: chair.ChairStyle | 'none';
+};
+
 export declare type UnknownData = Record<string, unknown>;
 
+export declare interface UnknownSpaceData extends UnknownData {
+    id: string;
+    spaceId: SpaceSid;
+}
+
+declare type URDL = 'up' | 'down' | 'right' | 'left';
+
 declare const useEventEmitter: () => {
     addListener: (listener: Listener) => number;
     removeListener: (listenerId: number) => void;
@@ -1155,6 +3124,11 @@ declare interface User extends Auth0UserWithClaims {
     emailVerified: boolean
 }
 
+export declare interface ValidGeojsonSpace extends GeojsonSpace {
+    definition: SOSpace;
+    georeference: Georeference;
+}
+
 declare interface Vector2Coord {
     x: number;
     y: number;
@@ -1164,7 +3138,7 @@ declare interface Vector3Coord extends Vector2Coord {
     z: number;
 }
 
-export declare const version = "2.31.0";
+export declare const version = "2.31.1-beta.1";
 
 declare interface ViewerRendererHandle {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -1198,6 +3172,203 @@ declare interface VrCamera extends VRDeviceOrientationFreeCamera {
     noSleep: NoSleep_2;
 }
 
+declare const Wall: IModelType<    {
+id: IOptionalIType<ISimpleType<string>, [undefined]>;
+type: IOptionalIType<ISimpleType<"wall">, [undefined]>;
+name: IOptionalIType<ISimpleType<string>, [undefined]>;
+options: IOptionalIType<IModelType<    {
+type: IOptionalIType<ISimpleType<"normal" | "shell" | "norender" | "structural">, [undefined]>;
+cap: IOptionalIType<ISimpleType<"flat" | "round">, [undefined]>;
+height: IMaybe<ISimpleType<number>>;
+thickness: IMaybe<ISimpleType<number>>;
+autoFacade: IOptionalIType<ISimpleType<boolean>, [undefined]>;
+partOfFacade: IOptionalIType<ISimpleType<boolean>, [undefined]>;
+}, {
+setType(type: "normal" | "shell" | "norender" | "structural"): void;
+setCap(cap: "flat" | "round"): void;
+setHeight(height: number): void;
+setThickness(thickness: number): void;
+setAutoFacade(autoFacade: boolean): void;
+setPartOfFacade(partOfFacade: boolean): void;
+}, _NotCustomized, _NotCustomized>, [undefined]>;
+segments: IArrayType<IModelType<    {
+start: IModelType<    {
+r: ISimpleType<number>;
+t: ISimpleType<number>;
+} & {
+id: IOptionalIType<ISimpleType<string>, [undefined]>;
+}, {
+regenerateId(randomizer: string): void;
+}, _NotCustomized, _NotCustomized>;
+end: IModelType<    {
+r: ISimpleType<number>;
+t: ISimpleType<number>;
+} & {
+id: IOptionalIType<ISimpleType<string>, [undefined]>;
+}, {
+regenerateId(randomizer: string): void;
+}, _NotCustomized, _NotCustomized>;
+} & {
+id: IOptionalIType<ISimpleType<string>, [undefined]>;
+openings: IArrayType<IModelType<    {
+id: IOptionalIType<ISimpleType<string>, [undefined]>;
+name: IOptionalIType<ISimpleType<string>, [undefined]>;
+type: ISimpleType<"door" | "window">;
+dimensions: IOptionalIType<IModelType<    {
+width: IMaybe<ISimpleType<number>>;
+height: IMaybe<ISimpleType<number>>;
+baseHeight: IMaybe<ISimpleType<number>>;
+}, {}, _NotCustomized, _NotCustomized>, [undefined]>;
+position: IMaybe<IModelType<    {
+from: ISimpleType<"start" | "end">;
+distance: ISimpleType<number>;
+}, {}, _NotCustomized, _NotCustomized>>;
+options: IOptionalIType<IModelType<    {
+style: IOptionalIType<ISimpleType<string>, [undefined]>;
+nbOfPanels: IOptionalIType<ISimpleType<number>, [undefined]>;
+nbOfPanelsVertically: IOptionalIType<ISimpleType<number>, [undefined]>;
+twoPanels: IOptionalIType<ISimpleType<boolean>, [undefined]>;
+centerSplit: IOptionalIType<ISimpleType<boolean>, [undefined]>;
+swapKnob: IOptionalIType<ISimpleType<boolean>, [undefined]>;
+swapInOut: IOptionalIType<ISimpleType<boolean>, [undefined]>;
+swapPanels: IOptionalIType<ISimpleType<boolean>, [undefined]>;
+glass: IOptionalIType<ISimpleType<boolean>, [undefined]>;
+openFrom: IOptionalIType<ISimpleType<string>, [undefined]>;
+panelsOpened: IOptionalIType<ISimpleType<number>, [undefined]>;
+openAngle: IOptionalIType<ISimpleType<number>, [undefined]>;
+railingHeight: IMaybe<ISimpleType<number>>;
+railingStyle: IOptionalIType<ISimpleType<string>, [undefined]>;
+}, {
+setStyle(style: string): void;
+setNbOfPanels(nbOfPanels: number): void;
+setNbOfPanelsVertically(nbOfPanelsVertically: number): void;
+setCenterSplit(centerSplit: boolean): void;
+setSwapKnob(swapKnob: boolean): void;
+setSwapInOut(swapInOut: boolean): void;
+setSwapPanels(swapPanels: boolean): void;
+setTwoPanels(twoPanels: boolean): void;
+setGlass(glass: boolean): void;
+setOpenFrom(openFrom: string): void;
+setPanelsOpened(panelsOpened: number): void;
+setOpenAngle(openAngle: number): void;
+setRailingHeight(railingHeight: number): void;
+setRailingStyle(railingStyle: string): void;
+}, _NotCustomized, _NotCustomized>, [undefined]>;
+}, {
+readonly segment: IWallSegment;
+} & {
+readonly feature: IWall;
+readonly direction: number;
+} & {
+readonly orientation: "horizontal" | "vertical";
+} & {
+verifyOpeningPosition(): void;
+regenerateId(randomizer: string): void;
+} & {
+rename(name: string): void;
+resize(dimensions: Partial<SIWallOpeningDimensions>): void;
+moveTo(position: SIWallOpeningPosition): void;
+moveInDirection(direction: URDL, distance?: number): void;
+remove(): void;
+}, _NotCustomized, _NotCustomized>>;
+}, {
+readonly centerPoint: SOCanvasPoint;
+} & {
+readonly centerPoint: SOCanvasPoint;
+} & {
+addOpening(opening: SIWallOpening): void;
+removeOpening(id: string): void;
+regenerateIds(randomizer: string): void;
+}, _NotCustomized, _NotCustomized>>;
+}, {
+newInParent(): void;
+removeInParent(): void;
+clearInEditor(id: string): void;
+regenerateIds(randomizer: string): void;
+} & {
+rename(name: string): void;
+} & {
+readonly points: SOCanvasPoint[];
+readonly geometry: SegmentGeometry;
+} & {
+addPoint({ r, t }: SICanvasPoint): void;
+addPointAfter({ pointId }: {
+pointId: string;
+}): void;
+close(): void;
+removePoint(id: string): void;
+} & {
+movePoint(id: string, { r, t }: SICanvasPoint): void;
+}, _NotCustomized, _NotCustomized>;
+
+declare const WallOpening: IModelType<    {
+id: IOptionalIType<ISimpleType<string>, [undefined]>;
+name: IOptionalIType<ISimpleType<string>, [undefined]>;
+type: ISimpleType<"door" | "window">;
+dimensions: IOptionalIType<IModelType<    {
+width: IMaybe<ISimpleType<number>>;
+height: IMaybe<ISimpleType<number>>;
+baseHeight: IMaybe<ISimpleType<number>>;
+}, {}, _NotCustomized, _NotCustomized>, [undefined]>;
+position: IMaybe<IModelType<    {
+from: ISimpleType<"start" | "end">;
+distance: ISimpleType<number>;
+}, {}, _NotCustomized, _NotCustomized>>;
+options: IOptionalIType<IModelType<    {
+style: IOptionalIType<ISimpleType<string>, [undefined]>;
+nbOfPanels: IOptionalIType<ISimpleType<number>, [undefined]>;
+nbOfPanelsVertically: IOptionalIType<ISimpleType<number>, [undefined]>;
+twoPanels: IOptionalIType<ISimpleType<boolean>, [undefined]>;
+centerSplit: IOptionalIType<ISimpleType<boolean>, [undefined]>;
+swapKnob: IOptionalIType<ISimpleType<boolean>, [undefined]>;
+swapInOut: IOptionalIType<ISimpleType<boolean>, [undefined]>;
+swapPanels: IOptionalIType<ISimpleType<boolean>, [undefined]>;
+glass: IOptionalIType<ISimpleType<boolean>, [undefined]>;
+openFrom: IOptionalIType<ISimpleType<string>, [undefined]>;
+panelsOpened: IOptionalIType<ISimpleType<number>, [undefined]>;
+openAngle: IOptionalIType<ISimpleType<number>, [undefined]>;
+railingHeight: IMaybe<ISimpleType<number>>;
+railingStyle: IOptionalIType<ISimpleType<string>, [undefined]>;
+}, {
+setStyle(style: string): void;
+setNbOfPanels(nbOfPanels: number): void;
+setNbOfPanelsVertically(nbOfPanelsVertically: number): void;
+setCenterSplit(centerSplit: boolean): void;
+setSwapKnob(swapKnob: boolean): void;
+setSwapInOut(swapInOut: boolean): void;
+setSwapPanels(swapPanels: boolean): void;
+setTwoPanels(twoPanels: boolean): void;
+setGlass(glass: boolean): void;
+setOpenFrom(openFrom: string): void;
+setPanelsOpened(panelsOpened: number): void;
+setOpenAngle(openAngle: number): void;
+setRailingHeight(railingHeight: number): void;
+setRailingStyle(railingStyle: string): void;
+}, _NotCustomized, _NotCustomized>, [undefined]>;
+}, {
+readonly segment: IWallSegment;
+} & {
+readonly feature: IWall;
+readonly direction: number;
+} & {
+readonly orientation: "horizontal" | "vertical";
+} & {
+verifyOpeningPosition(): void;
+regenerateId(randomizer: string): void;
+} & {
+rename(name: string): void;
+resize(dimensions: Partial<SIWallOpeningDimensions>): void;
+moveTo(position: SIWallOpeningPosition): void;
+moveInDirection(direction: URDL, distance?: number): void;
+remove(): void;
+}, _NotCustomized, _NotCustomized>;
+
+declare const WallOpeningDimensions: IModelType<    {
+width: IMaybe<ISimpleType<number>>;
+height: IMaybe<ISimpleType<number>>;
+baseHeight: IMaybe<ISimpleType<number>>;
+}, {}, _NotCustomized, _NotCustomized>;
+
 declare const WallOpeningOptions: IModelType<    {
 style: IOptionalIType<ISimpleType<string>, [undefined]>;
 nbOfPanels: IOptionalIType<ISimpleType<number>, [undefined]>;
@@ -1230,4 +3401,99 @@ setRailingHeight(railingHeight: number): void;
 setRailingStyle(railingStyle: string): void;
 }, _NotCustomized, _NotCustomized>;
 
+declare const WallOpeningPosition: IModelType<    {
+from: ISimpleType<"start" | "end">;
+distance: ISimpleType<number>;
+}, {}, _NotCustomized, _NotCustomized>;
+
+declare const WallSegment: IModelType<    {
+start: IModelType<    {
+r: ISimpleType<number>;
+t: ISimpleType<number>;
+} & {
+id: IOptionalIType<ISimpleType<string>, [undefined]>;
+}, {
+regenerateId(randomizer: string): void;
+}, _NotCustomized, _NotCustomized>;
+end: IModelType<    {
+r: ISimpleType<number>;
+t: ISimpleType<number>;
+} & {
+id: IOptionalIType<ISimpleType<string>, [undefined]>;
+}, {
+regenerateId(randomizer: string): void;
+}, _NotCustomized, _NotCustomized>;
+} & {
+id: IOptionalIType<ISimpleType<string>, [undefined]>;
+openings: IArrayType<IModelType<    {
+id: IOptionalIType<ISimpleType<string>, [undefined]>;
+name: IOptionalIType<ISimpleType<string>, [undefined]>;
+type: ISimpleType<"door" | "window">;
+dimensions: IOptionalIType<IModelType<    {
+width: IMaybe<ISimpleType<number>>;
+height: IMaybe<ISimpleType<number>>;
+baseHeight: IMaybe<ISimpleType<number>>;
+}, {}, _NotCustomized, _NotCustomized>, [undefined]>;
+position: IMaybe<IModelType<    {
+from: ISimpleType<"start" | "end">;
+distance: ISimpleType<number>;
+}, {}, _NotCustomized, _NotCustomized>>;
+options: IOptionalIType<IModelType<    {
+style: IOptionalIType<ISimpleType<string>, [undefined]>;
+nbOfPanels: IOptionalIType<ISimpleType<number>, [undefined]>;
+nbOfPanelsVertically: IOptionalIType<ISimpleType<number>, [undefined]>;
+twoPanels: IOptionalIType<ISimpleType<boolean>, [undefined]>;
+centerSplit: IOptionalIType<ISimpleType<boolean>, [undefined]>;
+swapKnob: IOptionalIType<ISimpleType<boolean>, [undefined]>;
+swapInOut: IOptionalIType<ISimpleType<boolean>, [undefined]>;
+swapPanels: IOptionalIType<ISimpleType<boolean>, [undefined]>;
+glass: IOptionalIType<ISimpleType<boolean>, [undefined]>;
+openFrom: IOptionalIType<ISimpleType<string>, [undefined]>;
+panelsOpened: IOptionalIType<ISimpleType<number>, [undefined]>;
+openAngle: IOptionalIType<ISimpleType<number>, [undefined]>;
+railingHeight: IMaybe<ISimpleType<number>>;
+railingStyle: IOptionalIType<ISimpleType<string>, [undefined]>;
+}, {
+setStyle(style: string): void;
+setNbOfPanels(nbOfPanels: number): void;
+setNbOfPanelsVertically(nbOfPanelsVertically: number): void;
+setCenterSplit(centerSplit: boolean): void;
+setSwapKnob(swapKnob: boolean): void;
+setSwapInOut(swapInOut: boolean): void;
+setSwapPanels(swapPanels: boolean): void;
+setTwoPanels(twoPanels: boolean): void;
+setGlass(glass: boolean): void;
+setOpenFrom(openFrom: string): void;
+setPanelsOpened(panelsOpened: number): void;
+setOpenAngle(openAngle: number): void;
+setRailingHeight(railingHeight: number): void;
+setRailingStyle(railingStyle: string): void;
+}, _NotCustomized, _NotCustomized>, [undefined]>;
+}, {
+readonly segment: IWallSegment;
+} & {
+readonly feature: IWall;
+readonly direction: number;
+} & {
+readonly orientation: "horizontal" | "vertical";
+} & {
+verifyOpeningPosition(): void;
+regenerateId(randomizer: string): void;
+} & {
+rename(name: string): void;
+resize(dimensions: Partial<SIWallOpeningDimensions>): void;
+moveTo(position: SIWallOpeningPosition): void;
+moveInDirection(direction: URDL, distance?: number): void;
+remove(): void;
+}, _NotCustomized, _NotCustomized>>;
+}, {
+readonly centerPoint: SOCanvasPoint;
+} & {
+readonly centerPoint: SOCanvasPoint;
+} & {
+addOpening(opening: SIWallOpening): void;
+removeOpening(id: string): void;
+regenerateIds(randomizer: string): void;
+}, _NotCustomized, _NotCustomized>;
+
 export { }