@archilogic/extension-sdk 0.2.1

package/dist/index.d.ts

@@ -0,0 +1,3541 @@
+declare class AnnotationCreate extends OperationBase {
+    type: typeof AnnotationCreateTypeValue;
+    value: LayoutAnnotationJson;
+    constructor(value: LayoutAnnotationJson);
+    do(layout: SpaceGraphLayout): void;
+    undo(layout: SpaceGraphLayout): void;
+}
+
+declare type AnnotationCreateOperationJson = Pick<AnnotationCreate, 'type' | 'value'>;
+
+declare const AnnotationCreateTypeValue: "operation:annotationCreate";
+
+declare class AnnotationRemove extends OperationBase {
+    type: typeof AnnotationRemoveTypeValue;
+    previousValue: LayoutAnnotationJson;
+    constructor(node: LayoutAnnotation | string, previousValue?: LayoutAnnotationJson);
+    do(layout: SpaceGraphLayout): void;
+    undo(layout: SpaceGraphLayout): void;
+}
+
+declare type AnnotationRemoveOperationJson = Pick<AnnotationRemove, 'nodeId' | 'type'> & Partial<Pick<AnnotationRemove, 'previousValue'>>;
+
+declare const AnnotationRemoveTypeValue: "operation:annotationRemove";
+
+declare class AnnotationUpdate extends OperationBase {
+    type: typeof AnnotationUpdateTypeValue;
+    value: AnnotationUpdateValue;
+    constructor(node: LayoutAnnotation | string, value: AnnotationUpdateValue, previousValue?: AnnotationUpdateValue);
+    private setPreviousValue;
+    private update;
+    do(layout: SpaceGraphLayout): void;
+    undo(layout: SpaceGraphLayout): void;
+}
+
+declare type AnnotationUpdateOperationJson = Pick<AnnotationUpdate, 'nodeId' | 'type' | 'value'> & Partial<Pick<AnnotationUpdate, 'previousValue'>>;
+
+declare const AnnotationUpdateTypeValue: "operation:annotationUpdate";
+
+declare type AnnotationUpdateValue = Partial<LayoutAnnotationJson> & {
+    parameters?: Partial<LayoutAnnotationJson['parameters']>;
+};
+
+declare interface ArcCurve extends CurveBase {
+    type: ArcCurveType;
+    radius: number;
+    startAngle: number;
+    endAngle: number;
+}
+
+declare interface ArcCurve_2 extends BaseShape {
+    type: 'curve:arc';
+    position: Vector2_2;
+    radius: number;
+    startAngle: number;
+    endAngle: number;
+}
+
+declare type ArcCurveType = typeof ArcCurveTypeValue;
+
+declare const ArcCurveTypeValue = "curve:arc";
+
+/**
+ * Background of the floor plan canvas
+ */
+declare type BackgroundOptions = {
+    /** background-color: hex code for color, set to 'transparent' for transparent background */
+    color?: string;
+    /** show a dynamic grid */
+    showGrid?: boolean;
+};
+
+declare interface BaseData {
+    id: string;
+    name: string;
+    type: string;
+    customId: string;
+    customAttributes: Record<string, string | number | boolean>;
+    /** dimensions in meters */
+    dimensions: {
+        width: number;
+        length: number;
+        height: number;
+    };
+    /**
+     * dimensions in meters
+     * @example
+     * {
+     *   min: [0, 0, 0],
+     *   max: [1, 2, 1],
+     *   transform: {
+     *     position: [0, 0, 0],
+     *     rotation: 0,
+     *     rotationAxis: [0, 1, 0]
+     *   }
+     * }
+     * */
+    boundingBox: TransformBoundingBox3d;
+    /**  */
+    boundingBoxContour: Vector2[];
+}
+
+declare interface BaseShape {
+    type: string;
+    style?: ShapeStyle;
+}
+
+declare interface BezierCurve extends BaseShape {
+    type: 'curve:quadraticBezier';
+    points: Polygon;
+}
+
+declare type BoundingBox3d = {
+    min: Vector3;
+    max: Vector3;
+};
+
+declare class CallOptions {
+    #private;
+    readonly transferables?: Transferable[];
+    readonly timeout?: number;
+    constructor(options?: {
+        transferables?: Transferable[];
+        timeout?: number;
+    });
+}
+
+declare interface CircleCurve extends CurveBase {
+    type: CircleCurveType;
+    radius: number;
+}
+
+declare interface CircleCurve_2 extends BaseShape {
+    type: 'curve:circle';
+    position: Vector2_2;
+    radius: number;
+}
+
+declare type CircleCurveType = typeof CircleCurveTypeValue;
+
+declare const CircleCurveTypeValue = "curve:circle";
+
+declare type ClosedCurve = RectangleCurve | PolygonCurve | PolygonWithHolesCurve | CircleCurve | CompositeCurve;
+
+declare type ClosedCurveType = RectangleCurveType | PolygonCurveType | PolygonWithHolesCurveType | CircleCurveType | CompositeCurveType;
+
+declare interface CommonParameters {
+    materials: LayoutBeamMaterials;
+}
+
+declare interface CommonParameters_2 {
+    counterHeight: number;
+    materials: LayoutCaseworkMaterials;
+}
+
+declare interface CommonParameters_3 {
+    /** thickness of the frame in x direction */
+    frameThickness: number;
+    /** depth of the frame in z direction */
+    frameDepth: number;
+    doorType: DoorType;
+    doorAngle: number;
+    hardware: boolean;
+    hingeSide: HingeSide;
+    doorSide: DoorSide;
+    materials: LayoutDoorMaterials;
+}
+
+declare interface CommonParameters_4 {
+    wallCabinet: boolean;
+    leftHighCabinetCount: number;
+    rightHighCabinetCount: number;
+    sinkElementSlot: number;
+    cooktopElementSlot: number;
+    ovenElementSlot: number;
+    materials: LayoutKitchenMaterials;
+}
+
+declare interface CommonParameters_5 {
+    segmentCount: number;
+    segmentLength: number;
+    materials: LayoutRailingMaterials;
+}
+
+declare interface CommonParameters_6 {
+    materials: LayoutRampMaterials;
+}
+
+declare interface CommonParameters_7 {
+    /** thickness of the frame in x direction */
+    frameThickness: number;
+    /** depth of the frame in z direction */
+    frameDepth: number;
+    panelLength: number;
+    panelCount: number;
+    materials: LayoutWindowMaterials;
+}
+
+declare type CommonStairsParameters = {
+    railing: 'none' | 'left' | 'right' | 'both';
+    materials: LayoutStairsMaterials;
+};
+
+declare interface CompositeCurve extends CurveBase {
+    type: CompositeCurveType;
+    segments: OpenCurve[];
+}
+
+declare interface CompositeCurve_2 extends BaseShape {
+    type: 'curve:composite';
+    segments: OpenCurves[];
+}
+
+declare type CompositeCurveType = typeof CompositeCurveTypeValue;
+
+declare const CompositeCurveTypeValue = "curve:composite";
+
+/**
+ * An object representing the connection as a result of calling connect().
+ */
+export declare type Connection<TMethods extends Methods = Methods> = {
+    /**
+     * A promise which will be resolved once the connection has been established.
+     */
+    promise: Promise<RemoteProxy<TMethods>>;
+    /**
+     * A method that, when called, will disconnect any communication.
+     * You may call this even before a connection has been established.
+     */
+    destroy: () => void;
+};
+
+/**
+ * @example
+ * const pluginConnection = createPluginConnection(methods)
+ * const pluginApi = await pluginConnection.promise
+ * await pluginApi.onPluginConnect({ floorMetaData })
+ * pluginConnection.destroy()
+ */
+export declare const createExtensionConnection: (iframe: HTMLIFrameElement, methods: any) => Connection<ExtensionApi>;
+
+/**
+ * @example
+ * const hostApi = createHostConnection({
+ *   onPluginConnect: () => {}
+ * })
+ * const spaceResponse = await hostApi.getSpaces()
+ */
+export declare const createHostConnection: (methods?: Partial<ExtensionApi>) => HostApi;
+
+declare class CuboidGeometry extends ParametricGeometryBase {
+    type: CuboidGeometryType;
+    dimensions: Vector3;
+    constructor(id: string);
+}
+
+declare interface CuboidGeometryJson extends ParametricGeometryBaseJson {
+    type: CuboidGeometryType;
+    dimensions: Vector3;
+}
+
+declare type CuboidGeometryType = typeof CuboidGeometryTypeValue;
+
+declare const CuboidGeometryTypeValue = "geometry:cuboid";
+
+declare interface CurveBase {
+    type: CurveType;
+}
+
+declare type CurveType = ClosedCurveType | OpenCurveType;
+
+declare class CustomAttributeCreate extends OperationBase {
+    type: typeof CustomAttributeCreateTypeValue;
+    value: CustomAttributeCreateValue;
+    constructor(value: CustomAttributeCreateValue);
+    do(layout: SpaceGraphLayout): void;
+    undo(layout: SpaceGraphLayout): void;
+}
+
+declare type CustomAttributeCreateOperationJson = Pick<CustomAttributeCreate, 'type' | 'value'>;
+
+declare const CustomAttributeCreateTypeValue = "operation:customAttributeCreate";
+
+declare type CustomAttributeCreateValue = SpaceGraphCustomAttributeJson;
+
+declare type CustomAttributeInputType = 'Text' | 'Number' | 'Boolean' | 'Integer' | 'Select';
+
+declare class CustomAttributeRemove extends OperationBase {
+    type: typeof CustomAttributeRemoveTypeValue;
+    value: CustomAttributeRemoveValue;
+    previousValue: CustomAttributeRemoveValue;
+    constructor(node: SpaceGraphCustomAttribute | string, previousValue?: CustomAttributeRemoveValue);
+    do(layout: SpaceGraphLayout): void;
+    undo(layout: SpaceGraphLayout): void;
+}
+
+declare type CustomAttributeRemoveOperationJson = Pick<CustomAttributeRemove, 'nodeId' | 'type'> & Partial<Pick<CustomAttributeRemove, 'previousValue'>>;
+
+declare const CustomAttributeRemoveTypeValue = "operation:customAttributeRemove";
+
+declare type CustomAttributeRemoveValue = SpaceGraphCustomAttributeJson;
+
+declare type CustomAttributeResourceType = 'building' | 'element' | 'floor' | 'layout' | 'product' | 'space';
+
+declare type CustomAttributeSchema = CustomAttributeSchemaText | CustomAttributeSchemaSelect | CustomAttributeSchemaNumber | CustomAttributeSchemaInteger | CustomAttributeSchemaBoolean;
+
+declare type CustomAttributeSchemaBoolean = {
+    type: 'boolean';
+};
+
+declare type CustomAttributeSchemaInteger = {
+    type: 'integer';
+};
+
+declare type CustomAttributeSchemaNumber = {
+    type: 'number';
+};
+
+declare type CustomAttributeSchemaSelect = {
+    type: 'string';
+    enum: string[];
+};
+
+declare type CustomAttributeSchemaText = {
+    type: 'string';
+};
+
+declare class CustomAttributeUpdate extends OperationBase {
+    type: typeof CustomAttributeUpdateTypeValue;
+    value: CustomAttributeUpdateValue;
+    constructor(node: SpaceGraphCustomAttribute | string, value: CustomAttributeUpdateValue, previousValue?: CustomAttributeUpdateValue);
+    private setPreviousValue;
+    do(layout: SpaceGraphLayout): void;
+    undo(layout: SpaceGraphLayout): void;
+}
+
+declare type CustomAttributeUpdateOperationJson = Pick<CustomAttributeUpdate, 'nodeId' | 'type' | 'value'> & Partial<Pick<CustomAttributeUpdate, 'previousValue'>>;
+
+declare const CustomAttributeUpdateTypeValue = "operation:customAttributeUpdate";
+
+declare type CustomAttributeUpdateValue = Partial<SpaceGraphCustomAttributeJson>;
+
+/** @deprecated */
+declare type CustomAttributeValueType = 'Text' | 'Number' | 'Boolean' | 'Schema';
+
+declare type CustomStairsParameters = {
+    stairsType: CustomStairsType;
+    /** @minimum 0.01 */
+    height: number;
+    /** @minimum 0.01 */
+    stepWidth: number;
+} & CommonStairsParameters;
+
+declare type CustomStairsParametersJson = Partial<CustomStairsParameters>;
+
+declare type CustomStairsType = 'custom';
+
+declare type DimensionParameters = {
+    /** @minimum 0.01 */
+    length: number;
+    /** @minimum 0.01 */
+    width: number;
+    /** @minimum 0.01 */
+    height: number;
+};
+
+declare interface DimensionParameters_2 {
+    /** @minimum 0.01 */
+    length: number;
+    /** @minimum 0.01 */
+    height: number;
+}
+
+declare interface DimensionParameters_3 {
+    /** @minimum 0.01 */
+    length: number;
+    /** @minimum 0.01 */
+    height: number;
+}
+
+declare type DoorSide = 'side1' | 'side2';
+
+declare type DoorType = 'singleSwing' | 'doubleSwing' | 'slidingDoor' | 'opening' | 'elevatorDoor' | 'garageDoor';
+
+declare enum DxfUnits {
+    unitLess = 0,
+    inches = 1,
+    feet = 2,
+    miles = 3,
+    millimeters = 4,
+    centimeters = 5,
+    meters = 6,
+    kilometers = 7
+}
+
+declare type DxfUnitsString = keyof typeof DxfUnits;
+
+declare interface EdgeCanSplitOptions {
+    minimumLength?: number;
+}
+
+declare class EdgeConnect extends OperationBase {
+    type: typeof EdgeConnectTypeValue;
+    value: EdgeConnectValue;
+    previousVertex: {
+        [edgeId: string]: {
+            start: SpatialGraphVertexJson | null;
+            end: SpatialGraphVertexJson | null;
+        };
+    };
+    newEdgeId: {
+        [originEdgeId: string]: string;
+    };
+    constructor(edge: SpatialGraphEdge | string, value: EdgeConnectValue);
+    isInRange(value: number, range: [number, number]): boolean;
+    splitEdge(layout: SpaceGraphLayout, edgeId: string, u: number): SpatialGraphVertex;
+    undoSplitEdge(layout: SpaceGraphLayout, edgeId: string): void;
+    extendEdge(layout: SpaceGraphLayout, edgeId: string, u: number, point: Vector2, vertex?: SpatialGraphVertex): SpatialGraphVertex;
+    undoExtendEdge(layout: SpaceGraphLayout, edgeId: string): void;
+    safeRemoveVertexById(layout: SpaceGraphLayout, vertexId: string): void;
+    do(layout: SpaceGraphLayout): void;
+    undo(layout: SpaceGraphLayout): void;
+}
+
+declare type EdgeConnectOperationJson = Pick<EdgeConnect, 'nodeId' | 'type' | 'value'>;
+
+declare const EdgeConnectTypeValue: "operation:edgeConnect";
+
+declare type EdgeConnectValue = {
+    edgeId: string;
+};
+
+declare class EdgeCreate extends OperationBase {
+    type: typeof EdgeCreateTypeValue;
+    value: EdgeCreateValueType;
+    constructor(value: EdgeCreateValueType);
+    do(layout: SpaceGraphLayout): void;
+    undo(layout: SpaceGraphLayout): void;
+}
+
+declare type EdgeCreateOperationJson = Pick<EdgeCreate, 'value' | 'type'>;
+
+declare const EdgeCreateTypeValue: "operation:edgeCreate";
+
+declare type EdgeCreateValueType = Omit<SpatialGraphEdgeJson, 'type'>;
+
+declare type EdgeElementMap = {
+    'element:curtainWall': LayoutCurtainWall;
+    'element:spaceDivider': LayoutSpaceDivider;
+    'element:wall': LayoutWall;
+};
+
+declare class EdgeMerge extends OperationBase {
+    type: typeof EdgeMergeTypeValue;
+    value: EdgeMergeValue;
+    previousValue: {
+        splitEdgeU: number;
+        elementId?: string;
+    };
+    constructor(edge: SpatialGraphEdge | string, value: EdgeMergeValue, previousValue?: {
+        splitEdgeU: number;
+    });
+    do(layout: SpaceGraphLayout): void;
+    undo(layout: SpaceGraphLayout): void;
+}
+
+declare type EdgeMergeOperationJson = Pick<EdgeMerge, 'nodeId' | 'type' | 'value'> & Partial<Pick<EdgeMerge, 'previousValue'>>;
+
+declare const EdgeMergeTypeValue: "operation:edgeMerge";
+
+declare type EdgeMergeValue = {
+    vertexId: string;
+    edgeId: string;
+};
+
+declare class EdgeRemove extends OperationBase {
+    type: typeof EdgeRemoveTypeValue;
+    previousValue: EdgeVertexValue;
+    constructor(edge: SpatialGraphEdge | string, previousValue?: EdgeVertexValue);
+    do(layout: SpaceGraphLayout): void;
+    undo(layout: SpaceGraphLayout): void;
+}
+
+declare type EdgeRemoveOperationJson = Pick<EdgeRemove, 'nodeId' | 'type'> & Partial<Pick<EdgeRemove, 'previousValue'>>;
+
+declare const EdgeRemoveTypeValue: "operation:edgeRemove";
+
+declare class EdgeReplace extends OperationBase {
+    type: typeof EdgeReplaceTypeValue;
+    value: EdgeReplaceValue;
+    previousValue: SpatialGraphEdgeJson;
+    constructor(edge: SpatialGraphEdge | string, value: EdgeReplaceValue, previousValue?: SpatialGraphEdgeJson);
+    do(layout: SpaceGraphLayout): void;
+    undo(layout: SpaceGraphLayout): void;
+}
+
+declare type EdgeReplaceOperationJson = Pick<EdgeReplace, 'nodeId' | 'type' | 'value'> & Partial<Pick<EdgeReplace, 'previousValue'>>;
+
+declare const EdgeReplaceTypeValue: "operation:edgeReplace";
+
+declare type EdgeReplaceValue = Pick<SpatialGraphEdgeJson, 'id'> & Partial<SpatialGraphEdgeJson>;
+
+declare class EdgeSplit extends OperationBase {
+    type: typeof EdgeSplitTypeValue;
+    value: EdgeSplitValue;
+    constructor(edge: SpatialGraphEdge | string, value: EdgeSplitValue);
+    do(layout: SpaceGraphLayout): void;
+    undo(layout: SpaceGraphLayout): void;
+}
+
+declare type EdgeSplitOperationJson = Pick<EdgeSplit, 'nodeId' | 'type' | 'value'>;
+
+declare interface EdgeSplitOptions {
+    vertexId?: string;
+    edgeId?: string;
+    elementId?: string;
+}
+
+declare interface EdgeSplitReturnValue {
+    vertex: SpatialGraphVertex;
+    edge: SpatialGraphEdge;
+    element?: LayoutEdgeElement;
+}
+
+declare const EdgeSplitTypeValue: "operation:edgeSplit";
+
+declare type EdgeSplitValue = {
+    splitEdgeU: number;
+    newVertexId: string;
+    newEdgeId: string;
+    newElementId?: string;
+    updateSpaceBoundaries?: boolean;
+};
+
+declare type EdgeType = 'graph:adjacentTo' | 'graph:connectedTo';
+
+declare class EdgeUpdate extends OperationBase {
+    type: typeof EdgeUpdateTypeValue;
+    value: EdgeVertexValue;
+    previousValue: EdgeVertexValue;
+    constructor(edge: SpatialGraphEdge | string, value: EdgeVertexValue, previousValue?: EdgeVertexValue);
+    private setPreviousValue;
+    private update;
+    do(layout: SpaceGraphLayout): void;
+    undo(layout: SpaceGraphLayout): void;
+}
+
+declare type EdgeUpdateOperationJson = Pick<EdgeUpdate, 'nodeId' | 'type' | 'value'> & Partial<Pick<EdgeUpdate, 'previousValue'>>;
+
+declare const EdgeUpdateTypeValue: "operation:edgeUpdate";
+
+declare type EdgeVertexValue = Required<Pick<SpatialGraphEdgeJson, 'vertices'>> & Partial<SpatialGraphEdgeJson>;
+
+declare class ElementCreate extends OperationBase {
+    type: typeof ElementCreateTypeValue;
+    value: LayoutElementJson;
+    parentId?: string;
+    constructor(value: LayoutElementJson, parentId?: string);
+    do(layout: SpaceGraphLayout): void;
+    undo(layout: SpaceGraphLayout): void;
+}
+
+declare type ElementCreateOperationJson = Pick<ElementCreate, 'type' | 'value' | 'parentId'>;
+
+declare const ElementCreateTypeValue: "operation:elementCreate";
+
+export declare interface ElementData extends BaseData {
+    type: LayoutElementJson['type'];
+    parameters: LayoutElementJson['parameters'];
+    product: ProductData;
+    elements: ElementData[];
+}
+
+declare class ElementRemove extends OperationBase {
+    type: typeof ElementRemoveTypeValue;
+    previousValue: LayoutElementJson;
+    parentId?: string;
+    constructor(element: LayoutElement | string, previousValue?: ElementUpdateValue);
+    private setPreviousValue;
+    do(layout: SpaceGraphLayout): void;
+    undo(layout: SpaceGraphLayout): void;
+}
+
+declare type ElementRemoveOperationJson = Pick<ElementRemove, 'nodeId' | 'type'> & Partial<Pick<ElementUpdate, 'previousValue'>>;
+
+declare const ElementRemoveTypeValue: "operation:elementRemove";
+
+declare class ElementUpdate extends OperationBase {
+    type: typeof ElementUpdateTypeValue;
+    value: ElementUpdateValue;
+    constructor(element: LayoutElement | string, value: ElementUpdateValue, previousValue?: ElementUpdateValue);
+    private setPreviousValue;
+    private update;
+    do(layout: SpaceGraphLayout): void;
+    undo(layout: SpaceGraphLayout): void;
+}
+
+declare type ElementUpdateOperationJson = Pick<ElementUpdate, 'nodeId' | 'type' | 'value'> & Partial<Pick<ElementUpdate, 'previousValue'>>;
+
+declare const ElementUpdateTypeValue: "operation:elementUpdate";
+
+declare type ElementUpdateValue = Partial<LayoutElementJson> & {
+    parameters?: Partial<LayoutElementJson['parameters']>;
+};
+
+declare interface EntityResponse extends HostResponse {
+    data: {
+        id: string;
+    };
+}
+
+export declare type ExtensionApi = {
+    onPluginConnect({ floorMetaData }: {
+        floorMetaData: any;
+    }): void;
+    onPluginDestroy(): void;
+    onLayoutChange(args: any): void;
+    onSelectionChange({ selectedNodes }: {
+        selectedNodes: {
+            id: string;
+            type: string;
+        }[];
+    }): void;
+    onGraphicDrag({ position, id }: {
+        position: [number, number];
+        id: string;
+    }): void;
+    onCanvasClick({ position, nodeId }: {
+        position: [number, number];
+        nodeId?: string;
+    }): void;
+};
+
+declare type ExtractValueFromReply<R> = R extends Reply ? Awaited<R['value']> : R;
+
+declare class ExtrusionGeometry extends ParametricGeometryBase {
+    type: ExtrusionGeometryType;
+    profile: ClosedCurve;
+    height: number;
+    constructor(id: string, profile: ClosedCurve);
+}
+
+declare interface ExtrusionGeometryJson extends ParametricGeometryBaseJson {
+    type: ExtrusionGeometryType;
+    profile: ClosedCurve;
+    height: number;
+}
+
+declare type ExtrusionGeometryType = typeof ExtrusionGeometryTypeValue;
+
+declare const ExtrusionGeometryTypeValue = "geometry:extrusion";
+
+/**
+ * This is the place to give the floor plan your own style
+ */
+declare type FloorPlanTheme = {
+    /** define the background */
+    background?: BackgroundOptions;
+    /** wall contours are merged to one continuous outline, needed if you want white walls */
+    wallContours?: boolean;
+    /** render assets with textures rather than solid colors */
+    showAssetTextures?: boolean;
+    fontFamily?: string;
+    elements?: {
+        byId?: Record<string, ShapeStyle>;
+        floorPlan?: {
+            grayscale: boolean;
+        };
+        roomStamp?: {
+            /** show the area information in room stamps */
+            roomStampDisplay?: ('usage' | 'area' | 'customId' | 'name' | 'id' | ['customAttribute', string])[];
+            /** text color for room stamps */
+            text?: Rgb;
+            /** whether the room stamp text should have an outline to assist with contrast issues */
+            textOutline?: boolean;
+        };
+        'element:asset'?: ShapeStyle;
+        'element:beam'?: ShapeStyle;
+        'element:boundaryWall'?: ShapeStyle;
+        'element:casework'?: ShapeStyle;
+        'element:ceiling'?: ShapeStyle;
+        'element:column'?: ShapeStyle;
+        'element:curtainWall'?: ShapeStyle;
+        'element:door'?: ShapeStyle;
+        'element:floor'?: ShapeStyle;
+        'element:generic'?: ShapeStyle;
+        'element:kitchen'?: ShapeStyle;
+        'element:opening'?: ShapeStyle;
+        'element:railing'?: ShapeStyle;
+        'element:ramp'?: ShapeStyle;
+        'element:roof'?: ShapeStyle;
+        'element:slab'?: ShapeStyle;
+        'element:spaceDivider'?: ShapeStyle;
+        'element:stairFlight'?: ShapeStyle;
+        'element:stairs'?: ShapeStyle;
+        'element:wall'?: ShapeStyle;
+        'element:window'?: ShapeStyle;
+        'layout:space'?: SpaceShapeStyle;
+        'spatialGraph:edge'?: ShapeStyle;
+    };
+};
+
+declare class GeometryBase extends SpaceGraphNodeBase {
+    type: SpaceGraphGeometryType;
+    position: PositionEntry;
+    rotation: RotationEntry;
+    rotationAxis: Vector3;
+    boundingBox: BoundingBox3d;
+    surfaces: Surfaces;
+    materials: SurfaceMaterialsJson;
+    constructor(id: string, type: SpaceGraphGeometryType);
+}
+
+declare interface GeometryBaseJson extends SpaceGraphNodeBaseJson {
+    id: string;
+    type: SpaceGraphGeometryType;
+    position?: PositionEntry;
+    rotation?: RotationEntry;
+    rotationAxis?: Vector3;
+    boundingBox?: BoundingBox3d;
+    surfaces?: Surfaces;
+    materials?: SurfaceMaterialsJson;
+    material?: SpaceGraphMaterialJson;
+}
+
+declare class GeometryClip extends GeometryOperationPlaneBase {
+    type: GeometryClipType;
+    constructor(id: string, plane: Plane, material: SpaceGraphMaterial);
+}
+
+declare interface GeometryClipJson extends GeometryOperationPlaneBaseJson {
+    type: GeometryClipType;
+}
+
+declare type GeometryClipType = typeof GeometryClipTypeValue;
+
+declare const GeometryClipTypeValue = "csg:clip";
+
+declare type GeometryFaceIndices = number[] | IndexRange | 'all';
+
+declare class GeometryIntersect extends GeometryOperationGeometryBase {
+    type: GeometryIntersectType;
+}
+
+declare interface GeometryIntersectJson extends GeometryOperationGeometryBaseJson {
+    type: GeometryIntersectType;
+}
+
+declare type GeometryIntersectType = typeof GeometryIntersectTypeValue;
+
+declare const GeometryIntersectTypeValue = "csg:intersect";
+
+declare type GeometryOperation = GeometryOperationGeometry | GeometryOperationPlane;
+
+declare class GeometryOperationBase extends SpaceGraphTypedValue {
+    type: GeometryOperationType;
+    constructor(type: GeometryOperationType);
+}
+
+declare interface GeometryOperationBaseJson extends SpaceGraphTypedValueJson {
+    type: GeometryOperationType;
+}
+
+declare type GeometryOperationGeometry = GeometryReference | GeometrySubtract | GeometryUnion | GeometryIntersect;
+
+declare class GeometryOperationGeometryBase extends GeometryOperationBase {
+    type: GeometryOperationGeometryType;
+    geometry: SpaceGraphGeometry;
+    position: PositionEntry;
+    rotation: RotationEntry;
+    rotationAxis: Vector3;
+    materials: SurfaceMaterials;
+    constructor(type: GeometryOperationGeometryType, geometry: SpaceGraphGeometry, materials: SurfaceMaterials);
+}
+
+declare interface GeometryOperationGeometryBaseJson extends GeometryOperationBaseJson {
+    type: GeometryOperationGeometryType;
+    geometry: string | SpaceGraphGeometryJson;
+    position?: PositionEntry;
+    rotation?: RotationEntry;
+    rotationAxis?: Vector3;
+    materials?: SurfaceMaterialsJson;
+    material?: SpaceGraphMaterialJson;
+}
+
+declare type GeometryOperationGeometryJson = string | GeometryReferenceJson | GeometrySubtractJson | GeometryIntersectJson | GeometryUnionJson;
+
+declare type GeometryOperationGeometryType = GeometryReferenceType | GeometrySubtractType | GeometryUnionType | GeometryIntersectType;
+
+declare type GeometryOperationJson = GeometryOperationGeometryJson | GeometryOperationPlaneJson;
+
+declare type GeometryOperationPlane = GeometryClip;
+
+declare class GeometryOperationPlaneBase extends GeometryOperationBase {
+    type: GeometryOperationPlaneType;
+    plane: Plane;
+    material: SpaceGraphMaterial;
+    constructor(type: GeometryOperationPlaneType, plane: Plane, material: SpaceGraphMaterial);
+}
+
+declare interface GeometryOperationPlaneBaseJson extends GeometryOperationBaseJson {
+    type: GeometryOperationPlaneType;
+    plane: Plane;
+    material: SpaceGraphMaterialJson;
+}
+
+declare type GeometryOperationPlaneJson = GeometryClipJson;
+
+declare type GeometryOperationPlaneType = GeometryClipType;
+
+declare type GeometryOperationType = GeometryOperationGeometryType | GeometryOperationPlaneType;
+
+declare class GeometryReference extends GeometryOperationGeometryBase {
+    type: GeometryReferenceType;
+}
+
+declare interface GeometryReferenceJson extends GeometryOperationGeometryBaseJson {
+    type: GeometryReferenceType;
+}
+
+declare type GeometryReferenceType = typeof GeometryReferenceTypeValue;
+
+declare const GeometryReferenceTypeValue = "reference:geometry";
+
+declare class GeometrySubtract extends GeometryOperationGeometryBase {
+    type: GeometrySubtractType;
+}
+
+declare interface GeometrySubtractJson extends GeometryOperationGeometryBaseJson {
+    type: GeometrySubtractType;
+}
+
+declare type GeometrySubtractType = typeof GeometrySubtractTypeValue;
+
+declare const GeometrySubtractTypeValue = "csg:subtract";
+
+declare class GeometryUnion extends GeometryOperationGeometryBase {
+    type: GeometryUnionType;
+}
+
+declare interface GeometryUnionJson extends GeometryOperationGeometryBaseJson {
+    type: GeometryUnionType;
+}
+
+declare type GeometryUnionType = typeof GeometryUnionTypeValue;
+
+declare const GeometryUnionTypeValue = "csg:union";
+
+/**
+ * undirected graph for traversal without edge weights
+ */
+declare class Graph {
+    nodeMap: Map<LayoutNode, Map<EdgeType, Set<LayoutNode>>>;
+    addNode(node: LayoutNode): Map<EdgeType, Set<LayoutNode>>;
+    addEdge(type: EdgeType, source: LayoutNode, destination: LayoutNode): void;
+    removeNode(node: LayoutNode): void;
+    removeEdge(type: EdgeType, source: LayoutNode, destination: LayoutNode): void;
+    /**
+     * Breadth-First Search
+     * if edges have weights this needs to be replaces with dijkstra algorithm
+     */
+    findShortestPath(edgeType: EdgeType, start: LayoutNode, end: LayoutNode, options?: {
+        depthLimit?: number;
+    }): LayoutNode[] | null;
+}
+
+declare class GroupRelation extends SpaceGraphNodeBase {
+    type: GroupRelationType;
+    elements: Set<LayoutElement>;
+    constructor(id: string);
+    insertElements(elements: LayoutElement[]): void;
+    removeElements(elements: LayoutElement[]): void;
+    copyForClone(product: GroupRelation): void;
+    toJSON(): GroupRelationJson;
+}
+
+declare interface GroupRelationJson extends SpaceGraphNodeBaseJson {
+    type: GroupRelationType;
+    elements: string[];
+}
+
+declare type GroupRelationType = typeof GroupRelationTypeValue;
+
+declare const GroupRelationTypeValue = "relation:group";
+
+declare interface GroupShape extends BaseShape {
+    type: 'group';
+    position?: Vector2_2;
+    rotation?: number;
+    children: Shape[];
+}
+
+declare type HingeSide = 'left' | 'right';
+
+export declare type HostApi = {
+    /**
+     * @example
+     * const { data: element } = await hostApi.getElementsById({ id, include: ['name', 'type', 'dimensions']})
+     */
+    getElementById: <K extends keyof ElementData>(args: {
+        id: string;
+        include: K[];
+    }) => Promise<{
+        data?: Pick<ElementData, K>;
+        error?: string;
+        ok: boolean;
+    }>;
+    /**
+     * @example
+     * const { data: elements } = await hostApi.getElements({ include: ['id', 'name', 'type']})
+     */
+    getElements: <K extends keyof ElementData>(args: {
+        include: K[];
+    }) => Promise<{
+        data: Pick<ElementData, K>[];
+        error?: string;
+        ok: boolean;
+    }>;
+    /**
+     * @example
+     * const { data: elementsByType } = await hostApi.getElementsByType({ type, include: ['id', 'name', 'dimensions']})
+     */
+    getElementsByType: <K extends keyof ElementData>(args: {
+        type: LayoutElementJson['type'];
+        include: K[];
+    }) => Promise<{
+        data: Pick<ElementData, K>[];
+        error?: string;
+        ok: boolean;
+    }>;
+    getSpaceById: <K extends keyof SpaceData>(args: {
+        id: string;
+        include: K[];
+    }) => Promise<{
+        data?: Pick<SpaceData, K>;
+        error?: string;
+        ok: boolean;
+    }>;
+    getSpaces: <K extends keyof SpaceData>(args: {
+        include: K[];
+    }) => Promise<{
+        data: Pick<SpaceData, K>[];
+        error?: string;
+        ok: boolean;
+    }>;
+    getSpaceGraphJson: () => Promise<{
+        data: SpaceGraphJson;
+        error?: string;
+    }>;
+    runOperations: (args: {
+        operations: OperationJson[];
+    }) => Promise<HostResponse>;
+    setPlanConfig: (config: {
+        theme: FloorPlanTheme;
+    }) => Promise<HostResponse>;
+    addPlanLayer: (args: {
+        id?: string;
+        baseLayer?: string;
+    }) => Promise<EntityResponse>;
+    addPlanGraphic: (args: {
+        shapes: Shape[];
+        isHandler?: boolean;
+        layerId?: string;
+        id?: string;
+        clearLayer?: boolean;
+    }) => Promise<EntityResponse>;
+    zoomToNode: (args: {
+        nodeId: string;
+        margin?: number;
+        animate?: number | boolean;
+    }) => Promise<HostResponse>;
+    zoomExtents: (args?: {
+        margin?: number;
+        animate?: number | boolean;
+    }) => Promise<HostResponse>;
+    drawNodeUpdate: (args: {
+        nodeId: string;
+        style: 'selected' | ShapeStyle | false;
+    }) => Promise<HostResponse>;
+    selectNodes: (args: {
+        nodeIds: string[];
+    }) => Promise<SelectionResponse>;
+};
+
+export declare type HostApiSync = {
+    /**
+     * @example
+     * const { data: element } = await hostApi.getElementsById({ id, include: ['name', 'type', 'dimensions']})
+     */
+    getElementById: <K extends keyof ElementData>(args: {
+        id: string;
+        include: K[];
+    }) => {
+        data?: Pick<ElementData, K>;
+        error?: string;
+        ok: boolean;
+    };
+    /**
+     * @example
+     * const { data: elements } = await hostApi.getElements({ include: ['id', 'name', 'type']})
+     */
+    getElements: <K extends keyof ElementData>(args: {
+        include: K[];
+    }) => {
+        data: Pick<ElementData, K>[];
+        error?: string;
+        ok: boolean;
+    };
+    /**
+     * @example
+     * const { data: elementsByType } = await hostApi.getElementsByType({ type, include: ['id', 'name', 'dimensions']})
+     */
+    getElementsByType: <K extends keyof ElementData>(args: {
+        type: LayoutElementJson['type'];
+        include: K[];
+    }) => {
+        data: Pick<ElementData, K>[];
+        error?: string;
+        ok: boolean;
+    };
+    getSpaceById: <K extends keyof SpaceData>(args: {
+        id: string;
+        include: K[];
+    }) => {
+        data?: Pick<SpaceData, K>;
+        error?: string;
+        ok: boolean;
+    };
+    getSpaces: <K extends keyof SpaceData>(args: {
+        include: K[];
+    }) => {
+        data: Pick<SpaceData, K>[];
+        error?: string;
+        ok: boolean;
+    };
+    getSpaceGraphJson: () => {
+        data: SpaceGraphJson;
+        error?: string;
+    };
+    runOperations: (args: {
+        operations: OperationJson[];
+    }) => HostResponse;
+    setPlanConfig: (config: {
+        theme: FloorPlanTheme;
+    }) => HostResponse;
+    addPlanLayer: (args: {
+        id?: string;
+        baseLayer?: string;
+    }) => EntityResponse;
+    addPlanGraphic: (args: {
+        shapes: Shape[];
+        isHandler?: boolean;
+        layerId?: string;
+        id?: string;
+        clearLayer?: boolean;
+    }) => EntityResponse;
+    zoomToNode: (args: {
+        nodeId: string;
+        margin?: number;
+        animate?: number | boolean;
+    }) => HostResponse;
+    zoomExtents: (args?: {
+        margin?: number;
+        animate?: number | boolean;
+    }) => HostResponse;
+    drawNodeUpdate: (args: {
+        nodeId: string;
+        style: 'selected' | ShapeStyle | false;
+    }) => HostResponse;
+    selectNodes: (args: {
+        nodeIds: string[];
+    }) => SelectionResponse;
+};
+
+export declare interface HostResponse {
+    ok: boolean;
+    data?: unknown;
+    error?: string;
+}
+
+declare type IndexRange = {
+    type: 'index:range';
+    start: number;
+    end: number;
+};
+
+declare class Layout2dView extends LayoutViewBase {
+    type: Layout2dViewType;
+    parameters: Layout2dViewParameters;
+    constructor(id: string);
+    setParameters(parameters: RecursivePartial<Layout2dViewParameters>): void;
+}
+
+declare interface Layout2dViewJson extends LayoutViewBaseJson {
+    type: Layout2dViewType;
+    parameters?: Layout2dViewParametersJson;
+}
+
+declare interface Layout2dViewNodeStyle {
+    tags: string[];
+    fill: string;
+    fillOpacity: number;
+    stroke: string;
+    strokeWidth: number;
+}
+
+declare type Layout2dViewNodeStyleJson = Partial<Layout2dViewNodeStyle>;
+
+declare interface Layout2dViewParameters {
+    style: Layout2dViewStyle;
+    hidden: LayoutElementType[];
+}
+
+declare interface Layout2dViewParametersJson {
+    style: Layout2dViewStyleJson;
+    hidden: LayoutElementType[];
+}
+
+declare interface Layout2dViewStyle {
+    background: Pick<Layout2dViewNodeStyle, 'fill'>;
+    units: 'imperial' | 'metric';
+    byId: Record<string, Layout2dViewNodeStyle>;
+    byType: Record<string, Layout2dViewNodeStyle>;
+    byAttribute: {
+        program: Record<string, Layout2dViewNodeStyle>;
+        usage: Record<string, Layout2dViewNodeStyle>;
+    };
+}
+
+declare interface Layout2dViewStyleJson {
+    background?: Pick<Layout2dViewNodeStyleJson, 'fill'>;
+    units?: 'imperial' | 'metric';
+    byId?: Record<string, Layout2dViewNodeStyleJson>;
+    byType?: Record<string, Layout2dViewNodeStyleJson>;
+    byAttribute?: {
+        program?: Record<string, Layout2dViewNodeStyleJson>;
+        usage?: Record<string, Layout2dViewNodeStyleJson>;
+    };
+}
+
+declare type Layout2dViewType = typeof Layout2dViewTypeValue;
+
+declare const Layout2dViewTypeValue = "view:2d";
+
+declare class Layout3dView extends LayoutViewBase {
+    type: Layout3dViewType;
+    parameters: Layout3dViewParameters;
+    constructor(id: string);
+    setParameters(parameters: RecursivePartial<Layout3dViewParameters>): void;
+}
+
+declare interface Layout3dViewJson extends LayoutViewBaseJson {
+    type: Layout3dViewType;
+    parameters?: Layout3dViewParametersJson;
+}
+
+declare interface Layout3dViewParameters {
+    position: Vector3;
+    normal: Vector3;
+    fov: number | 'default';
+    scale: number | 'auto';
+    lensShiftX: number;
+    lensShiftY: number;
+    projection: 'perspective' | 'orthographic';
+}
+
+declare type Layout3dViewParametersJson = Partial<Layout3dViewParameters>;
+
+declare type Layout3dViewType = typeof Layout3dViewTypeValue;
+
+declare const Layout3dViewTypeValue = "view:3d";
+
+declare type LayoutAnnotation = LayoutFloorPlanDxfAnnotation | LayoutFloorPlanImageAnnotation;
+
+declare class LayoutAnnotationBase extends LayoutNodeBase {
+    type: LayoutAnnotationType;
+    parameters: LayoutAnnotationParameters;
+    position: Vector3;
+    rotation: number;
+    copyForClone(annotation: LayoutAnnotation): void;
+    setTransform(position: Vector3, rotation: number): void;
+    setParameters(parameters: RecursivePartial<LayoutAnnotationParameters>): void;
+    toJSON(): LayoutAnnotationJson;
+}
+
+declare interface LayoutAnnotationBaseJson extends LayoutNodeBaseJson {
+    type: LayoutAnnotationType;
+    position: Vector3;
+    rotation: number;
+    parameters?: LayoutAnnotationParametersJson;
+}
+
+declare type LayoutAnnotationJson = LayoutFloorPlanDxfAnnotationJson | LayoutFloorPlanImageAnnotationJson;
+
+declare type LayoutAnnotationParameters = LayoutFloorPlanDxfParameters | LayoutFloorPlanImageParameters;
+
+declare type LayoutAnnotationParametersJson = LayoutFloorPlanDxfParametersJson | LayoutFloorPlanImageParametersJson;
+
+declare type LayoutAnnotationType = LayoutFloorPlanDxfType | LayoutFloorPlanImageType;
+
+declare class LayoutAsset extends LayoutTransformElementBase {
+    type: LayoutAssetType;
+    parameters: LayoutAssetParameters;
+    product: SpaceGraphProduct | null;
+    constructor(id: string);
+    setParameters(parameters: RecursivePartial<LayoutAssetParameters>): void;
+    setProduct(product: SpaceGraphProduct): void;
+    getBoundingBox(localTransform?: boolean): {
+        min: Vector3;
+        max: Vector3;
+        transform: Transform3d;
+    };
+}
+
+declare interface LayoutAssetJson extends LayoutTransformElementBaseJson {
+    type: LayoutAssetType;
+    product?: string;
+}
+
+declare interface LayoutAssetMaterials {
+}
+
+declare interface LayoutAssetParameters {
+    materials: LayoutAssetMaterials;
+}
+
+declare type LayoutAssetType = typeof LayoutAssetTypeValue;
+
+declare const LayoutAssetTypeValue = "element:asset";
+
+declare class LayoutBeam extends LayoutTransformElementBase {
+    type: LayoutBeamType;
+    parameters: LayoutBeamParameters;
+    constructor(id: string);
+    setParameters(parameters: RecursivePartial<LayoutBeamParameters>): void;
+}
+
+declare interface LayoutBeamJson extends LayoutTransformElementBaseJson {
+    type: LayoutBeamType;
+    parameters?: LayoutBeamParametersJson;
+}
+
+declare interface LayoutBeamMaterials {
+    top: SpaceGraphMaterialJson;
+    bottom: SpaceGraphMaterialJson;
+    sides: SpaceGraphMaterialJson;
+}
+
+declare type LayoutBeamParameters = DimensionParameters & CommonParameters;
+
+declare type LayoutBeamParametersJson = DimensionParameters & Partial<CommonParameters>;
+
+declare type LayoutBeamType = typeof LayoutBeamTypeValue;
+
+declare const LayoutBeamTypeValue = "element:beam";
+
+declare class LayoutBoundary {
+    vertices: SpatialGraphVertex[];
+    edges: SpatialGraphEdge[];
+    geometryProfile: Vector2[];
+    toJSON(): LayoutBoundaryJson;
+}
+
+declare type LayoutBoundaryElement = LayoutBoundarySlab | LayoutBoundaryWall;
+
+declare class LayoutBoundaryElementBase extends LayoutElementBase {
+    type: LayoutBoundaryElementType;
+    parameters: LayoutBoundaryElementParameters;
+    boundaries: LayoutBoundary[];
+    constructor(id: string, type: LayoutBoundaryElementType, boundaries: LayoutBoundary[]);
+    getBoundingBox(): {
+        min: Vector3;
+        max: Vector3;
+        transform: Transform3d;
+    };
+}
+
+declare interface LayoutBoundaryElementBaseJson extends LayoutElementBaseJson {
+    type: LayoutBoundaryElementType;
+    boundaries: LayoutBoundaryJson[];
+    parameters?: LayoutBoundaryElementParametersJson;
+}
+
+declare type LayoutBoundaryElementJson = LayoutBoundarySlabJson | LayoutBoundaryWallJson;
+
+declare type LayoutBoundaryElementParameters = LayoutBoundarySlabParameters | LayoutBoundaryWallParameters;
+
+declare type LayoutBoundaryElementParametersJson = LayoutBoundarySlabParametersJson | LayoutBoundaryWallParametersJson;
+
+declare type LayoutBoundaryElementType = LayoutBoundarySlabType | LayoutBoundaryWallType;
+
+declare interface LayoutBoundaryJson {
+    edges: string[];
+}
+
+declare class LayoutBoundarySlab extends LayoutBoundaryElementBase {
+    type: LayoutBoundarySlabType;
+    parameters: LayoutBoundarySlabParameters;
+    space: LayoutSpace | null;
+    constructor(id: string, type: LayoutBoundarySlabType, boundaries: LayoutBoundary[]);
+    setParameters(parameters: RecursivePartial<LayoutBoundarySlabParameters>): void;
+    getSpaces(): LayoutSpace[];
+}
+
+declare interface LayoutBoundarySlabJson extends LayoutBoundaryElementBaseJson {
+    type: LayoutBoundarySlabType;
+    parameters?: LayoutBoundarySlabParametersJson;
+}
+
+declare interface LayoutBoundarySlabMaterials {
+    top: SpaceGraphMaterialJson;
+    bottom: SpaceGraphMaterialJson;
+    sides: SpaceGraphMaterialJson;
+}
+
+declare interface LayoutBoundarySlabParameters {
+    height: number;
+    elevation: number;
+    materials: LayoutBoundarySlabMaterials;
+}
+
+declare type LayoutBoundarySlabParametersJson = Partial<LayoutBoundarySlabParameters>;
+
+declare type LayoutBoundarySlabType = LayoutFloorType | LayoutCeilingType;
+
+declare class LayoutBoundaryWall extends LayoutBoundaryElementBase {
+    type: LayoutBoundaryWallType;
+    parameters: LayoutBoundaryWallParameters;
+    constructor(id: string, boundaries: LayoutBoundary[]);
+    setParameters(parameters: RecursivePartial<LayoutBoundaryWallParameters>): void;
+}
+
+declare interface LayoutBoundaryWallJson extends LayoutBoundaryElementBaseJson {
+    type: LayoutBoundaryWallType;
+    parameters?: LayoutBoundaryWallParametersJson;
+}
+
+declare interface LayoutBoundaryWallMaterials {
+    top: SpaceGraphMaterialJson;
+    bottom: SpaceGraphMaterialJson;
+    sides: SpaceGraphMaterialJson;
+}
+
+declare interface LayoutBoundaryWallParameters {
+    height: number;
+    elevation: number;
+    surfaces: {
+        top: [0];
+        bottom: [1];
+        sides: '...';
+    };
+    materials: LayoutBoundaryWallMaterials;
+}
+
+declare type LayoutBoundaryWallParametersJson = Partial<LayoutBoundaryWallParameters>;
+
+declare type LayoutBoundaryWallType = typeof LayoutBoundaryWallTypeValue;
+
+declare const LayoutBoundaryWallTypeValue = "element:boundaryWall";
+
+declare class LayoutCasework extends LayoutTransformElementBase {
+    type: LayoutCaseworkType;
+    parameters: LayoutCaseworkParameters;
+    constructor(id: string);
+    setParameters(parameters: RecursivePartial<LayoutCaseworkParameters>): void;
+}
+
+declare interface LayoutCaseworkJson extends LayoutTransformElementBaseJson {
+    type: LayoutCaseworkType;
+    parameters?: LayoutCaseworkParametersJson;
+}
+
+declare interface LayoutCaseworkMaterials {
+    cabinet: SpaceGraphMaterialJson;
+    cabinetDoors: SpaceGraphMaterialJson;
+    counter: SpaceGraphMaterialJson;
+}
+
+declare type LayoutCaseworkParameters = DimensionParameters & CommonParameters_2;
+
+declare type LayoutCaseworkParametersJson = DimensionParameters & Partial<CommonParameters_2>;
+
+declare type LayoutCaseworkType = typeof LayoutCaseworkTypeValue;
+
+declare const LayoutCaseworkTypeValue = "element:casework";
+
+declare type LayoutCeilingType = typeof LayoutCeilingTypeValue;
+
+declare const LayoutCeilingTypeValue = "element:ceiling";
+
+declare class LayoutColumn extends LayoutTransformElementBase {
+    type: LayoutColumnType;
+    parameters: LayoutColumnParameters;
+    constructor(id: string);
+    setParameters(parameters: RecursivePartial<LayoutColumnParameters>): void;
+}
+
+declare interface LayoutColumnJson extends LayoutTransformElementBaseJson {
+    type: LayoutColumnType;
+    parameters?: LayoutColumnParametersJson;
+}
+
+declare interface LayoutColumnMaterials {
+    top: SpaceGraphMaterialJson;
+    bottom: SpaceGraphMaterialJson;
+    sides: SpaceGraphMaterialJson;
+}
+
+declare interface LayoutColumnParameters {
+    profile: LayoutColumnProfile;
+    /** @minimum 0.01 */
+    height: number;
+    materials: LayoutColumnMaterials;
+}
+
+declare type LayoutColumnParametersJson = Partial<LayoutColumnParameters>;
+
+declare type LayoutColumnProfile = RectangleCurve | CircleCurve | PolygonCurve | PolygonWithHolesCurve;
+
+declare type LayoutColumnType = typeof LayoutColumnTypeValue;
+
+declare const LayoutColumnTypeValue = "element:column";
+
+declare class LayoutCurtainWall extends LayoutEdgeElementBase {
+    type: LayoutCurtainWallType;
+    parameters: LayoutCurtainWallParameters;
+    constructor(id: string, edges: SpatialGraphEdge[]);
+    setParameters(parameters: RecursivePartial<LayoutCurtainWallParameters>): void;
+}
+
+declare interface LayoutCurtainWallJson extends LayoutEdgeElementBaseJson {
+    type: LayoutCurtainWallType;
+    parameters?: LayoutCurtainWallParametersJson;
+}
+
+declare interface LayoutCurtainWallParameters {
+}
+
+declare type LayoutCurtainWallParametersJson = Partial<LayoutCurtainWallParameters>;
+
+declare type LayoutCurtainWallType = typeof LayoutCurtainWallTypeValue;
+
+declare const LayoutCurtainWallTypeValue = "element:curtainWall";
+
+declare class LayoutDoor extends LayoutTransformElementBase {
+    type: LayoutDoorType;
+    parameters: LayoutDoorParameters;
+    constructor(id: string);
+    setParameters(parameters: RecursivePartial<LayoutDoorParameters>): void;
+    getBoundingBox(localTransform?: boolean): {
+        min: Vector3;
+        max: Vector3;
+        transform: Transform3d;
+    };
+}
+
+declare interface LayoutDoorJson extends LayoutTransformElementBaseJson {
+    type: LayoutDoorType;
+    parameters?: LayoutDoorParametersJson;
+}
+
+declare interface LayoutDoorMaterials {
+    frame: SpaceGraphMaterialJson;
+    leaf: SpaceGraphMaterialJson;
+}
+
+declare type LayoutDoorParameters = DimensionParameters_2 & CommonParameters_3;
+
+declare type LayoutDoorParametersJson = DimensionParameters_2 & Partial<CommonParameters_3>;
+
+declare type LayoutDoorType = typeof LayoutDoorTypeValue;
+
+declare const LayoutDoorTypeValue = "element:door";
+
+declare type LayoutEdgeElement = LayoutCurtainWall | LayoutSpaceDivider | LayoutWall;
+
+declare class LayoutEdgeElementBase extends LayoutElementBase {
+    type: LayoutEdgeElementType;
+    parameters: LayoutEdgeElementParameters;
+    private edges;
+    private vertices;
+    edgesChanged: boolean;
+    constructor(id: string, type: LayoutEdgeElementType, edges: SpatialGraphEdge[]);
+    setEdges(edges: SpatialGraphEdge[]): void;
+    private verifyEdges;
+    getEdges(): SpatialGraphEdge[];
+    getVertices(): SpatialGraphVertex[];
+    getStartVertex(): SpatialGraphVertex | undefined;
+    getEndVertex(): SpatialGraphVertex | undefined;
+    getAxisPoints(): [Vector2, Vector2] | [];
+    getAxisLength(): number;
+    getEdgeAtLinearPosition(u: number): SpatialGraphEdge | undefined;
+    getEdgesAtLinearSegment(u: number, v: number): SpatialGraphEdge[];
+    /**
+     * @deprecated Use getEdges() instead of edge
+     */
+    get edge(): SpatialGraphEdge;
+    getAdjacentElementsByVertex(): [LayoutEdgeElement[], LayoutEdgeElement[]];
+    getAdjacentSpacesBySide(): [LayoutSpace[], LayoutSpace[]];
+    getSpaces(): LayoutSpace[];
+    getElementsAtLinearPosition(u: number): LayoutElement[];
+    get isExternal(): boolean;
+}
+
+declare interface LayoutEdgeElementBaseJson extends LayoutElementBaseJson {
+    type: LayoutEdgeElementType;
+    edge: string | string[];
+    parameters?: LayoutEdgeElementParametersJson;
+}
+
+declare type LayoutEdgeElementJson = LayoutCurtainWallJson | LayoutSpaceDividerJson | LayoutWallJson;
+
+declare type LayoutEdgeElementParameters = LayoutCurtainWallParameters | LayoutSpaceDividerParameters | LayoutWallParameters;
+
+declare type LayoutEdgeElementParametersJson = LayoutCurtainWallParametersJson | LayoutSpaceDividerParametersJson | LayoutWallParametersJson;
+
+declare type LayoutEdgeElementType = LayoutCurtainWallType | LayoutSpaceDividerType | LayoutWallType;
+
+declare type LayoutElement = LayoutBoundaryElement | LayoutEdgeElement | LayoutOpeningElement | LayoutTransformElement;
+
+declare class LayoutElementBase extends LayoutNodeBase {
+    type: LayoutElementType;
+    parameters: LayoutElementParameters;
+    parent: LayoutElement | null;
+    elements: LayoutElement[];
+    geometries: GeometryOperationJson[];
+    insertElement(element: LayoutElement): void;
+    getTransform(): Transform3d;
+    getWorldTransform(): Transform3d;
+    /**
+     * returns the element's object aligned bounding box with transform
+     */
+    getBoundingBox(localTransform?: boolean): TransformBoundingBox3d;
+    getAxisAlignedBoundingBox(localTransform?: boolean): BoundingBox3d;
+    getBoundingBoxContour(localTransform?: boolean): Vector2[];
+    get isExternal(): boolean;
+    removeElement(element: LayoutElement): void;
+    copyForClone(element: LayoutElement): void;
+    setParameters(parameters: RecursivePartial<LayoutElementParameters>): void;
+    getSpaces(): LayoutSpace[];
+    toJSON(): LayoutElementJson;
+}
+
+declare interface LayoutElementBaseJson extends LayoutNodeBaseJson {
+    type: LayoutElementType;
+    geometries?: GeometryOperationJson[];
+    parameters?: LayoutElementParametersJson;
+    elements?: LayoutElementJson[];
+}
+
+declare type LayoutElementJson = LayoutBoundaryElementJson | LayoutEdgeElementJson | LayoutOpeningElementJson | LayoutTransformElementJson;
+
+declare type LayoutElementParameters = LayoutBoundaryElementParameters | LayoutEdgeElementParameters | LayoutOpeningElementParameters | LayoutTransformElementParameters;
+
+declare type LayoutElementParametersJson = LayoutBoundaryElementParametersJson | LayoutEdgeElementParametersJson | LayoutOpeningElementParametersJson | LayoutTransformElementParametersJson;
+
+declare type LayoutElementType = LayoutBoundaryElementType | LayoutEdgeElementType | LayoutOpeningElementType | LayoutTransformElementType;
+
+declare class LayoutFloorPlanDxfAnnotation extends LayoutAnnotationBase {
+    type: LayoutFloorPlanDxfType;
+    parameters: LayoutFloorPlanDxfParameters;
+    constructor(id: string);
+    setParameters(parameters: RecursivePartial<LayoutFloorPlanDxfParameters>): void;
+}
+
+declare interface LayoutFloorPlanDxfAnnotationJson extends LayoutAnnotationBaseJson {
+    type: LayoutFloorPlanDxfType;
+    parameters?: LayoutFloorPlanDxfParametersJson;
+}
+
+declare interface LayoutFloorPlanDxfParameters {
+    uri: string;
+    drawingOrigin: Vector2;
+    drawingUnits: DxfUnitsString;
+    hiddenLayers: string[];
+}
+
+declare type LayoutFloorPlanDxfParametersJson = Partial<LayoutFloorPlanDxfParameters>;
+
+declare type LayoutFloorPlanDxfType = typeof LayoutFloorPlanDxfTypeValue;
+
+declare const LayoutFloorPlanDxfTypeValue = "annotation:floorPlanDxf";
+
+declare class LayoutFloorPlanImageAnnotation extends LayoutAnnotationBase {
+    type: LayoutFloorPlanImageType;
+    parameters: LayoutFloorPlanImageParameters;
+    constructor(id: string);
+    setParameters(parameters: RecursivePartial<LayoutFloorPlanImageParameters>): void;
+}
+
+declare interface LayoutFloorPlanImageAnnotationJson extends LayoutAnnotationBaseJson {
+    type: LayoutFloorPlanImageType;
+    parameters?: LayoutFloorPlanImageParametersJson;
+}
+
+declare interface LayoutFloorPlanImageParameters {
+    uri: string;
+    length: number;
+    width: number;
+}
+
+declare type LayoutFloorPlanImageParametersJson = Partial<LayoutFloorPlanImageParameters>;
+
+declare type LayoutFloorPlanImageType = typeof LayoutFloorPlanImageTypeValue;
+
+declare const LayoutFloorPlanImageTypeValue = "annotation:floorPlanImage";
+
+declare type LayoutFloorType = typeof LayoutFloorTypeValue;
+
+declare const LayoutFloorTypeValue = "element:floor";
+
+declare class LayoutGeneric extends LayoutTransformElementBase {
+    type: LayoutGenericType;
+    parameters: LayoutGenericParameters;
+    constructor(id: string);
+    setParameters(parameters: RecursivePartial<LayoutGenericParameters>): void;
+}
+
+declare interface LayoutGenericJson extends LayoutTransformElementBaseJson {
+    type: LayoutGenericType;
+    parameters?: LayoutGenericParametersJson;
+}
+
+declare interface LayoutGenericMaterials {
+    top: SpaceGraphMaterialJson;
+    bottom: SpaceGraphMaterialJson;
+    sides: SpaceGraphMaterialJson;
+}
+
+declare interface LayoutGenericParameters {
+    profile: LayoutGenericProfile;
+    height: number;
+    materials: LayoutGenericMaterials;
+}
+
+declare type LayoutGenericParametersJson = Partial<LayoutGenericParameters>;
+
+declare type LayoutGenericProfile = 'none' | RectangleCurve | CircleCurve | PolygonCurve | PolygonWithHolesCurve;
+
+declare type LayoutGenericType = typeof LayoutGenericTypeValue;
+
+declare const LayoutGenericTypeValue = "element:generic";
+
+declare class LayoutKitchen extends LayoutTransformElementBase {
+    type: LayoutKitchenType;
+    parameters: LayoutKitchenParameters;
+    constructor(id: string);
+    setParameters(parameters: RecursivePartial<LayoutKitchenParameters>, skipElementCreation?: boolean): void;
+}
+
+declare interface LayoutKitchenJson extends LayoutTransformElementBaseJson {
+    type: LayoutKitchenType;
+    parameters?: LayoutKitchenParametersJson;
+}
+
+declare interface LayoutKitchenMaterials {
+    cabinet: SpaceGraphMaterialJson;
+    cabinetDoors: SpaceGraphMaterialJson;
+    counter: SpaceGraphMaterialJson;
+}
+
+declare type LayoutKitchenParameters = DimensionParameters & CommonParameters_4;
+
+declare type LayoutKitchenParametersJson = DimensionParameters & Partial<CommonParameters_4>;
+
+declare type LayoutKitchenType = typeof LayoutKitchenTypeValue;
+
+declare const LayoutKitchenTypeValue = "element:kitchen";
+
+declare type LayoutNode = SpatialGraphNode_2 | LayoutSpace | LayoutElement | LayoutAnnotation | LayoutView;
+
+declare class LayoutNodeBase extends SpaceGraphNodeWithCustomAttributesBase {
+    type: LayoutNodeType;
+    layout: SpaceGraphLayout;
+    constructor(id: string, type: LayoutNodeType);
+}
+
+declare interface LayoutNodeBaseJson extends SpaceGraphNodeWithCustomAttributesBaseJson {
+    type: LayoutNodeType;
+}
+
+declare type LayoutNodeType = SpatialGraphNodeType | LayoutSpaceType | LayoutElementType | LayoutAnnotationType | LayoutViewType;
+
+declare class LayoutOpening extends LayoutOpeningElementBase {
+    type: LayoutOpeningType;
+    parameters: LayoutOpeningParameters;
+    constructor(id: string);
+    getTransform(): Transform3d;
+    get position(): Vector3;
+    get rotation(): number;
+    setParameters(parameters: RecursivePartial<LayoutOpeningParameters>): void;
+    getBoundingBox(localTransform?: boolean): {
+        min: Vector3;
+        max: Vector3;
+        transform: Transform3d;
+    };
+    getSpaces(): LayoutSpace[];
+    get isExternal(): boolean;
+}
+
+declare type LayoutOpeningElement = LayoutOpening;
+
+declare class LayoutOpeningElementBase extends LayoutElementBase {
+    type: LayoutOpeningElementType;
+    parameters: LayoutOpeningElementParameters;
+    constructor(id: string, type: LayoutOpeningElementType);
+}
+
+declare interface LayoutOpeningElementBaseJson extends LayoutElementBaseJson {
+    type: LayoutOpeningElementType;
+    parameters?: LayoutOpeningElementParametersJson;
+}
+
+declare type LayoutOpeningElementJson = LayoutOpeningJson;
+
+declare type LayoutOpeningElementParameters = LayoutOpeningParameters;
+
+declare type LayoutOpeningElementParametersJson = LayoutOpeningParametersJson;
+
+declare type LayoutOpeningElementType = LayoutOpeningType;
+
+declare interface LayoutOpeningJson extends LayoutOpeningElementBaseJson {
+    type: LayoutOpeningType;
+    parameters?: LayoutOpeningParametersJson;
+}
+
+declare interface LayoutOpeningMaterials {
+    top: SpaceGraphMaterialJson;
+    bottom: SpaceGraphMaterialJson;
+    sides: SpaceGraphMaterialJson;
+}
+
+declare interface LayoutOpeningParameters {
+    position: Vector2;
+    dimensions: Vector2;
+    materials: LayoutOpeningMaterials;
+}
+
+declare type LayoutOpeningParametersJson = Partial<LayoutOpeningParameters>;
+
+declare type LayoutOpeningType = typeof LayoutOpeningTypeValue;
+
+declare const LayoutOpeningTypeValue = "element:opening";
+
+declare class LayoutRailing extends LayoutTransformElementBase {
+    type: LayoutRailingType;
+    parameters: LayoutRailingParameters;
+    constructor(id: string);
+    setParameters(parameters: RecursivePartial<LayoutRailingParameters>): void;
+}
+
+declare interface LayoutRailingJson extends LayoutTransformElementBaseJson {
+    type: LayoutRailingType;
+    parameters?: LayoutRailingParametersJson;
+}
+
+declare interface LayoutRailingMaterials {
+    surface: SpaceGraphMaterialJson;
+}
+
+declare type LayoutRailingParameters = DimensionParameters & CommonParameters_5;
+
+declare type LayoutRailingParametersJson = DimensionParameters & Partial<CommonParameters_5>;
+
+declare type LayoutRailingType = typeof LayoutRailingTypeValue;
+
+declare const LayoutRailingTypeValue = "element:railing";
+
+declare class LayoutRamp extends LayoutTransformElementBase {
+    type: LayoutRampType;
+    parameters: LayoutRampParameters;
+    constructor(id: string);
+}
+
+declare interface LayoutRampJson extends LayoutTransformElementBaseJson {
+    type: LayoutRampType;
+    parameters?: LayoutRampParametersJson;
+}
+
+declare interface LayoutRampMaterials {
+    top: SpaceGraphMaterialJson;
+    bottom: SpaceGraphMaterialJson;
+    sides: SpaceGraphMaterialJson;
+}
+
+declare type LayoutRampParameters = DimensionParameters & CommonParameters_6;
+
+declare type LayoutRampParametersJson = DimensionParameters & Partial<CommonParameters_6>;
+
+declare type LayoutRampType = typeof LayoutRampTypeValue;
+
+declare const LayoutRampTypeValue = "element:ramp";
+
+declare class LayoutRoof extends LayoutTransformElementBase {
+    type: LayoutRoofType;
+    parameters: LayoutRoofParameters;
+    constructor(id: string);
+}
+
+declare interface LayoutRoofJson extends LayoutTransformElementBaseJson {
+    type: LayoutRoofType;
+    parameters?: LayoutRoofParametersJson;
+}
+
+declare interface LayoutRoofMaterials {
+}
+
+declare interface LayoutRoofParameters {
+    materials: LayoutRoofMaterials;
+}
+
+declare type LayoutRoofParametersJson = Partial<LayoutRoofParameters>;
+
+declare type LayoutRoofType = typeof LayoutRoofTypeValue;
+
+declare const LayoutRoofTypeValue = "element:roof";
+
+declare class LayoutSlab extends LayoutTransformElementBase {
+    type: LayoutSlabType;
+    parameters: LayoutSlabParameters;
+    constructor(id: string);
+    setParameters(parameters: RecursivePartial<LayoutSlabParameters>): void;
+}
+
+declare interface LayoutSlabJson extends LayoutTransformElementBaseJson {
+    type: LayoutSlabType;
+    parameters?: LayoutSlabParametersJson;
+}
+
+declare interface LayoutSlabMaterials {
+    top: SpaceGraphMaterialJson;
+    bottom: SpaceGraphMaterialJson;
+    sides: SpaceGraphMaterialJson;
+}
+
+declare interface LayoutSlabParameters {
+    profile: LayoutSlabProfile;
+    height: number;
+    materials: LayoutSlabMaterials;
+}
+
+declare type LayoutSlabParametersJson = Partial<LayoutSlabParameters>;
+
+declare type LayoutSlabProfile = RectangleCurve | CircleCurve | PolygonCurve | PolygonWithHolesCurve;
+
+declare type LayoutSlabType = typeof LayoutSlabTypeValue;
+
+declare const LayoutSlabTypeValue = "element:slab";
+
+declare class LayoutSpace extends LayoutNodeBase {
+    type: LayoutSpaceType;
+    attributes: LayoutSpaceAttributes;
+    boundaries: LayoutBoundary[];
+    geometry: LayoutSpaceGeometry;
+    slabs: LayoutBoundarySlab[];
+    constructor(id: string, boundaries: LayoutBoundary[]);
+    copyForClone(space: LayoutSpace): void;
+    setId(id: string): void;
+    setAttributes(attributes: LayoutSpaceAttributesJson): void;
+    get isExternal(): boolean;
+    getArea(): number;
+    getAdjacentSpaces(graph: Graph, { connectivity }?: {
+        connectivity?: number;
+    }): LayoutSpace[];
+    getElements(types?: string | string[]): LayoutElement[];
+    getBoundaryFromVertex(vertex: SpatialGraphVertex): {
+        boundary: LayoutBoundary | undefined;
+        itemIndex: number;
+    };
+    getBoundaryFromEdge(edge: SpatialGraphEdge): {
+        boundary: LayoutBoundary | undefined;
+        edgeIndex: number;
+    };
+    getBoundingBox(): TransformBoundingBox3d;
+    getAxisAlignedBoundingBox(): BoundingBox3d;
+    getBoundingBoxContour(): Vector2[];
+    attachSlab(slab: LayoutBoundarySlab): void;
+    detachSlab(slab: LayoutBoundarySlab): void;
+    toJSON(): LayoutSpaceJson;
+}
+
+declare interface LayoutSpaceAttributes {
+    usage: string;
+    program: string;
+}
+
+declare interface LayoutSpaceAttributesJson {
+    usage?: string;
+    program?: string;
+}
+
+declare class LayoutSpaceDivider extends LayoutEdgeElementBase {
+    type: LayoutSpaceDividerType;
+    parameters: LayoutSpaceDividerParameters;
+    constructor(id: string, edges: SpatialGraphEdge[]);
+    setParameters(parameters: RecursivePartial<LayoutSpaceDividerParameters>): void;
+    getBoundingBox(): TransformBoundingBox3d;
+}
+
+declare interface LayoutSpaceDividerJson extends LayoutEdgeElementBaseJson {
+    type: LayoutSpaceDividerType;
+    parameters?: LayoutSpaceDividerParametersJson;
+}
+
+declare interface LayoutSpaceDividerParameters {
+}
+
+declare type LayoutSpaceDividerParametersJson = Partial<LayoutSpaceDividerParameters>;
+
+declare type LayoutSpaceDividerType = typeof LayoutSpaceDividerTypeValue;
+
+declare const LayoutSpaceDividerTypeValue = "element:spaceDivider";
+
+declare interface LayoutSpaceGeometry {
+    polygons: Vector2[][];
+}
+
+declare interface LayoutSpaceJson extends LayoutNodeBaseJson {
+    type: LayoutSpaceType;
+    boundaries: LayoutBoundaryJson[];
+    attributes?: LayoutSpaceAttributesJson;
+}
+
+declare type LayoutSpaceType = typeof LayoutSpaceTypeValue;
+
+declare const LayoutSpaceTypeValue = "layout:space";
+
+declare class LayoutSpatialGraph {
+    layout: SpaceGraphLayout;
+    vertices: SpatialGraphVertex[];
+    verticesById: Record<string, SpatialGraphVertex>;
+    edges: SpatialGraphEdge[];
+    edgesById: Record<string, SpatialGraphEdge>;
+    graphChanged: boolean;
+    debugVertexCount: number;
+    debugEdgeCount: number;
+    constructor(layout: SpaceGraphLayout);
+    emit<EventType extends keyof SpaceGraphEventMap>(event: EventType, ...args: SpaceGraphEventMap[EventType]): void;
+    copyForClone(spatialGraph: LayoutSpatialGraph): void;
+    deleteVertexAtIndex(vertexIndex: number, removeNodes: boolean): SpatialGraphVertex | undefined;
+    deleteEdgeAtIndex(edgeIndex: number, removeNodes: boolean): SpatialGraphEdge | undefined;
+    insertVertex(vertex: SpatialGraphVertex): void;
+    removeVertex(vertex: SpatialGraphVertex, removeNodes?: boolean): SpatialGraphVertex | undefined;
+    removeVertexAtIndex(vertexIndex: number, removeNodes?: boolean): SpatialGraphVertex | undefined;
+    removeVertexById(id: string, removeNodes?: boolean): SpatialGraphVertex | undefined;
+    insertEdge(edge: SpatialGraphEdge, splitSpace?: boolean): void;
+    removeEdge(edge: SpatialGraphEdge, removeNodes?: boolean): SpatialGraphEdge | undefined;
+    removeEdgeAtIndex(edgeIndex: number, removeNodes?: boolean): SpatialGraphEdge | undefined;
+    removeEdgeById(id: string, removeNodes?: boolean): SpatialGraphEdge | undefined;
+    getEdgeFromVertices(vertex1: SpatialGraphVertex, vertex2: SpatialGraphVertex): SpatialGraphEdge | undefined;
+    getVertexId(prefix?: string): string;
+    getEdgeId(prefix?: string): string;
+    createVertex(id: string, x: number, y: number): SpatialGraphVertex;
+    createEdge(id: string, vertex1: SpatialGraphVertex, vertex2: SpatialGraphVertex, splitSpace?: boolean): SpatialGraphEdge;
+    createEdgeByVertexIds(id: string, vertexId1: string, vertexId2: string, splitSpace?: boolean): SpatialGraphEdge;
+    toJSON(): LayoutSpatialGraphJson;
+}
+
+declare interface LayoutSpatialGraphJson {
+    vertices: SpatialGraphVertexJson[];
+    edges: SpatialGraphEdgeJson[];
+}
+
+declare class LayoutStairFlight extends LayoutTransformElementBase {
+    type: LayoutStairFlightType;
+    parameters: LayoutStairFlightParameters;
+    constructor(id: string);
+    setParameters(parameters: RecursivePartial<LayoutStairFlightParameters>): void;
+}
+
+declare interface LayoutStairFlightJson extends LayoutTransformElementBaseJson {
+    type: LayoutStairFlightType;
+    parameters?: LayoutStairFlightParametersJson;
+}
+
+declare interface LayoutStairFlightMaterials {
+    steps: SpaceGraphMaterialJson;
+    tread: SpaceGraphMaterialJson;
+}
+
+declare type LayoutStairFlightParameters = StraightStairFlightParameters | SpiralStairFlightParameters;
+
+declare type LayoutStairFlightParametersJson = StraightStairFlightParametersJson | SpiralStairFlightParametersJson;
+
+declare type LayoutStairFlightType = typeof LayoutStairFlightTypeValue;
+
+declare const LayoutStairFlightTypeValue = "element:stairFlight";
+
+declare class LayoutStairs extends LayoutTransformElementBase {
+    type: LayoutStairsType;
+    parameters: LayoutStairsParameters;
+    constructor(id: string);
+    setParameters(parameters: RecursivePartial<LayoutStairsParameters>, skipElementCreation?: boolean): void;
+    getBoundingBox(localTransform?: boolean): {
+        min: Vector3;
+        max: Vector3;
+        transform: Transform3d;
+    };
+}
+
+declare interface LayoutStairsJson extends LayoutTransformElementBaseJson {
+    type: LayoutStairsType;
+    parameters?: LayoutStairsParametersJson;
+}
+
+declare interface LayoutStairsMaterials {
+    steps: SpaceGraphMaterialJson;
+    tread: SpaceGraphMaterialJson;
+    railing: SpaceGraphMaterialJson;
+}
+
+declare type LayoutStairsParameters = StraightStairsParameters | OrthogonalStairsParameters | SpiralStairsParameters | CustomStairsParameters;
+
+declare type LayoutStairsParametersJson = StraightStairsParametersJson | OrthogonalStairsParametersJson | SpiralStairsParametersJson | CustomStairsParametersJson;
+
+declare type LayoutStairsType = typeof LayoutStairsTypeValue;
+
+declare const LayoutStairsTypeValue = "element:stairs";
+
+declare type LayoutTransformElement = LayoutAsset | LayoutBeam | LayoutCasework | LayoutColumn | LayoutDoor | LayoutGeneric | LayoutKitchen | LayoutRailing | LayoutRamp | LayoutRoof | LayoutSlab | LayoutStairs | LayoutStairFlight | LayoutWindow;
+
+declare class LayoutTransformElementBase extends LayoutElementBase {
+    type: LayoutTransformElementType;
+    parameters: LayoutTransformElementParameters;
+    position: Vector3;
+    rotation: number;
+    rotationAxis: Vector3;
+    constructor(id: string, type: LayoutTransformElementType);
+    copyForClone(transformElement: LayoutTransformElement): void;
+    setPosition(position: Vector3): void;
+    setRotation(rotation: number, rotationAxis?: Vector3): void;
+    setTransform(position: Vector3, rotation: number, rotationAxis?: Vector3): void;
+    getSpaces(): LayoutSpace[];
+    getTransform(): Transform3d;
+    getWorldTransform(): Transform3d;
+    getBoundingBox(localTransform?: boolean): {
+        min: Vector3;
+        max: Vector3;
+        transform: Transform3d;
+    };
+    setParameters(parameters: RecursivePartial<LayoutTransformElementParameters>): void;
+}
+
+declare interface LayoutTransformElementBaseJson extends LayoutElementBaseJson {
+    type: LayoutTransformElementType;
+    position: Vector3;
+    rotation?: number;
+    rotationAxis?: Vector3;
+    parameters?: LayoutTransformElementParametersJson;
+}
+
+declare type LayoutTransformElementJson = LayoutAssetJson | LayoutBeamJson | LayoutCaseworkJson | LayoutColumnJson | LayoutDoorJson | LayoutGenericJson | LayoutKitchenJson | LayoutRailingJson | LayoutRampJson | LayoutRoofJson | LayoutSlabJson | LayoutStairFlightJson | LayoutStairsJson | LayoutWindowJson;
+
+declare type LayoutTransformElementParameters = LayoutAssetParameters | LayoutBeamParameters | LayoutCaseworkParameters | LayoutColumnParameters | LayoutDoorParameters | LayoutGenericParameters | LayoutKitchenParameters | LayoutRailingParameters | LayoutRampParameters | LayoutRoofParameters | LayoutSlabParameters | LayoutStairsParameters | LayoutStairFlightParameters | LayoutWindowParameters;
+
+declare type LayoutTransformElementParametersJson = LayoutBeamParametersJson | LayoutCaseworkParametersJson | LayoutColumnParametersJson | LayoutDoorParametersJson | LayoutGenericParametersJson | LayoutKitchenParametersJson | LayoutRailingParametersJson | LayoutRampParametersJson | LayoutRoofParametersJson | LayoutSlabParametersJson | LayoutStairFlightParametersJson | LayoutStairsParametersJson | LayoutWindowParametersJson;
+
+declare type LayoutTransformElementType = LayoutAssetType | LayoutBeamType | LayoutCaseworkType | LayoutColumnType | LayoutDoorType | LayoutGenericType | LayoutKitchenType | LayoutRailingType | LayoutRampType | LayoutRoofType | LayoutSlabType | LayoutStairsType | LayoutStairFlightType | LayoutWindowType;
+
+declare type LayoutType = typeof LayoutTypeValue;
+
+declare const LayoutTypeValue = "spatialStructure:layout";
+
+declare class LayoutUpdate extends OperationBase {
+    type: typeof LayoutUpdateTypeValue;
+    value: LayoutUpdateValue;
+    constructor(node: SpaceGraphLayout | string, value: LayoutUpdateValue, previousValue?: LayoutUpdateValue);
+    private setPreviousValue;
+    private update;
+    do(layout: SpaceGraphLayout): void;
+    undo(layout: SpaceGraphLayout): void;
+}
+
+declare type LayoutUpdateOperationJson = Pick<LayoutUpdate, 'nodeId' | 'type' | 'value'> & Partial<Pick<LayoutUpdate, 'previousValue'>>;
+
+declare const LayoutUpdateTypeValue = "operation:layoutUpdate";
+
+declare type LayoutUpdateValue = Partial<SpaceGraphNodeWithCustomAttributesBaseJson>;
+
+declare type LayoutView = Layout2dView | Layout3dView;
+
+declare class LayoutViewBase extends LayoutNodeBase {
+    type: LayoutViewType;
+    parameters: LayoutViewParameters;
+    copyForClone(view: LayoutView): void;
+    setParameters(parameters: RecursivePartial<LayoutViewParameters>): void;
+    toJSON(): LayoutViewJson;
+}
+
+declare interface LayoutViewBaseJson extends LayoutNodeBaseJson {
+    type: LayoutViewType;
+    parameters?: LayoutViewParametersJson;
+}
+
+declare type LayoutViewJson = Layout2dViewJson | Layout3dViewJson;
+
+declare type LayoutViewParameters = Layout2dViewParameters | Layout3dViewParameters;
+
+declare type LayoutViewParametersJson = Layout2dViewParametersJson | Layout3dViewParametersJson;
+
+declare type LayoutViewType = Layout2dViewType | Layout3dViewType;
+
+declare class LayoutWall extends LayoutEdgeElementBase {
+    type: LayoutWallType;
+    parameters: LayoutWallParameters;
+    geometryProfile: LayoutWallGeometryProfile;
+    constructor(id: string, edges: SpatialGraphEdge[]);
+    copyForClone(wall: LayoutWall): void;
+    setParameters(parameters: RecursivePartial<LayoutWallParameters>): void;
+    getBoundingBox(): TransformBoundingBox3d;
+}
+
+declare interface LayoutWallGeometryProfile {
+    valid: boolean;
+    skipped: boolean;
+    selfIntersecting: boolean;
+    sidePoints1: Vector2[];
+    sidePoints2: Vector2[];
+    joinPoints1: Vector2[];
+    joinPoints2: Vector2[];
+    points: Vector2[];
+}
+
+declare interface LayoutWallJson extends LayoutEdgeElementBaseJson {
+    type: LayoutWallType;
+    parameters?: LayoutWallParametersJson;
+}
+
+declare interface LayoutWallMaterials {
+    top: SpaceGraphMaterialJson;
+    bottom: SpaceGraphMaterialJson;
+    side1: SpaceGraphMaterialJson;
+    side2: SpaceGraphMaterialJson;
+    join1: SpaceGraphMaterialJson;
+    join2: SpaceGraphMaterialJson;
+}
+
+declare interface LayoutWallParameters {
+    /** @minimum 0.01 */
+    width: number;
+    /** @minimum 0.01 */
+    height: number;
+    offset: number;
+    elevation: number;
+    materials: LayoutWallMaterials;
+}
+
+declare type LayoutWallParametersJson = Partial<LayoutWallParameters>;
+
+declare type LayoutWallType = typeof LayoutWallTypeValue;
+
+declare const LayoutWallTypeValue = "element:wall";
+
+declare class LayoutWindow extends LayoutTransformElementBase {
+    type: LayoutWindowType;
+    parameters: LayoutWindowParameters;
+    constructor(id: string);
+    setParameters(parameters: RecursivePartial<LayoutWindowParameters>): void;
+}
+
+declare interface LayoutWindowJson extends LayoutTransformElementBaseJson {
+    type: LayoutWindowType;
+    parameters?: LayoutWindowParametersJson;
+}
+
+declare interface LayoutWindowMaterials {
+    frame: SpaceGraphMaterialJson;
+    panel: SpaceGraphMaterialJson;
+}
+
+declare type LayoutWindowParameters = DimensionParameters_3 & CommonParameters_7;
+
+declare type LayoutWindowParametersJson = DimensionParameters_3 & Partial<CommonParameters_7>;
+
+declare type LayoutWindowType = typeof LayoutWindowTypeValue;
+
+declare const LayoutWindowTypeValue = "element:window";
+
+declare interface LineCurve extends CurveBase {
+    type: LineCurveType;
+    start: Vector2;
+    end: Vector2;
+}
+
+declare interface LineCurve_2 extends BaseShape {
+    type: 'curve:line';
+    start: Vector2_2;
+    end: Vector2_2;
+}
+
+declare type LineCurveType = typeof LineCurveTypeValue;
+
+declare const LineCurveTypeValue = "curve:line";
+
+declare class MaterialCreate extends OperationBase {
+    type: typeof MaterialCreateTypeValue;
+    value: SpaceGraphMaterialResourceJson;
+    constructor(value: SpaceGraphMaterialResourceJson);
+    do(layout: SpaceGraphLayout): void;
+    undo(layout: SpaceGraphLayout): void;
+}
+
+declare type MaterialCreateOperationJson = Pick<MaterialCreate, 'type' | 'value'>;
+
+declare const MaterialCreateTypeValue: "operation:materialCreate";
+
+declare class MaterialRemove extends OperationBase {
+    type: typeof MaterialRemoveTypeValue;
+    previousValue: SpaceGraphMaterialResourceJson;
+    constructor(node: SpaceGraphMaterial | string, previousValue?: SpaceGraphMaterialResourceJson);
+    do(layout: SpaceGraphLayout): void;
+    undo(layout: SpaceGraphLayout): void;
+}
+
+declare type MaterialRemoveOperationJson = Pick<MaterialRemove, 'nodeId' | 'type'> & Partial<Pick<MaterialRemove, 'previousValue'>>;
+
+declare const MaterialRemoveTypeValue: "operation:materialRemove";
+
+declare class MaterialUpdate extends OperationBase {
+    type: typeof MaterialUpdateTypeValue;
+    value: MaterialUpdateValue;
+    previousValue: MaterialUpdateValue;
+    constructor(node: SpaceGraphMaterial | string, value: MaterialUpdateValue, previousValue?: MaterialUpdateValue);
+    private setPreviousValue;
+    do(layout: SpaceGraphLayout): void;
+    undo(layout: SpaceGraphLayout): void;
+    private updateMaterial;
+    private updateBasicMaterial;
+    private updateColorMaterial;
+    private updateStandardMaterial;
+}
+
+declare type MaterialUpdateOperationJson = Pick<MaterialUpdate, 'nodeId' | 'type' | 'value'> & Partial<Pick<MaterialUpdate, 'previousValue'>>;
+
+declare const MaterialUpdateTypeValue: "operation:materialUpdate";
+
+declare type MaterialUpdateValue = Partial<SpaceGraphMaterialResourceJson>;
+
+declare class MeshGeometry extends GeometryBase {
+    type: MeshGeometryType;
+    vertices: number[];
+    indices: number[];
+    normals: ParametricNormals | number[];
+    uvs: ParametricUvs | number[];
+    constructor(id: string);
+}
+
+declare interface MeshGeometryJson extends GeometryBaseJson {
+    type: MeshGeometryType;
+    vertices: number[];
+    indices: number[];
+    normals?: ParametricNormals | number[];
+    uvs?: ParametricUvs | number[];
+}
+
+declare type MeshGeometryType = typeof MeshGeometryTypeValue;
+
+declare const MeshGeometryTypeValue = "geometry:mesh";
+
+/**
+ * Methods to expose to the remote window. May contain nested objects
+ * with methods as well.
+ */
+declare type Methods = {
+    [index: string]: Methods | Function;
+};
+
+declare type NodesByType<NodeMap extends NodeTypeMap = {}> = {
+    -readonly [K in keyof NodeMap]: InstanceType<NodeMap[K]>[];
+};
+
+declare type NodeSelection = {
+    id: string;
+    type: string;
+}[];
+
+declare type NodeTypeMap = Record<string, any>;
+
+declare interface NumberList extends SpaceGraphTypedValueJson {
+    type: 'number:list';
+    list: number[];
+}
+
+declare interface NumberRange extends SpaceGraphTypedValueJson {
+    type: 'number:range';
+    range: {
+        start: number;
+        step: number;
+        count: number;
+    };
+}
+
+declare type OpenCurve = LineCurve | PolylineCurve | ArcCurve;
+
+declare type OpenCurves = LineCurve_2 | ArcCurve_2 | PolylineCurve_2 | BezierCurve;
+
+declare type OpenCurveType = LineCurveType | PolylineCurveType | ArcCurveType;
+
+declare class OperationBase {
+    /** @format uuid */
+    nodeId: string;
+    type: string;
+    value: any;
+    previousValue: any;
+    constructor(operationType: string, nodeId: string, value: any, previousValue: any);
+    do(layout: SpaceGraphLayout): void;
+    undo(layout: SpaceGraphLayout): void;
+}
+
+/**
+ * @discriminator type
+ */
+declare type OperationJson = VertexCreateOperationJson | EdgeCreateOperationJson | SpaceCreateOperationJson | ElementCreateOperationJson | AnnotationCreateOperationJson | ViewCreateOperationJson | ProductCreateOperationJson | RelationCreateOperationJson | MaterialCreateOperationJson | CustomAttributeCreateOperationJson | VertexRemoveOperationJson | VertexUpdateOperationJson | VertexReplaceOperationJson | EdgeConnectOperationJson | EdgeRemoveOperationJson | EdgeReplaceOperationJson | EdgeMergeOperationJson | EdgeSplitOperationJson | EdgeUpdateOperationJson | SpaceUpdateOperationJson | SpaceRemoveOperationJson | ElementUpdateOperationJson | ElementRemoveOperationJson | AnnotationUpdateOperationJson | AnnotationRemoveOperationJson | ViewUpdateOperationJson | ViewRemoveOperationJson | ProductUpdateOperationJson | ProductRemoveOperationJson | RelationUpdateOperationJson | RelationRemoveOperationJson | RelationInsertNodesOperationJson | RelationRemoveNodesOperationJson | MaterialUpdateOperationJson | MaterialRemoveOperationJson | LayoutUpdateOperationJson | CustomAttributeUpdateOperationJson | CustomAttributeRemoveOperationJson;
+
+declare type OrthogonalStairsParameters = {
+    stairsType: OrthogonalStairsType;
+    /** @minimum 0.01 */
+    stepWidth: number;
+    circulation: 'left' | 'right';
+} & DimensionParameters & CommonStairsParameters;
+
+declare type OrthogonalStairsParametersJson = Partial<OrthogonalStairsParameters>;
+
+declare type OrthogonalStairsType = 'halfLanding' | 'quarterLanding' | 'twoQuarterLanding' | 'winder' | 'doubleWinder';
+
+declare type ParametricGeometry = PlaneGeometry | CuboidGeometry | SphereGeometry | ExtrusionGeometry;
+
+declare class ParametricGeometryBase extends GeometryBase {
+    normals: ParametricNormals | 'generator';
+    uvs: ParametricUvs | 'generator';
+    geometries: GeometryOperation[];
+    constructor(id: string, type: ParametricGeometryType);
+}
+
+declare interface ParametricGeometryBaseJson extends GeometryBaseJson {
+    normals?: ParametricNormals | 'generator';
+    uvs?: ParametricUvs | 'generator';
+    geometries?: GeometryOperationJson[];
+}
+
+declare type ParametricGeometryJson = PlaneGeometryJson | CuboidGeometryJson | SphereGeometryJson | ExtrusionGeometryJson;
+
+declare type ParametricGeometryType = PlaneGeometryType | CuboidGeometryType | SphereGeometryType | ExtrusionGeometryType;
+
+declare type ParametricNormals = 'none' | 'flat' | 'smooth';
+
+declare type ParametricUvs = 'none' | 'automatic' | 'spherical';
+
+declare interface Plane {
+    position: Vector3;
+    normal: Vector3;
+}
+
+declare class PlaneGeometry extends ParametricGeometryBase {
+    type: PlaneGeometryType;
+    normal: Vector3;
+    size: number;
+    doubleSided: boolean;
+    constructor(id: string);
+}
+
+declare interface PlaneGeometryJson extends ParametricGeometryBaseJson {
+    type: PlaneGeometryType;
+    normal: Vector3;
+    size: number;
+    doubleSided: boolean;
+}
+
+declare type PlaneGeometryType = typeof PlaneGeometryTypeValue;
+
+declare const PlaneGeometryTypeValue = "geometry:plane";
+
+declare type Polygon = Vector2_2[];
+
+declare interface PolygonCurve extends CurveBase {
+    type: PolygonCurveType;
+    points: Vector2[];
+}
+
+declare interface PolygonCurve_2 extends BaseShape {
+    type: 'curve:polygon';
+    points: Polygon;
+}
+
+declare type PolygonCurveType = typeof PolygonCurveTypeValue;
+
+declare const PolygonCurveTypeValue = "curve:polygon";
+
+/** outer ring counter clockwise, inner rings ( holes ) clockwise */
+declare type PolygonWithHoles = Polygon[];
+
+declare interface PolygonWithHolesCurve extends CurveBase {
+    type: PolygonWithHolesCurveType;
+    polygons: Vector2[][];
+}
+
+declare interface PolygonWithHolesCurve_2 extends BaseShape {
+    type: 'curve:polygonWithHoles';
+    polygons: PolygonWithHoles;
+}
+
+declare type PolygonWithHolesCurveType = typeof PolygonWithHolesCurveTypeValue;
+
+declare const PolygonWithHolesCurveTypeValue = "curve:polygonWithHoles";
+
+declare interface PolylineCurve extends CurveBase {
+    type: PolylineCurveType;
+    points: Vector2[];
+}
+
+declare interface PolylineCurve_2 extends BaseShape {
+    type: 'curve:polyline';
+    points: Polygon;
+}
+
+declare type PolylineCurveType = typeof PolylineCurveTypeValue;
+
+declare const PolylineCurveTypeValue = "curve:polyline";
+
+declare type PositionEntry = Vector3 | Vector3List | Vector3Range;
+
+declare type PositionValue = {
+    position: Vector2;
+};
+
+declare class ProductCreate extends OperationBase {
+    type: typeof ProductCreateTypeValue;
+    value: ProductCreateValue;
+    constructor(value: ProductCreateValue);
+    do(layout: SpaceGraphLayout): void;
+    undo(layout: SpaceGraphLayout): void;
+}
+
+declare type ProductCreateOperationJson = Pick<ProductCreate, 'type' | 'value'>;
+
+declare const ProductCreateTypeValue: "operation:productCreate";
+
+declare type ProductCreateValue = SpaceGraphProductJson;
+
+export declare interface ProductData extends BaseData {
+    type: SpaceGraphProduct['type'];
+    attributes: {
+        category: string;
+        subCategory: string;
+    };
+}
+
+declare class ProductRemove extends OperationBase {
+    type: typeof ProductRemoveTypeValue;
+    value: ProductRemoveValue;
+    previousValue: ProductRemoveValue;
+    constructor(node: SpaceGraphProduct | string, previousValue?: ProductRemoveValue);
+    do(layout: SpaceGraphLayout): void;
+    undo(layout: SpaceGraphLayout): void;
+}
+
+declare type ProductRemoveOperationJson = Pick<ProductRemove, 'nodeId' | 'type'> & Partial<Pick<ProductRemove, 'previousValue'>>;
+
+declare const ProductRemoveTypeValue: "operation:productRemove";
+
+declare type ProductRemoveValue = SpaceGraphProductJson;
+
+declare class ProductUpdate extends OperationBase {
+    type: typeof ProductUpdateTypeValue;
+    value: ProductUpdateValue;
+    constructor(node: SpaceGraphProduct | string, value: ProductUpdateValue, previousValue?: ProductUpdateValue);
+    private setPreviousValue;
+    do(layout: SpaceGraphLayout): void;
+    undo(layout: SpaceGraphLayout): void;
+}
+
+declare type ProductUpdateOperationJson = Pick<ProductUpdate, 'nodeId' | 'type' | 'value'> & Partial<Pick<ProductUpdate, 'previousValue'>>;
+
+declare const ProductUpdateTypeValue: "operation:productUpdate";
+
+declare type ProductUpdateValue = Partial<SpaceGraphProductJson>;
+
+declare interface RectangleCurve extends CurveBase {
+    type: RectangleCurveType;
+    dimensions: Vector2;
+}
+
+declare interface RectangleCurve_2 extends BaseShape {
+    type: 'curve:rectangle';
+    position: Vector2_2;
+    dimensions: [number, number];
+}
+
+declare type RectangleCurveType = typeof RectangleCurveTypeValue;
+
+declare const RectangleCurveTypeValue = "curve:rectangle";
+
+declare type RecursivePartial<T> = T extends Array<any> ? {
+    [K in keyof T]: RecursivePartial<T[K]>;
+} : T extends object ? {
+    [P in keyof T]?: RecursivePartial<T[P]>;
+} : T;
+
+declare class RelationCreate extends OperationBase {
+    type: typeof RelationCreateTypeValue;
+    value: SpaceGraphRelationJson;
+    constructor(value: SpaceGraphRelationJson);
+    do(layout: SpaceGraphLayout): void;
+    undo(layout: SpaceGraphLayout): void;
+}
+
+declare type RelationCreateOperationJson = Pick<RelationCreate, 'type' | 'value'>;
+
+declare const RelationCreateTypeValue: "operation:relationCreate";
+
+declare class RelationInsertNodes extends OperationBase {
+    type: typeof RelationInsertNodesTypeValue;
+    value: RelationInsertNodesValue;
+    constructor(node: SpaceGraphRelation | string, value: RelationInsertNodesValue);
+    do(layout: SpaceGraphLayout): void;
+    undo(layout: SpaceGraphLayout): void;
+}
+
+declare type RelationInsertNodesOperationJson = Pick<RelationInsertNodes, 'nodeId' | 'type' | 'value'>;
+
+declare const RelationInsertNodesTypeValue: "operation:relationInsertNodes";
+
+declare type RelationInsertNodesValue = string[];
+
+declare class RelationRemove extends OperationBase {
+    type: typeof RelationRemoveTypeValue;
+    previousValue: SpaceGraphRelationJson;
+    constructor(node: SpaceGraphRelation | string, previousValue?: SpaceGraphRelationJson);
+    do(layout: SpaceGraphLayout): void;
+    undo(layout: SpaceGraphLayout): void;
+}
+
+declare class RelationRemoveNodes extends OperationBase {
+    type: typeof RelationRemoveNodesTypeValue;
+    value: RelationRemoveNodesValue;
+    constructor(node: SpaceGraphRelation | string, value: RelationRemoveNodesValue);
+    do(layout: SpaceGraphLayout): void;
+    undo(layout: SpaceGraphLayout): void;
+}
+
+declare type RelationRemoveNodesOperationJson = Pick<RelationRemoveNodes, 'nodeId' | 'type' | 'value'>;
+
+declare const RelationRemoveNodesTypeValue: "operation:relationRemoveNodes";
+
+declare type RelationRemoveNodesValue = string[];
+
+declare type RelationRemoveOperationJson = Pick<RelationRemove, 'nodeId' | 'type'> & Partial<Pick<RelationRemove, 'previousValue'>>;
+
+declare const RelationRemoveTypeValue: "operation:relationRemove";
+
+declare class RelationUpdate extends OperationBase {
+    type: typeof RelationUpdateTypeValue;
+    value: RelationUpdateValue;
+    previousValue: RelationUpdateValue;
+    constructor(node: SpaceGraphRelation | string, value: RelationUpdateValue, previousValue?: RelationUpdateValue);
+    private setPreviousValue;
+    private update;
+    do(layout: SpaceGraphLayout): void;
+    undo(layout: SpaceGraphLayout): void;
+}
+
+declare type RelationUpdateOperationJson = Pick<RelationUpdate, 'nodeId' | 'type' | 'value'> & Partial<Pick<RelationUpdate, 'previousValue'>>;
+
+declare const RelationUpdateTypeValue: "operation:relationUpdate";
+
+declare type RelationUpdateValue = Omit<Partial<SpaceGraphRelationJson>, 'type'>;
+
+/**
+ * An object representing methods exposed by the remote but that can be called
+ * locally.
+ */
+export declare type RemoteProxy<TMethods extends Methods = Methods> = {
+    [K in keyof TMethods]: TMethods[K] extends (...args: infer A) => infer R ? (...args: [...A, CallOptions?]) => Promise<ExtractValueFromReply<Awaited<R>>> : TMethods[K] extends Methods ? RemoteProxy<TMethods[K]> : never;
+};
+
+declare class Reply<T = unknown> {
+    #private;
+    readonly value: T;
+    readonly transferables?: Transferable[];
+    constructor(value: T, options?: {
+        transferables?: Transferable[];
+    });
+}
+
+declare type Rgb = [number, number, number];
+
+declare type RgbA = [number, number, number, number];
+
+declare type RotationEntry = number | NumberList | NumberRange;
+
+declare interface SelectionResponse extends HostResponse {
+    data: {
+        selectedNodes: NodeSelection;
+    };
+}
+
+declare type Shape = PolygonCurve_2 | PolygonWithHolesCurve_2 | PolylineCurve_2 | RectangleCurve_2 | CircleCurve_2 | LineCurve_2 | GroupShape | TextShape | ArcCurve_2 | BezierCurve | CompositeCurve_2;
+
+declare interface ShapeStyle {
+    stroke?: string | number | number[];
+    strokeWidth?: number | 'native';
+    strokeOpacity?: number;
+    fill?: string | number | number[] | false;
+    fillOpacity?: number;
+    dash?: boolean;
+    alignment?: 0 | 0.5 | 1;
+}
+
+declare class SpaceCreate extends OperationBase {
+    type: typeof SpaceCreateTypeValue;
+    value: SpaceCreateValue;
+    constructor(value: SpaceCreateValue);
+    do(layout: SpaceGraphLayout): void;
+    undo(layout: SpaceGraphLayout): void;
+}
+
+declare type SpaceCreateOperationJson = Pick<SpaceCreate, 'type' | 'value'>;
+
+declare const SpaceCreateTypeValue: "operation:spaceCreate";
+
+declare type SpaceCreateValue = LayoutSpaceJson;
+
+export declare interface SpaceData extends BaseData {
+    type: LayoutSpaceJson['type'];
+    attributes: {
+        category: string;
+        subCategory: string;
+    };
+    area: number;
+    labelPoint: Vector2;
+    polygons: PolygonWithHoles;
+    elements: ElementData[];
+}
+
+declare class SpaceGraph {
+    spatialStructure: SpaceGraphSpatialStructure;
+    products: SpaceGraphProduct[];
+    productsById: Record<string, SpaceGraphProduct>;
+    productsByType: NodesByType<{
+        readonly 'product:static': typeof SpaceGraphProduct;
+    }>;
+    customAttributes: SpaceGraphCustomAttribute[];
+    customAttributesById: Record<string, SpaceGraphCustomAttribute>;
+    customAttributesByType: NodesByType<{
+        readonly 'customAttribute:definition': typeof SpaceGraphCustomAttribute;
+    }>;
+    geometries: SpaceGraphGeometryJson[];
+    geometriesById: Record<string, SpaceGraphGeometryJson>;
+    geometriesByType: NodesByType<{
+        readonly 'geometry:plane': PlaneGeometry;
+        readonly 'geometry:cuboid': CuboidGeometry;
+        readonly 'geometry:sphere': SphereGeometry;
+        readonly 'geometry:extrusion': ExtrusionGeometry;
+        readonly 'geometry:mesh': MeshGeometry;
+        readonly 'geometry:uri': UriGeometry;
+    }>;
+    materials: SpaceGraphMaterial[];
+    materialsById: Record<string, SpaceGraphMaterial>;
+    materialsByType: NodesByType<{
+        readonly 'material:embedded': typeof SpaceGraphEmbeddedMaterial;
+        readonly 'material:basic': typeof SpaceGraphBasicMaterial;
+        readonly 'material:color': typeof SpaceGraphColorMaterial;
+        readonly 'material:standard': typeof SpaceGraphStandardMaterial;
+    }>;
+    relations: SpaceGraphRelation[];
+    relationsById: Record<string, SpaceGraphRelation>;
+    relationsByType: NodesByType<{
+        readonly 'relation:group': typeof GroupRelation;
+    }>;
+    nodes: SpaceGraphNode[];
+    nodesById: Record<string, SpaceGraphNode>;
+    nodesByType: NodesByType<{
+        readonly 'spatialStructure:building': typeof SpaceGraphBuilding;
+        readonly 'spatialStructure:floor': typeof SpaceGraphFloor;
+        readonly 'spatialStructure:layout': typeof SpaceGraphLayout;
+        readonly 'relation:group': typeof GroupRelation;
+        readonly 'product:static': typeof SpaceGraphProduct;
+        readonly 'material:embedded': typeof SpaceGraphEmbeddedMaterial;
+        readonly 'material:basic': typeof SpaceGraphBasicMaterial;
+        readonly 'material:color': typeof SpaceGraphColorMaterial;
+        readonly 'material:standard': typeof SpaceGraphStandardMaterial;
+        readonly 'geometry:plane': PlaneGeometry;
+        readonly 'geometry:cuboid': CuboidGeometry;
+        readonly 'geometry:sphere': SphereGeometry;
+        readonly 'geometry:extrusion': ExtrusionGeometry;
+        readonly 'geometry:mesh': MeshGeometry;
+        readonly 'geometry:uri': UriGeometry;
+        readonly 'spatialGraph:edge': SpatialGraphEdge;
+        readonly 'spatialGraph:vertex': SpatialGraphVertex;
+        readonly 'layout:space': LayoutSpace;
+        readonly 'view:2d': Layout2dView;
+        readonly 'view:3d': Layout3dView;
+        readonly 'annotation:floorPlanDxf': LayoutFloorPlanDxfAnnotation;
+        readonly 'annotation:floorPlanImage': LayoutFloorPlanImageAnnotation;
+        readonly 'element:ceiling': LayoutBoundarySlab;
+        readonly 'element:floor': LayoutBoundarySlab;
+        readonly 'element:boundaryWall': LayoutBoundaryWall;
+        readonly 'element:curtainWall': LayoutCurtainWall;
+        readonly 'element:spaceDivider': LayoutSpaceDivider;
+        readonly 'element:wall': LayoutWall;
+        readonly 'element:opening': LayoutOpening;
+        readonly 'element:asset': LayoutAsset;
+        readonly 'element:beam': LayoutBeam;
+        readonly 'element:casework': LayoutCasework;
+        readonly 'element:column': LayoutColumn;
+        readonly 'element:door': LayoutDoor;
+        readonly 'element:generic': LayoutGeneric;
+        readonly 'element:kitchen': LayoutKitchen;
+        readonly 'element:railing': LayoutRailing;
+        readonly 'element:ramp': LayoutRamp;
+        readonly 'element:roof': LayoutRoof;
+        readonly 'element:slab': LayoutSlab;
+        readonly 'element:stairs': LayoutStairs;
+        readonly 'element:stairFlight': LayoutStairFlight;
+        readonly 'element:window': LayoutWindow;
+    }>;
+    sourceSchemaVersion: string | undefined;
+    private emitter;
+    constructor(sourceSchemaVersion?: string);
+    getEvents(): Record<string, Function>;
+    copyEvents(spaceGraph: SpaceGraph): void;
+    deleteNodeAtIndex(nodeIndex: number, nodes: SpaceGraphNode[], nodesById: Record<string, SpaceGraphNode>, nodesByType: NodesByType<Record<string, SpaceGraphNode>>): SpaceGraphNode | undefined;
+    insertNode(node: SpaceGraphNode, nodes: SpaceGraphNode[], nodesById: Record<string, SpaceGraphNode>, nodesByType: NodesByType<Record<string, SpaceGraphNode>>): void;
+    removeNode(node: SpaceGraphNode, nodes: SpaceGraphNode[], nodesById: Record<string, SpaceGraphNode>, nodesByType: NodesByType<Record<string, SpaceGraphNode>>): SpaceGraphNode | undefined;
+    registerNode(node: SpaceGraphNode): void;
+    unregisterNode(node: SpaceGraphNode): void;
+    insertSpatialStructure(spatialStructure: SpaceGraphSpatialStructure): void;
+    removeSpatialStructure(): SpaceGraphSpatialStructure | undefined;
+    createSpatialStructure(type: SpaceGraphBuildingType, id: string): SpaceGraphBuilding;
+    createSpatialStructure(type: SpaceGraphFloorType, id: string): SpaceGraphFloor;
+    createSpatialStructure(type: LayoutType, id: string): SpaceGraphLayout;
+    createSpatialStructure(type: SpaceGraphSpatialStructureType, id: string): SpaceGraphSpatialStructure;
+    insertProduct(product: SpaceGraphProduct): void;
+    removeProduct(product: SpaceGraphProduct): void;
+    createProduct(id: string): SpaceGraphProduct;
+    insertGeometry(geometryJson: SpaceGraphGeometryJson): void;
+    removeGeometry(geometryJson: SpaceGraphGeometryJson): void;
+    insertMaterial(material: SpaceGraphMaterial): void;
+    removeMaterial(material: SpaceGraphMaterial): void;
+    createMaterial(type: SpaceGraphColorMaterialType, id: string, color: Rgb, opacity: number): SpaceGraphColorMaterial;
+    createMaterial(type: SpaceGraphStandardMaterialType, id: string, reference: string): SpaceGraphStandardMaterial;
+    createMaterial(type: SpaceGraphEmbeddedMaterialType, id: string, reference: string, format: SpaceGraphEmbeddedMaterialFormat): SpaceGraphEmbeddedMaterial;
+    createMaterial(type: SpaceGraphBasicMaterialType, id: string): SpaceGraphBasicMaterial;
+    insertRelation(relation: SpaceGraphRelation): void;
+    removeRelation(relation: SpaceGraphRelation): void;
+    createRelation(type: SpaceGraphRelationType, id: string): SpaceGraphRelation;
+    insertCustomAttribute(customAttribute: SpaceGraphCustomAttribute): void;
+    removeCustomAttribute(customAttribute: SpaceGraphCustomAttribute): void;
+    getId(): string;
+    emit<EventType extends keyof SpaceGraphEventMap>(event: EventType, ...args: SpaceGraphEventMap[EventType]): void;
+    on<EventType extends keyof SpaceGraphEventMap>(event: EventType, handler: (...args: SpaceGraphEventMap[EventType]) => void, context?: any): void;
+    once<EventType extends keyof SpaceGraphEventMap>(event: EventType, handler: (...args: SpaceGraphEventMap[EventType]) => void, context?: any): void;
+    off<EventType extends keyof SpaceGraphEventMap>(event: EventType, handler?: (...args: SpaceGraphEventMap[EventType]) => void): void;
+    toJSON(): SpaceGraphJson;
+}
+
+declare class SpaceGraphBasicMaterial extends SpaceGraphNodeBase {
+    type: SpaceGraphBasicMaterialType;
+    colorDiffuse: Rgb;
+    colorSpecular: Rgb;
+    specularCoefficient: number;
+    opacity: number;
+    constructor(id: string);
+    copyForClone(material: SpaceGraphBasicMaterial): void;
+    toJSON(): SpaceGraphMaterialResourceJson;
+}
+
+declare interface SpaceGraphBasicMaterialJson extends SpaceGraphMaterialBaseJson {
+    type: SpaceGraphBasicMaterialType;
+    colorDiffuse: Rgb;
+    colorSpecular?: Rgb;
+    specularCoefficient?: number;
+    opacity?: number;
+}
+
+declare type SpaceGraphBasicMaterialType = typeof SpaceGraphBasicMaterialTypeValue;
+
+declare const SpaceGraphBasicMaterialTypeValue = "material:basic";
+
+declare class SpaceGraphBuilding extends SpaceGraphSpatialStructureBase {
+    type: SpaceGraphBuildingType;
+    location: SpaceGraphLocation;
+    floors: SpaceGraphFloor[];
+    constructor(id: string);
+    copyForClone(building: SpaceGraphBuilding): void;
+    insertFloor(floor: SpaceGraphFloor): void;
+    removeFloor(floor: SpaceGraphFloor): void;
+    createFloor(id: string): SpaceGraphFloor;
+    toJSON(): SpaceGraphBuildingJson;
+}
+
+declare interface SpaceGraphBuildingJson extends SpaceGraphSpatialStructureBaseJson {
+    type: SpaceGraphBuildingType;
+    location?: SpaceGraphLocation;
+    floors: SpaceGraphFloorJson[];
+}
+
+declare type SpaceGraphBuildingType = typeof SpaceGraphBuildingTypeValue;
+
+declare const SpaceGraphBuildingTypeValue = "spatialStructure:building";
+
+declare class SpaceGraphColorMaterial extends SpaceGraphNodeBase {
+    type: SpaceGraphColorMaterialType;
+    color: Rgb;
+    opacity: number;
+    constructor(id: string, color?: Rgb, opacity?: number);
+    toJSON(): SpaceGraphMaterialResourceJson;
+}
+
+declare interface SpaceGraphColorMaterialJson extends SpaceGraphMaterialBaseJson {
+    type: SpaceGraphColorMaterialType;
+    value: Rgb | RgbA | string;
+}
+
+declare type SpaceGraphColorMaterialType = typeof SpaceGraphColorMaterialTypeValue;
+
+declare const SpaceGraphColorMaterialTypeValue = "material:color";
+
+declare class SpaceGraphCustomAttribute extends SpaceGraphNodeBase {
+    type: SpaceGraphCustomAttributeType;
+    attributes: SpaceGraphCustomAttributeAttributes;
+    constructor(id: string, attributesJson?: SpaceGraphCustomAttributeAttributesJson);
+    getInputType(): CustomAttributeInputType;
+    setAttributes(attributesJson: SpaceGraphCustomAttributeAttributesJson): void;
+    copyForClone(customAttribute: SpaceGraphCustomAttribute): void;
+    toJSON(): SpaceGraphCustomAttributeJson;
+}
+
+declare type SpaceGraphCustomAttributeAttributes = {
+    resourceType: CustomAttributeResourceType;
+    schema: CustomAttributeSchema;
+    updatedAt?: string;
+    description?: string;
+};
+
+declare type SpaceGraphCustomAttributeAttributesJson = {
+    resourceType: CustomAttributeResourceType;
+    valueType?: CustomAttributeValueType;
+    schema?: CustomAttributeSchema;
+    updatedAt?: string;
+    /** @minLength 3 @maxLength 200 @type string */
+    description?: string;
+};
+
+declare interface SpaceGraphCustomAttributeJson extends SpaceGraphNodeBaseJson {
+    /** @type string @minLength 3 @maxLength 70 @pattern ^(?![_-])[A-Za-z0-9_:-]*$ */
+    id: string;
+    /** @minLength 3 @maxLength 30 @type string */
+    name: string;
+    type: SpaceGraphCustomAttributeType;
+    attributes: SpaceGraphCustomAttributeAttributesJson;
+}
+
+declare type SpaceGraphCustomAttributeType = typeof SpaceGraphCustomAttributeTypeValue;
+
+declare const SpaceGraphCustomAttributeTypeValue = "customAttribute:definition";
+
+declare type SpaceGraphCustomAttributeValue = Record<string, string | boolean | number>;
+
+declare type SpaceGraphCustomAttributeValueJson = Record<string, string | boolean | number | null>;
+
+declare class SpaceGraphEmbeddedMaterial extends SpaceGraphNodeBase {
+    type: SpaceGraphEmbeddedMaterialType;
+    reference: string;
+    format: SpaceGraphEmbeddedMaterialFormat;
+    constructor(id: string, reference: string, format: SpaceGraphEmbeddedMaterialFormat);
+    toJSON(): SpaceGraphMaterialResourceJson;
+}
+
+declare type SpaceGraphEmbeddedMaterialFormat = 'data3d';
+
+declare type SpaceGraphEmbeddedMaterialType = typeof SpaceGraphEmbeddedMaterialTypeValue;
+
+declare const SpaceGraphEmbeddedMaterialTypeValue = "material:embedded";
+
+declare interface SpaceGraphEventMap {
+    'spatial-structure-create': [SpaceGraphSpatialStructure];
+    'spatial-structure-delete': [SpaceGraphSpatialStructure];
+    'product-create': [SpaceGraphProduct];
+    'product-delete': [SpaceGraphProduct];
+    'material-create': [SpaceGraphMaterial];
+    'material-delete': [SpaceGraphMaterial];
+    'relation-create': [SpaceGraphRelation];
+    'relation-delete': [SpaceGraphRelation];
+    'custom-attribute-create': [SpaceGraphCustomAttribute];
+    'custom-attribute-delete': [SpaceGraphCustomAttribute];
+    'node-id-change': [SpaceGraphNodeBase, string];
+    'node-property-change': [SpaceGraphNodeBase, string];
+    'node-custom-attributes-change': [SpaceGraphNodeBase];
+    'vertex-create': [SpatialGraphVertex];
+    'vertex-delete': [SpatialGraphVertex];
+    'vertex-add-edge': [SpatialGraphVertex, SpatialGraphEdge];
+    'vertex-remove-edge': [SpatialGraphVertex, SpatialGraphEdge];
+    'vertex-set-position': [SpatialGraphVertex];
+    'edge-create': [SpatialGraphEdge];
+    'edge-delete': [SpatialGraphEdge];
+    'edge-set-vertices': [SpatialGraphEdge, {
+        previousVertices: [SpatialGraphVertex, SpatialGraphVertex];
+    }];
+    'space-create': [LayoutSpace];
+    'space-delete': [LayoutSpace];
+    'space-split': [LayoutSpace, [LayoutSpace, LayoutSpace]];
+    'space-attributes-change': [LayoutSpace];
+    'element-create': [LayoutElement];
+    'element-delete': [LayoutElement, LayoutElement | null];
+    'element-parameters-change': [LayoutElementBase];
+    'element-transform-change': [LayoutTransformElementBase];
+    'element-edges-change': [LayoutEdgeElementBase];
+    'annotation-create': [LayoutAnnotation];
+    'annotation-delete': [LayoutAnnotation];
+    'annotation-transform-change': [LayoutAnnotationBase];
+    'annotation-parameters-change': [LayoutAnnotationBase];
+    'view-create': [LayoutView];
+    'view-delete': [LayoutView];
+    'view-parameters-change': [LayoutViewBase];
+    'geometry-update': [LayoutElement];
+    'geometry-profile-update': [LayoutSpace | LayoutElement];
+}
+
+declare class SpaceGraphFloor extends SpaceGraphSpatialStructureBase {
+    type: SpaceGraphFloorType;
+    parent: SpaceGraphBuilding | null;
+    position: Vector3;
+    rotation: number;
+    layouts: SpaceGraphLayout[];
+    constructor(id: string);
+    copyForClone(floor: SpaceGraphFloor): void;
+    insertLayout(layout: SpaceGraphLayout): void;
+    removeLayout(layout: SpaceGraphLayout): void;
+    createLayout(id: string): SpaceGraphLayout;
+    toJSON(): SpaceGraphFloorJson;
+}
+
+declare interface SpaceGraphFloorJson extends SpaceGraphSpatialStructureBaseJson {
+    type: SpaceGraphFloorType;
+    position: Vector3;
+    rotation: number;
+    layouts: SpaceGraphLayoutJson[];
+}
+
+declare type SpaceGraphFloorType = typeof SpaceGraphFloorTypeValue;
+
+declare const SpaceGraphFloorTypeValue = "spatialStructure:floor";
+
+declare type SpaceGraphGeometry = ParametricGeometry | MeshGeometry | UriGeometry;
+
+declare type SpaceGraphGeometryJson = ParametricGeometryJson | MeshGeometryJson | UriGeometryJson;
+
+declare type SpaceGraphGeometryType = ParametricGeometryType | MeshGeometryType | UriGeometryType;
+
+declare interface SpaceGraphJson {
+    schemaVersion: string;
+    spatialStructure: SpaceGraphSpatialStructureJson;
+    sharedResources: SpaceGraphSharedResourcesJson;
+}
+
+declare class SpaceGraphLayout extends SpaceGraphSpatialStructureBase {
+    type: LayoutType;
+    parent: SpaceGraphFloor | null;
+    spatialGraph: LayoutSpatialGraph;
+    spaces: LayoutSpace[];
+    spacesById: Record<string, LayoutSpace>;
+    elements: LayoutElement[];
+    elementsById: Record<string, LayoutElement>;
+    elementsByType: NodesByType<    {
+        readonly 'element:ceiling': typeof LayoutBoundarySlab;
+        readonly 'element:floor': typeof LayoutBoundarySlab;
+        readonly 'element:boundaryWall': typeof LayoutBoundaryWall;
+        readonly 'element:curtainWall': LayoutCurtainWall;
+        readonly 'element:spaceDivider': LayoutSpaceDivider;
+        readonly 'element:wall': LayoutWall;
+        readonly 'element:opening': typeof LayoutOpening;
+        readonly 'element:asset': LayoutAsset;
+        readonly 'element:beam': LayoutBeam;
+        readonly 'element:casework': LayoutCasework;
+        readonly 'element:column': LayoutColumn;
+        readonly 'element:door': LayoutDoor;
+        readonly 'element:generic': LayoutGeneric;
+        readonly 'element:kitchen': LayoutKitchen;
+        readonly 'element:railing': LayoutRailing;
+        readonly 'element:ramp': LayoutRamp;
+        readonly 'element:roof': LayoutRoof;
+        readonly 'element:slab': LayoutSlab;
+        readonly 'element:stairs': LayoutStairs;
+        readonly 'element:stairFlight': LayoutStairFlight;
+        readonly 'element:window': LayoutWindow;
+    }>;
+    annotations: LayoutAnnotation[];
+    annotationsById: Record<string, LayoutAnnotation>;
+    annotationsByType: NodesByType<    {
+        readonly 'annotation:floorPlanDxf': LayoutFloorPlanDxfAnnotation;
+        readonly 'annotation:floorPlanImage': LayoutFloorPlanImageAnnotation;
+    }>;
+    views: LayoutView[];
+    viewsById: Record<string, LayoutView>;
+    viewsByType: NodesByType<    {
+        readonly 'view:2d': Layout2dView;
+        readonly 'view:3d': Layout3dView;
+    }>;
+    debugIds: boolean;
+    suggestedIds: Record<string, boolean>;
+    constructor(id: string);
+    copyForClone(layout: SpaceGraphLayout): void;
+    insertSpace(space: LayoutSpace): void;
+    removeSpace(space: LayoutSpace): LayoutSpace | undefined;
+    createSpace(id: string, boundaries: LayoutBoundary[]): LayoutSpace;
+    insertElement(element: LayoutElement): void;
+    removeElement(element: LayoutElement): LayoutElement | undefined;
+    createElement(type: LayoutOpeningType, id: string): LayoutOpening;
+    createElement(type: LayoutBoundarySlabType, id: string, boundaries: LayoutBoundary[]): LayoutBoundarySlab;
+    createElement(type: LayoutBoundaryWallType, id: string, boundaries: LayoutBoundary[]): LayoutBoundaryWall;
+    createElement<T extends LayoutEdgeElementType>(type: T, id: string, edges: SpatialGraphEdge[]): EdgeElementMap[T];
+    createElement<T extends LayoutTransformElementType>(type: T, id: string): TransformElementMap[T];
+    insertNode(node: LayoutAnnotation | LayoutView): void;
+    removeNode(node: LayoutAnnotation | LayoutView): void;
+    insertAnnotation(annotation: LayoutAnnotation): void;
+    removeAnnotation(annotation: LayoutAnnotation): LayoutAnnotation | undefined;
+    createAnnotation(type: LayoutAnnotationType, id: string): LayoutAnnotation;
+    insertView(view: LayoutView): void;
+    removeView(view: LayoutView): LayoutView;
+    createView(type: LayoutViewType, id: string): LayoutView;
+    clearSpaces(): void;
+    getElementList(): LayoutElement[];
+    getArea(filter?: {
+        program?: {
+            exclude?: string[];
+            include?: string[];
+        };
+    }): number;
+    getLayoutGraph(): Graph;
+    getUniqueId(prefix: string, nodesById: Record<string, SpaceGraphNode>): string;
+    getSpaceId(prefix?: string): string;
+    getElementId(element: LayoutElement, prefix?: string): string;
+    getBoundingBox(): TransformBoundingBox3d;
+    toJSON(): SpaceGraphLayoutJson;
+}
+
+declare interface SpaceGraphLayoutJson extends SpaceGraphSpatialStructureBaseJson {
+    type: LayoutType;
+    spatialGraph: LayoutSpatialGraphJson;
+    spaces: LayoutSpaceJson[];
+    elements: LayoutElementJson[];
+    annotations?: LayoutAnnotationJson[];
+    views?: LayoutViewJson[];
+}
+
+declare type SpaceGraphLocation = {
+    latLong: Vector2;
+    rotation: number;
+};
+
+declare type SpaceGraphMaterial = SpaceGraphColorMaterial | SpaceGraphStandardMaterial | SpaceGraphEmbeddedMaterial | SpaceGraphBasicMaterial;
+
+declare interface SpaceGraphMaterialBaseJson extends SpaceGraphNodeBaseJson {
+    id: string;
+}
+
+declare type SpaceGraphMaterialJson = Rgb | RgbA | string | SpaceGraphMaterialResourceJson;
+
+declare type SpaceGraphMaterialResourceJson = SpaceGraphColorMaterialJson | SpaceGraphStandardMaterialJson | SpaceGraphBasicMaterialJson;
+
+declare type SpaceGraphNode = SpaceGraphProduct | SpaceGraphGeometry | SpaceGraphMaterial | SpaceGraphRelation | SpaceGraphCustomAttribute | SpaceGraphBuilding | SpaceGraphFloor | LayoutNode | SpaceGraphLayout | LayoutAnnotation;
+
+declare class SpaceGraphNodeBase extends SpaceGraphTypedValue {
+    id: string;
+    name: string;
+    customId: string;
+    constructor(id: string, type: string);
+    copyForClone(node: SpaceGraphNode): void;
+    setName(name: string): void;
+    setCustomId(customId: string): void;
+    emit<EventType extends keyof SpaceGraphEventMap>(event: EventType, ...args: SpaceGraphEventMap[EventType]): void;
+    toJSON(): SpaceGraphNodeBaseJson;
+}
+
+declare interface SpaceGraphNodeBaseJson extends SpaceGraphTypedValueJson {
+    /** @format uuid */
+    id: string;
+    name?: string;
+    customId?: string;
+}
+
+declare type SpaceGraphNodeWithCustomAttributes = LayoutNode | SpaceGraphSpatialStructure | SpaceGraphProduct;
+
+declare class SpaceGraphNodeWithCustomAttributesBase extends SpaceGraphNodeBase {
+    customAttributes: SpaceGraphCustomAttributeValue;
+    constructor(id: string, type: string);
+    setCustomAttributes(customAttributes?: SpaceGraphCustomAttributeValueJson | null, customAttributesById?: Record<string, SpaceGraphCustomAttribute>): void;
+    toJSON(): SpaceGraphNodeWithCustomAttributesBaseJson;
+    copyForClone(node: SpaceGraphNodeWithCustomAttributes): void;
+}
+
+declare interface SpaceGraphNodeWithCustomAttributesBaseJson extends SpaceGraphNodeBaseJson {
+    customAttributes?: SpaceGraphCustomAttributeValueJson | null;
+}
+
+declare class SpaceGraphProduct extends SpaceGraphNodeWithCustomAttributesBase {
+    type: SpaceGraphProductType;
+    attributes: SpaceGraphProductAttributes;
+    geometries: GeometryOperationJson[];
+    constructor(id: string);
+    copyForClone(product: SpaceGraphProduct): void;
+    setAttributes(attributesJson: SpaceGraphProductAttributesJson): void;
+    toJSON(): SpaceGraphProductJson;
+}
+
+declare type SpaceGraphProductAttributes = {
+    manufacturer: string;
+    categories: string[];
+    subCategories: string[];
+    thumbnail: string;
+    boundingBox: BoundingBox3d;
+    seatCapacity: number;
+    updatedAt: string;
+};
+
+declare type SpaceGraphProductAttributesJson = {
+    manufacturer?: string;
+    categories?: string[];
+    subCategories?: string[];
+    thumbnail?: string;
+    boundingBox?: BoundingBox3d;
+    seatCapacity?: number;
+    updatedAt?: string;
+};
+
+declare interface SpaceGraphProductJson extends SpaceGraphNodeWithCustomAttributesBaseJson {
+    type: SpaceGraphProductType;
+    attributes?: SpaceGraphProductAttributesJson;
+    geometries: GeometryOperationJson[];
+}
+
+declare type SpaceGraphProductType = typeof SpaceGraphProductTypeValue;
+
+declare const SpaceGraphProductTypeValue = "product:static";
+
+declare type SpaceGraphRelation = GroupRelation;
+
+declare type SpaceGraphRelationJson = GroupRelationJson;
+
+declare type SpaceGraphRelationType = GroupRelationType;
+
+declare interface SpaceGraphSharedResourcesJson {
+    products: SpaceGraphProductJson[];
+    geometries: SpaceGraphGeometryJson[];
+    materials: SpaceGraphMaterialResourceJson[];
+    relations: SpaceGraphRelationJson[];
+    customAttributes?: SpaceGraphCustomAttributeJson[];
+}
+
+declare type SpaceGraphSpatialStructure = SpaceGraphBuilding | SpaceGraphFloor | SpaceGraphLayout;
+
+declare class SpaceGraphSpatialStructureBase extends SpaceGraphNodeWithCustomAttributesBase {
+    type: SpaceGraphSpatialStructureType;
+    constructor(id: string, type: SpaceGraphSpatialStructureType);
+}
+
+declare interface SpaceGraphSpatialStructureBaseJson extends SpaceGraphNodeWithCustomAttributesBaseJson {
+    type: SpaceGraphSpatialStructureType;
+}
+
+declare type SpaceGraphSpatialStructureJson = SpaceGraphBuildingJson | SpaceGraphFloorJson | SpaceGraphLayoutJson;
+
+declare type SpaceGraphSpatialStructureType = SpaceGraphBuildingType | SpaceGraphFloorType | LayoutType;
+
+declare class SpaceGraphStandardMaterial extends SpaceGraphNodeBase {
+    type: SpaceGraphStandardMaterialType;
+    reference: string;
+    constructor(id: string, reference: string);
+    toJSON(): SpaceGraphMaterialResourceJson;
+}
+
+declare interface SpaceGraphStandardMaterialJson extends SpaceGraphMaterialBaseJson {
+    type: SpaceGraphStandardMaterialType;
+    reference: string;
+}
+
+declare type SpaceGraphStandardMaterialType = typeof SpaceGraphStandardMaterialTypeValue;
+
+declare const SpaceGraphStandardMaterialTypeValue = "material:standard";
+
+declare class SpaceGraphTypedValue {
+    spaceGraph: SpaceGraph;
+    type: string;
+    constructor(type: string);
+}
+
+declare interface SpaceGraphTypedValueJson {
+    type: string;
+}
+
+declare class SpaceRemove extends OperationBase {
+    type: typeof SpaceRemoveTypeValue;
+    previousValue: SpaceRemoveValue;
+    constructor(node: LayoutSpace | string, previousValue?: SpaceRemoveValue);
+    do(layout: SpaceGraphLayout): void;
+    undo(layout: SpaceGraphLayout): void;
+}
+
+declare type SpaceRemoveOperationJson = Pick<SpaceRemove, 'nodeId' | 'type'> & Partial<Pick<SpaceRemove, 'previousValue'>>;
+
+declare const SpaceRemoveTypeValue: "operation:spaceRemove";
+
+declare type SpaceRemoveValue = LayoutSpaceJson;
+
+declare interface SpaceShapeStyle extends ShapeStyle {
+    usage?: {
+        [key: string]: ShapeStyle;
+    };
+    program?: {
+        [key: string]: ShapeStyle;
+    };
+}
+
+declare class SpaceUpdate extends OperationBase {
+    type: typeof SpaceUpdateTypeValue;
+    value: SpaceUpdateValue;
+    constructor(node: LayoutSpace | string, value: SpaceUpdateValue, previousValue?: SpaceUpdateValue);
+    private setPreviousValue;
+    private update;
+    do(layout: SpaceGraphLayout): void;
+    undo(layout: SpaceGraphLayout): void;
+}
+
+declare type SpaceUpdateOperationJson = Pick<SpaceUpdate, 'nodeId' | 'type' | 'value'> & Partial<Pick<SpaceUpdate, 'previousValue'>>;
+
+declare const SpaceUpdateTypeValue: "operation:spaceUpdate";
+
+declare type SpaceUpdateValue = Partial<LayoutSpaceJson>;
+
+declare class SpatialGraphEdge extends SpatialGraphNodeBase {
+    type: SpatialGraphEdgeType;
+    vertices: [SpatialGraphVertex, SpatialGraphVertex];
+    spaces: [LayoutSpace | null | undefined, LayoutSpace | null | undefined];
+    boundaryWalls: [LayoutBoundaryWall | null, LayoutBoundaryWall | null];
+    element: LayoutEdgeElement | null;
+    constructor(id: string, vertex1: SpatialGraphVertex, vertex2: SpatialGraphVertex);
+    getPoints(): [Vector2_2, Vector2_2];
+    getLength(): number;
+    get isExternal(): boolean;
+    setVertices(vertex1: SpatialGraphVertex, vertex2: SpatialGraphVertex): void;
+    setVerticesByIds(vertexId1: string, vertexId2: string): void;
+    canSplit(u: number, options?: EdgeCanSplitOptions): boolean;
+    split(u: number, options?: EdgeSplitOptions, updateSpaceBoundaries?: boolean): EdgeSplitReturnValue;
+    canMerge(edge: SpatialGraphEdge): boolean;
+    merge(edge: SpatialGraphEdge, updateSpaceBoundaries?: boolean): void;
+    toJSON(): SpatialGraphEdgeJson;
+}
+
+declare interface SpatialGraphEdgeJson extends SpatialGraphNodeBaseJson {
+    type: SpatialGraphEdgeType;
+    vertices: [string, string];
+}
+
+declare type SpatialGraphEdgeType = typeof SpatialGraphEdgeTypeValue;
+
+declare const SpatialGraphEdgeTypeValue = "spatialGraph:edge";
+
+declare type SpatialGraphNode_2 = SpatialGraphVertex | SpatialGraphEdge;
+
+declare class SpatialGraphNodeBase extends LayoutNodeBase {
+}
+
+declare interface SpatialGraphNodeBaseJson extends LayoutNodeBaseJson {
+}
+
+declare type SpatialGraphNodeType = SpatialGraphVertexType | SpatialGraphEdgeType;
+
+declare class SpatialGraphVertex extends SpatialGraphNodeBase {
+    type: SpatialGraphVertexType;
+    position: Vector2;
+    edges: SpatialGraphEdge[];
+    constructor(id: string, x: number, y: number);
+    sortVertexEdges(): void;
+    addEdge(edge: SpatialGraphEdge): void;
+    removeEdge(edge: SpatialGraphEdge): void;
+    setPosition(x: number, y: number): void;
+    toJSON(): SpatialGraphVertexJson;
+}
+
+declare interface SpatialGraphVertexJson extends SpatialGraphNodeBaseJson {
+    type: SpatialGraphVertexType;
+    position: Vector2;
+}
+
+declare type SpatialGraphVertexType = typeof SpatialGraphVertexTypeValue;
+
+declare const SpatialGraphVertexTypeValue = "spatialGraph:vertex";
+
+declare class SphereGeometry extends ParametricGeometryBase {
+    type: SphereGeometryType;
+    radius: number;
+    constructor(id: string);
+}
+
+declare interface SphereGeometryJson extends ParametricGeometryBaseJson {
+    type: SphereGeometryType;
+    radius: number;
+}
+
+declare type SphereGeometryType = typeof SphereGeometryTypeValue;
+
+declare const SphereGeometryTypeValue = "geometry:sphere";
+
+declare interface SpiralStairFlightParameters {
+    stairFlightType: 'spiral';
+    angle: number;
+    radius: number;
+    /** @minimum 0.01 */
+    width: number;
+    /** @minimum 0.01 */
+    height: number;
+    circulation: 'left' | 'right';
+    materials: LayoutStairFlightMaterials;
+}
+
+declare type SpiralStairFlightParametersJson = Partial<SpiralStairFlightParameters>;
+
+declare type SpiralStairsParameters = {
+    stairsType: SpiralStairsType;
+    radius: number;
+    angle: number;
+    /** @minimum 0.01 */
+    height: number;
+    /** @minimum 0.01 */
+    stepWidth: number;
+    circulation: 'left' | 'right';
+} & CommonStairsParameters;
+
+declare type SpiralStairsParametersJson = Partial<SpiralStairsParameters>;
+
+declare type SpiralStairsType = 'spiral';
+
+declare type StraightStairFlightParameters = {
+    stairFlightType: 'straight';
+    materials: LayoutStairFlightMaterials;
+} & DimensionParameters;
+
+declare type StraightStairFlightParametersJson = Partial<StraightStairFlightParameters>;
+
+declare type StraightStairsParameters = {
+    stairsType: StraightStairsType;
+} & DimensionParameters & CommonStairsParameters;
+
+declare type StraightStairsParametersJson = Partial<StraightStairsParameters>;
+
+declare type StraightStairsType = 'straight' | 'straightLanding';
+
+declare interface SurfaceMaterials {
+    [surface: string]: SpaceGraphMaterial;
+}
+
+declare interface SurfaceMaterialsJson {
+    [surface: string]: SpaceGraphMaterialJson;
+}
+
+declare interface Surfaces {
+    [surface: string]: GeometryFaceIndices;
+}
+
+declare interface TextShape extends BaseShape {
+    type: 'text';
+    position: Vector2_2;
+    text: string;
+    rotation?: number;
+    alignV?: 'center' | 'bottom' | 'top';
+    alignH?: 'center' | 'left' | 'right';
+    fontSize?: number;
+}
+
+declare type Transform3d = {
+    position: Vector3;
+    rotation: number;
+    rotationAxis: Vector3;
+};
+
+declare type TransformBoundingBox3d = {
+    min: Vector3;
+    max: Vector3;
+    transform: Transform3d;
+};
+
+declare type TransformElementMap = {
+    'element:asset': LayoutAsset;
+    'element:beam': LayoutBeam;
+    'element:casework': LayoutCasework;
+    'element:column': LayoutColumn;
+    'element:door': LayoutDoor;
+    'element:kitchen': LayoutKitchen;
+    'element:railing': LayoutRailing;
+    'element:ramp': LayoutRamp;
+    'element:roof': LayoutRoof;
+    'element:slab': LayoutSlab;
+    'element:stairs': LayoutStairs;
+    'element:stairFlight': LayoutStairFlight;
+    'element:window': LayoutWindow;
+    'element:generic': LayoutGeneric;
+};
+
+declare class UriGeometry extends GeometryBase {
+    type: UriGeometryType;
+    format: UriGeometryFormat;
+    uri: string;
+    normals: ParametricNormals;
+    constructor(id: string);
+}
+
+declare type UriGeometryFormat = 'data3d';
+
+declare interface UriGeometryJson extends GeometryBaseJson {
+    type: UriGeometryType;
+    format: UriGeometryFormat;
+    uri: string;
+    normals?: ParametricNormals;
+}
+
+declare type UriGeometryType = typeof UriGeometryTypeValue;
+
+declare const UriGeometryTypeValue = "geometry:uri";
+
+declare type Vector2 = [number, number];
+
+declare type Vector2_2 = [number, number];
+
+declare type Vector3 = [number, number, number];
+
+declare interface Vector3List extends SpaceGraphTypedValueJson {
+    type: 'vector3:list';
+    list: Vector3[];
+}
+
+declare interface Vector3Range extends SpaceGraphTypedValueJson {
+    type: 'vector3:range';
+    range: {
+        start: Vector3;
+        step: Vector3;
+        count: number;
+    };
+}
+
+declare class VertexCreate extends OperationBase {
+    type: typeof VertexCreateTypeValue;
+    value: VertexValueType;
+    previousValue: null;
+    constructor(value: VertexValueType);
+    do(layout: SpaceGraphLayout): void;
+    undo(layout: SpaceGraphLayout): void;
+}
+
+declare type VertexCreateOperationJson = Pick<VertexCreate, 'type' | 'value'>;
+
+declare const VertexCreateTypeValue: "operation:vertexCreate";
+
+declare class VertexRemove extends OperationBase {
+    type: typeof VertexRemoveTypeValue;
+    previousValue: PositionValue;
+    constructor(vertex: SpatialGraphVertex | string, previousValue?: PositionValue);
+    setPreviousValue(layout: SpaceGraphLayout): void;
+    do(layout: SpaceGraphLayout): void;
+    undo(layout: SpaceGraphLayout): void;
+}
+
+declare type VertexRemoveOperationJson = Pick<VertexRemove, 'nodeId' | 'type'> & Partial<Pick<VertexRemove, 'previousValue'>>;
+
+declare const VertexRemoveTypeValue: "operation:vertexRemove";
+
+declare class VertexReplace extends OperationBase {
+    type: typeof VertexReplaceTypeValue;
+    value: VertexReplaceValue;
+    previousValue: SpatialGraphVertexJson;
+    constructor(vertex: SpatialGraphVertex | string, value: VertexReplaceValue, previousValue?: VertexReplaceValue);
+    setPreviousValue(layout: SpaceGraphLayout): void;
+    do(layout: SpaceGraphLayout): void;
+    undo(layout: SpaceGraphLayout): void;
+}
+
+declare type VertexReplaceOperationJson = Pick<VertexReplace, 'nodeId' | 'type' | 'value'> & Partial<Pick<VertexReplace, 'previousValue'>>;
+
+declare const VertexReplaceTypeValue: "operation:vertexReplace";
+
+declare type VertexReplaceValue = Pick<VertexValueType, 'id'> & Partial<VertexValueType>;
+
+declare class VertexUpdate extends OperationBase {
+    type: typeof VertexUpdateTypeValue;
+    value: PositionValue;
+    previousValue: PositionValue;
+    constructor(vertex: SpatialGraphVertex | string, value: PositionValue, previousValue?: PositionValue);
+    private setPreviousValue;
+    private update;
+    do(layout: SpaceGraphLayout): void;
+    undo(layout: SpaceGraphLayout): void;
+}
+
+declare type VertexUpdateOperationJson = Pick<VertexUpdate, 'nodeId' | 'type' | 'value'> & Partial<Pick<VertexUpdate, 'previousValue'>>;
+
+declare const VertexUpdateTypeValue: "operation:vertexUpdate";
+
+declare type VertexValueType = Omit<SpatialGraphVertexJson, 'type'>;
+
+declare class ViewCreate extends OperationBase {
+    type: typeof ViewCreateTypeValue;
+    value: LayoutViewJson;
+    constructor(value: LayoutViewJson);
+    do(layout: SpaceGraphLayout): void;
+    undo(layout: SpaceGraphLayout): void;
+}
+
+declare type ViewCreateOperationJson = Pick<ViewCreate, 'type' | 'value'>;
+
+declare const ViewCreateTypeValue: "operation:viewCreate";
+
+declare class ViewRemove extends OperationBase {
+    type: typeof ViewRemoveTypeValue;
+    previousValue: LayoutViewJson;
+    constructor(node: LayoutView | string, previousValue?: LayoutViewJson);
+    do(layout: SpaceGraphLayout): void;
+    undo(layout: SpaceGraphLayout): void;
+}
+
+declare type ViewRemoveOperationJson = Pick<ViewRemove, 'nodeId' | 'type'> & Partial<Pick<ViewRemove, 'previousValue'>>;
+
+declare const ViewRemoveTypeValue: "operation:viewRemove";
+
+declare class ViewUpdate extends OperationBase {
+    type: typeof ViewUpdateTypeValue;
+    value: ViewUpdateValue;
+    constructor(node: LayoutView | string, value: ViewUpdateValue, previousValue?: ViewUpdateValue);
+    private setPreviousValue;
+    private update;
+    do(layout: SpaceGraphLayout): void;
+    undo(layout: SpaceGraphLayout): void;
+}
+
+declare type ViewUpdateOperationJson = Pick<ViewUpdate, 'nodeId' | 'type' | 'value'> & Partial<Pick<ViewUpdate, 'previousValue'>>;
+
+declare const ViewUpdateTypeValue: "operation:viewUpdate";
+
+declare type ViewUpdateValue = Partial<LayoutViewJson> & {
+    parameters?: Partial<LayoutViewJson['parameters']>;
+};
+
+export { }