@archilogic/floor-plan-sdk 5.0.0-v5-scene-structure.0 → 5.0.1

package/dist/fpe.d.ts

@@ -1,1476 +1,3252 @@
-declare const validNodeTypes: readonly ["a:helper:spaceDivider", "a:reference:externalId", "a:reference:ifcElement", "a:reference:ifcFile", "a:relation:wall", "a:settings:display", "a:settings:generatedGroup", "box", "camera-bookmark", "closet", "column", "curtain", "door", "floor", "floorplan", "floorplanDxf", "group", "interior", "kitchen", "level", "object", "pic", "plan", "polybox", "polyfloor", "railing", "stairs", "tag", "wall", "window"];
-type NodeTypes = typeof validNodeTypes[number];
-type NodesByType = {
-    [K in NodeTypes]: SceneNode[];
-};
-
-declare class TinyEmitter$1 {
-  on(event: string, callback: Function, ctx?: any): this;
-  once(event: string, callback: Function, ctx?: any): this;
-  emit(event: string, ...args: any[]): this;
-  off(event: string, callback?: Function): this;
-}
-
-type Point2d = [number, number];
-type Polygon = Point2d[];
-type PolygonList = Polygon[];
-type BoundingBox2d = {
-    x: number;
-    z: number;
-    x2: number;
-    z2: number;
-    length: number;
-    width: number;
-};
-interface Vector2d {
-    x: number;
-    z: number;
-}
-interface Vector extends Vector2d {
-    y?: number;
-}
-interface Vector3d extends Vector {
-    x: number;
-    y: number;
-    z: number;
-}
-type ProductId = string;
-type ProductSrc = `!${ProductId}`;
-
-type RGBArray$1 = [number, number, number];
-interface MaterialDefinition {
-    size?: [number, number];
-    colorDiffuse?: RGBArray$1;
-    colorSpecular?: RGBArray$1;
-    specularCoef?: number;
-    mapDiffuse?: string;
-    mapDiffusePreview?: string;
-    mapDiffuseSource?: string;
-    mapDiffuseKey?: string;
-    mapSpecular?: string;
-    mapSpecularPreview?: string;
-    mapSpecularSource?: string;
-    mapSpecularKey?: string;
-    mapNormal?: string;
-    mapNormalPreview?: string;
-    mapNormalSource?: string;
-    mapNormalKey?: string;
-    mapAlpha?: string;
-    mapAlphaPreview?: string;
-    mapAlphaSource?: string;
-    mapAlphaKey?: string;
-    opacity?: number;
-    bsdfType?: string;
-    useInBaking?: boolean;
-    wrap?: 'repeat' | 'mirror';
-    receiveRealTimeShadows?: boolean;
-    castRealTimeShadows?: boolean;
-    hideAfterBaking?: boolean;
-    no2dOutline?: boolean;
-    wireframeThickness?: number;
-    wireframeThresholdAngle?: number;
-    wireframeColor?: RGBArray$1;
-    wireframeOpacity?: number;
-    lightEmissionCoef?: number;
-}
-type MaterialReference = string;
-type Material = MaterialDefinition | MaterialReference;
-interface SceneNodeMaterials {
-    [meshName: string]: Material;
-}
-
-declare class SceneNodeJson {
-    type?: NodeTypes;
-    id?: string;
-    x?: number;
-    y?: number;
-    z?: number;
-    ry?: number;
-    l?: number;
-    w?: number;
-    h?: number;
-    v?: string;
-    src?: ProductSrc;
-    polygon?: Polygon;
-    polygonHoles?: Polygon[];
-    locked?: boolean;
-    class?: string[];
-    usage?: string;
-    hCeiling?: number;
-    hasCeiling?: boolean;
-    materials?: SceneNodeMaterials;
-    name?: string;
-    customId?: string;
-    controlLine?: string;
-    baseHeight?: number;
-    backHasBase?: boolean;
-    frontHasBase?: boolean;
-    nodeIds?: {
-        [nodeId: string]: string;
-    };
-    nodeId?: string;
-    params?: {
-        [param: string]: any;
-    };
-    shape?: string;
-    doorType?: string;
-    doorAngle?: number;
-    doorWidth?: number;
-    side?: string;
-    hinge?: string;
-    threshold?: boolean;
-    thresholdHeight?: number;
-    leafWidth?: number;
-    leafOffset?: number;
-    frameOffset?: number;
-    fixLeafRatio?: number;
-    rowRatios?: number[];
-    columnRatios?: number[][];
-    frameWidth?: number;
-    frameLength?: number;
-    cooktopType?: string;
-    sinkType?: string;
-    sinkPos?: number;
-    cooktopPos?: number;
-    ovenPos?: number;
-    ovenType?: string;
-    baseBoard?: number;
-    highCabinetLeft?: number;
-    highCabinetRight?: number;
-    cabinetType?: string;
-    counterHeight?: number;
-    counterThickness?: number;
-    elementLength?: number;
-    wallCabinet?: boolean;
-    wallCabinetWidth?: number;
-    wallCabinetHeight?: number;
-    barCounter?: boolean;
-    fridge?: boolean;
-    fridgePos?: number;
-    microwave?: boolean;
-    microwavePos?: number;
-    extractorType?: string;
-    baseboard?: number;
-    handleWidth?: number;
-    handleHeight?: number;
-    handleLength?: number;
-    file?: string;
-    drawingOrigin?: number[];
-    drawingUnits?: 'kilometers' | 'meters' | 'centimeters' | 'millimeters' | 'miles' | 'feet' | 'inches';
-    hiddenLayers?: string[];
-    circulation?: string;
-    stairType?: string;
-    stepWidth?: number;
-    railing?: 'none' | 'left' | 'right' | 'both';
-    railingType?: 'verticalBars' | 'filling';
-    treadHeight?: number;
-    stepThickness?: number;
-    segmentation?: string;
-    pailing?: number;
-    segments?: number;
-    segmentDistance?: number;
-    railCount?: number;
-    rx?: number;
-    distance?: number;
-    index?: number;
-    visibleLevelIds?: string[];
-    hiddenLevelIds?: string[];
-    fov?: number;
-    mode?: string;
-    displayInUI?: boolean;
-    activeLevelId?: string;
-    bake?: boolean;
-    bakeStatus?: string;
-    bakedModelUrl?: string;
-    bakedModelStage?: string;
-    bakeContentHash?: string;
-    bakePollStage?: string;
-    bakePreviewStatusFileKey?: string;
-    bakeRegularStatusFileKey?: string;
-    bakeSettings?: any;
-    lightMapCenter?: number;
-    lightMapFalloff?: number;
-    lightMapIntensity?: number;
-    skyMap?: string;
-    _highlight?: HighlightArgs;
-    _isSelected?: boolean;
-    children?: SceneNodeJson[];
-    units?: string;
-    folds?: number;
-    method?: string;
-}
-interface SceneNodeOptions {
-    /** apply default schema to each node - node.addChild has this set to true by default */
-    setDefaults?: boolean;
-    /** force regenerating node ids - otherwise ids will only be generated if they are missing */
-    regenerateIds?: boolean;
-    force?: boolean;
-    keepTransient?: boolean;
-    /** provide an id for an action to be able to group multiple actions */
-    actionId?: string;
-    /** define whether the update requires an update of computed properties */
-    updateState?: boolean;
-    /** define whether an event should be broadcasted - for plugins or multiplayer */
-    skipHistory?: boolean;
-    /** relevant for plugins or multiplayer: should the event be broadcasted */
-    preventBroadcast?: boolean;
-}
-interface ToJsonOptions extends SceneNodeOptions {
-    /** export the mapping between old and new node ids as top-level idMap property */
-    exportIdMap?: boolean;
-}
-interface TransformArgs {
-    x?: number;
-    y?: number;
-    z?: number;
-    ry?: number;
-}
-type RGBArray = [number, number, number];
-interface HighlightArgs {
-    /** color overlay for the node */
-    fill?: RGBArray;
-    /** opacity for the color overlay */
-    fillOpacity?: number;
-    /** outline for the node */
-    outline?: RGBArray;
-    /** width of the outline */
-    outlineWidth?: number;
-}
-/**
- * Main class for the nodes in a scene
- */
-declare class SceneNode extends SceneNodeJson {
-    /** node type: 'wall', 'column' etc */
-    type: NodeTypes;
-    /** globally unique id for each node */
-    id: string;
-    children: SceneNode[];
-    private _parent;
-    private _scene;
-    private _emitter;
-    constructor({ node, parent, scene, emitter, options }: {
-        /** node params */
-        node: SceneNodeJson;
-        /** parent node */
-        parent?: SceneNode;
-        /** the scene class to get access to scene.nodesByType etc */
-        scene?: Scene;
-        /** optional emitter that emits events for all SceneNode updates */
-        emitter?: TinyEmitter$1;
-        /** scene node options */
-        options?: SceneNodeOptions;
-    });
-    get parent(): SceneNode;
-    get scene(): Scene;
-    get schema(): Schema;
-    /**
-     * internal method: update the properties of a scene node
-     * @param {Object} args - update arguments
-     */
-    _update(args?: SceneNodeJson): void;
-    /**
-     * set the attributes of a scene node
-     * @param {Object} args - update arguments
-     * @param {Object} [options] - update options
-     */
-    set(args?: SceneNodeJson, options?: SceneNodeOptions): void;
-    /**
-     * set the transform of a scene node ( this is faster than node.set )
-     * @param {Object} args - update arguments { x, y, z, ry }
-     * @param {Object} [options] - update options
-     */
-    setTransform({ x, y, z, ry }?: TransformArgs, options?: SceneNodeOptions): void;
-    /**
-     * set the materials of a scene node
-     * @param {Object} materials - Object containing meshKey - material definition pairs, material definition can be a name(String) or a new definition(Object)
-     * @param {Object} [options] - update options
-     */
-    setMaterials(materials?: SceneNodeMaterials, options?: SceneNodeOptions): void;
-    /**
-     * set transient attributes of a scene node [ v1.6 ]
-     * @param {Object} args - transient arguments, have to be prefixed with underscore
-     */
-    setTransient(args?: {}, options?: SceneNodeOptions): void;
-    /**
-     * method to set the transient _highlight property of a scene node
-     * will emit a set-transient event
-     */
-    setHighlight(args?: HighlightArgs, options?: SceneNodeOptions): void;
-    /**
-     * find node by id ( unique ) or type ( find first )
-     */
-    find(args?: {
-        id?: string;
-        type?: NodeTypes;
-    }): SceneNode | void;
-    /**
-     * find all children nodes by type
-     */
-    findAll(args?: {
-        type?: NodeTypes;
-    }): SceneNode[];
-    /**
-     * add child to node
-     * @returns {SceneNode} the new child
-     */
-    addChild(node: SceneNodeJson, options?: SceneNodeOptions): SceneNode;
-    /**
-     * remove child from node
-     */
-    removeChild(node: any, options?: SceneNodeOptions): void;
-    /**
-     * remove node from its parent
-     */
-    remove(options?: SceneNodeOptions): void;
-    /**
-     * get nodes in the scene that refer to this node, like relation or setting nodes
-     */
-    getReferringNodes(): SceneNode[];
-    /**
-     * get the world position from a local position
-     */
-    getWorldPosition(): any;
-    /**
-     * get the local position from a world position
-     */
-    getLocalPositionFromWorld(pos: SceneNodeJson): SceneNodeJson;
-    /**
-     * get list of all parent nodes
-     */
-    getParents(): SceneNode[];
-    /**
-     * export scene node to json removing transient data
-     */
-    toJson(options?: ToJsonOptions): any;
-    /**
-     * Executes the callback on this node and all descendants
-     */
-    traverse(callback: (node: SceneNode) => any): void;
-}
-
-declare enum spaceCategories {
-    residential = "residential",
-    office = "office",
-    parking = "parking",
-    lightIndustrial = "lightIndustrial"
-}
-type SpaceCategories = keyof typeof spaceCategories;
-
-type NodesByName = {
-    [key: string]: SceneNode[];
-};
-type Schema = {
-    [K in NodeTypes]?: TypeSchema;
-};
-interface TypeSchemaProperty {
-    type?: string | string[];
-    description?: string;
-    const?: string;
-    pattern?: string;
-    items?: TypeSchemaProperty | TypeSchemaProperty[];
-    default?: any;
-    minimum?: number;
-    maximum?: number;
-    minItems?: number;
-    maxItems?: number;
-    multipleOf?: number;
-    enum?: string[];
-    patternProperties?: any;
-    additionalProperties?: boolean;
-    properties?: {
-        [key: string]: TypeSchemaProperty;
-    };
-    children?: TypeSchemaProperty;
-}
-interface TypeSchema {
-    type?: string;
-    required?: string[];
-    additionalProperties?: boolean;
-    description?: string;
-    properties: {
-        [key: string]: TypeSchemaProperty;
-    };
-}
-interface SceneOptions {
-    spaceContourAreaThreshold?: number;
-}
-/**
- * Central class to load an entire scene
- * scene structure is converted into a tree of SceneNode items
- * nodes can be quickly accessed
- * via `scene.nodesById[<uuid>]`
- * or `scene.nodesByType[<type>]`
- */
-declare class Scene {
-    sceneId: string | null;
-    node: SceneNode | null;
-    /** @deprecated */
-    type: string;
-    spaceCategories: SpaceCategories[];
-    nodesById: {
-        [uuid: string]: SceneNode;
-    };
-    nodesByType: NodesByType;
-    nodesByName: NodesByName;
-    options: SceneOptions;
-    private _emitter;
-    private _schema;
-    private _apiVersion;
-    constructor({ schema, options }?: {
-        /** optionally initialize scene with existing schema */
-        schema?: Schema;
-        options?: SceneOptions;
-    });
-    get emitter(): TinyEmitter$1;
-    get schema(): Schema;
-    set schema(schema: Schema);
-    /**
-     * load scene structure recursively, creating sceneNodes
-     * and registering nodes and nodesByType
-     */
-    loadSceneStructure(sceneStructure: SceneNodeJson, 
-    /** options will be handed to new SceneNode() */
-    options?: {
-        /** overwrite the rotation of the plan node - will be restored on planNode.toJson() */
-        planRotation?: number;
-        /** apply default schema to each node, useful when starting a plan from scratch ({type: 'plan'}) */
-        setDefaults?: boolean;
-        /** force regenerating node ids - otherwise ids will only be generated if they are missing */
-        regenerateIds?: boolean;
-    }): SceneNode;
-    /**
-     * set the scene type
-     * @deprecated, use setSpaceCategories() instead
-     */
-    setSceneType(): void;
-    _setSceneType(): void;
-    /**
-     * set the space categories
-     */
-    setSpaceCategories(): void;
-    /**
-     * compute the floor area
-     */
-    getFloorArea(): number;
-    /**
-     * add a node in scene.nodesByType, nodesById, and nodesByName
-     */
-    registerNode(node: SceneNode): void;
-    /**
-     * remove a node in scene.nodesByType, nodesById, and nodesByName
-     */
-    unregisterNode(node: SceneNode): void;
-    /**
-     * subscribe to a scene event
-     * * SceneNode events that change a node
-     * all set events fire with `{ node: <SceneNode>, args: <payload>, prevState: <oldValues>, options: <Object>, event: <eventName> }`
-     *   * `set-transform` - x,y,z or ry is changed for a node
-     *   * `set` - an attribute is changed for a node, like l or w
-     *   * `set-materials` - a material for a specific mesh is changed for a node, args: `{ <meshName>: <material> }`
-     *   * `set-transient` - transient attribute ( starting with underscore ) is changed for a node
-     * * SceneNode events that change the node tree
-     * all tree change events fire with `{ node: <SceneNode>, args: <SceneNode>, options: <Object>, event: <eventName> }`
-     *   * `add-child` - a child (args) is added to the node
-     *   * `remove-child` - a child (args) is removed from the node
-     * * Scene events:
-     *   * `scene-structure-loading` - fires when the loadSceneStructure is starting, payload is the Scene instance
-     *   * `scene-structure-loaded` - fires when the loadSceneStructure is complete, payload is the Scene instance
-     */
-    on(event: string, callback: any, context?: any): void;
-    /**
-     * subscribe to a scene event but remove after first emit
-     * otherwise like scene.on()
-     */
-    once(event: string, callback: any, context?: any): void;
-    /**
-     * unsubscribe from a scene event
-     */
-    off(event: string, callback?: any): void;
-    /**
-     * emit an event
-     */
-    emit(event: string, arg1: any, arg2?: any, arg3?: any, arg4?: any): void;
-    /**
-     * retrieve scene structure api version
-     */
-    get apiVersion(): string;
-}
-
-interface SpaceRelations {
-    /** space id */
-    node: SceneNode;
-    /** related nodes */
-    relationsById: NodeIdList;
-    relationsByEdgeIndex: {};
-}
-interface NodeIdList {
-    [nodeId: string]: {
-        /** related node */
-        node: SceneNode;
-        /** type of the relation */
-        relation: 'edge' | 'contained';
-        /** edge relations */
-        edgeRelations?: {
-            /** edge index of the space polygon [ loopIndex, edgeIndex ] */
-            edgeIndex?: [number, number];
-            /** edge index of related node */
-            nodeContourIndex?: number;
-        }[];
-    };
-}
-
-interface ShapeStyle {
-    stroke?: string | number | number[];
-    strokeWidth?: number | 'native';
-    strokeOpacity?: number;
-    fill?: string | number | number[] | false;
-    fillOpacity?: number;
-}
-interface BaseShape {
-    type: string;
-    style?: ShapeStyle;
-}
-interface LineShape extends BaseShape {
-    type: 'line';
-    start: Point2d;
-    end: Point2d;
-}
-interface ArcShape extends BaseShape {
-    type: 'arc';
-    position: Point2d;
-    radius: number;
-    startAngle: number;
-    endAngle: number;
-}
-interface CompositeShape extends BaseShape {
-    type: 'composite';
-    segments: OpenShapes[];
-}
-type OpenShapes = LineShape | ArcShape | PolylineShape | BezierShape;
-interface CircleShape extends BaseShape {
-    type: 'circle';
-    position: Point2d;
-    radius: number;
-}
-interface RectShape extends BaseShape {
-    type: 'rectangle';
-    position: Point2d;
-    dimensions: [number, number];
-}
-interface PolygonShape extends BaseShape {
-    type: 'polygon';
-    points: Polygon;
-    holes?: PolygonList;
-}
-interface PolylineShape extends BaseShape {
-    type: 'polyline';
-    points: Polygon;
-}
-interface BezierShape extends BaseShape {
-    type: 'quadraticBezier';
-    points: Polygon;
-}
-interface TextShape extends BaseShape {
-    type: 'text';
-    position: Point2d;
-    text: string;
-    rotation?: number;
-    alignV?: 'center' | 'bottom' | 'top';
-    alignH?: 'center' | 'left' | 'right';
-    fontSize?: number;
-}
-type Shape = PolygonShape | PolylineShape | RectShape | CircleShape | LineShape | GroupShape | TextShape | ArcShape | BezierShape | CompositeShape;
-interface GroupShape extends BaseShape {
-    type: 'group';
-    position?: Point2d;
-    rotation?: number;
-    children: Shape[];
-}
-/**
- * boolean union of two or more polygon
- */
-declare function polygonUnion(polygons: PolygonList): PolygonList;
-declare enum EndType {
-    etOpenSquare = 0,
-    etOpenRound = 1,
-    etOpenButt = 2,
-    etClosedLine = 3,
-    etClosedPolygon = 4
-}
-/**
- * contour offset for one or multiple polygons
- * https://sourceforge.net/p/jsclipper/wiki/documentation/#clipperlibendtype
- */
-declare function polygonOffset(polygons: PolygonList, delta?: number, endType?: EndType, skipCleaning?: boolean): PolygonList;
-/**
- * boolean intersection of two or more polygon
- * the subject path can be an open polyline
- */
-declare function polygonIntersection(polygons?: PolygonList, clipPolygons?: PolygonList, subjectPathOpen?: boolean): PolygonList;
-
-/**
- * This interface was referenced by `AuthJson`'s JSON-Schema
- * via the `definition` "resourceScope".
- */
-type ResourceScope =
-  | "customFields"
-  | "customAttributes"
-  | "customAttributeValues"
-  | "organization"
-  | "dxf"
-  | "floor"
-  | "ifc"
-  | "job"
-  | "order"
-  | "product"
-  | "user"
-  | "team"
-  | "superadmin"
-  | "token"
-  | "subscription"
-  | "graphql";
-/**
- * This interface was referenced by `AuthJson`'s JSON-Schema
- * via the `definition` "actionScope".
- */
-type ActionScope =
-  | "manageJoinRequests"
-  | "access"
-  | "archive"
-  | "bake"
-  | "changeRole"
-  | "close"
-  | "create"
-  | "createFromOrder"
-  | "delete"
-  | "export"
-  | "import"
-  | "invite"
-  | "query"
-  | "queryPublic"
-  | "queryPrivate"
-  | "read"
-  | "readPrivate"
-  | "readPublic"
-  | "update"
-  | "remove"
-  | "write"
-  | "addUser"
-  | "removeUser"
-  | "settings";
-/**
- * This interface was referenced by `AuthJson`'s JSON-Schema
- * via the `definition` "scopeDefinitionArray".
- */
-type ScopeDefinitionArray = ScopeDefinition[];
-/**
- * This interface was referenced by `AuthJson`'s JSON-Schema
- * via the `definition` "scopeDefinition".
- */
-interface ScopeDefinition {
-  resource: ResourceScope;
-  action?: ActionScope;
-  resourceId?: string;
-}
-/**
- * This interface was referenced by `AuthJson`'s JSON-Schema
- * via the `definition` "temporaryAccessToken".
- */
-interface TemporaryAccessToken {
-  authorization: string;
-  expiresAt: number;
-}
-/**
- * This interface was referenced by `AuthJson`'s JSON-Schema
- * via the `definition` "createTemporaryAccessToken".
- */
-interface CreateTemporaryAccessToken {
-  scopes: ScopeDefinitionArray;
-  durationSeconds?: number;
-}
-
-type TemporaryAccessTokenFunction = (args: CreateTemporaryAccessToken) => Promise<TemporaryAccessToken>;
-interface TokenOptions {
-    publishableAccessToken?: string;
-    secretAccessToken?: string;
-    temporaryAccessToken?: TemporaryAccessToken;
-    temporaryAccessTokenFunction?: TemporaryAccessTokenFunction;
-    temporaryAccessTokenScopes?: ScopeDefinitionArray;
-    sdkVersion?: string;
-}
-
-declare class TinyEmitter {
-  on(event: string, callback: Function, ctx?: any): this;
-  once(event: string, callback: Function, ctx?: any): this;
-  emit(event: string, ...args: any[]): this;
-  off(event: string, callback?: Function): this;
-}
-
-interface AssetData {
-    id: string;
-    node: SceneNode;
-    polygon: Polygon;
-    boundingBox: BoundingBox2d;
-    name: string;
-    manufacturer: string;
-    productId: string;
-    tags: string[];
-    categories: string[];
-    subCategories: string[];
-    dimensions: {
-        width: number;
-        length: number;
-        height: number;
-    };
-    seatCapacity: number;
-    position: Vector3d;
-    rotation: number;
-}
-interface SpaceData {
-    node: SceneNode;
-    boundingBox: BoundingBox2d;
-    id: string;
-    usage?: string;
-    usageName?: string;
-    program?: string;
-    polygons: PolygonList;
-    assets: string[];
-    area: number;
-    center: Point2d;
-    customId?: string;
-    name?: string;
-}
-interface ProductData {
-    preview: string;
-    manufacturer: string;
-    productId: string;
-    name: string;
-    fileKey: string;
-    tags: string[];
-    categories: string[];
-    subCategories: string[];
-    boundingPoints: {
-        min: any;
-        max: any;
-    };
-    boundingBox: {
-        length: number;
-        width: number;
-        height: number;
-    };
-    seatCapacity: number;
-    texture: string;
-    materials: string[];
-    matColors: string[];
-    colours: string[];
-    order: number;
-    isCeilingLamp: boolean;
-    isCarpet: boolean;
-    createdAt: string;
-    updatedAt: string;
-    link: string;
-    _shapes?: Shape[];
-}
-interface ResourceData {
-    space: SpaceData;
-    asset: AssetData;
-}
-type ResourceType = keyof ResourceData;
-type BaseResource<T extends ResourceType> = {
-    resourceType: T;
-    setHighlight: (highlightArgs?: HighlightArgs) => void;
-};
-type SceneResource<T extends ResourceType> = BaseResource<T> & Omit<ResourceData[T], 'node'>;
-type SpaceResource = SceneResource<'space'>;
-type AssetResource = SceneResource<'asset'>;
-
-type LoadingEvent = 'loading-done' | 'loading-status' | 'product-load-stage' | 'product-load-texture' | 'product-data' | 'product-contour' | 'spaces-loaded' | 'assets-loaded';
-declare enum TextureFilter {
-    None = 0,
-    Default = 1,
-    Grayscale = 2
-}
-declare class FpeLoader$1 extends TinyEmitter {
-    productQueue: {
-        [productId: string]: {
-            nodes: Set<SceneNode>;
-            /**
-              0 = nothing loaded;
-              1 = product data loaded;
-              2 = product bounding box contour loaded;
-              3 = product contour loaded
-            */
-            loadStage: number;
-        };
-    };
-    textureQueue: {
-        [textureId: string]: {
-            productId?: string;
-            nodes: Set<SceneNode>;
-            textureUrl: string;
-            applyFilter: TextureFilter;
-            imageData?: any;
-            /**
-              0: nothing loaded;
-              1: image texture loaded;
-              2: final product texture created with contour baked in
-            */
-            loadStage: number;
-            error?: boolean;
-            texture?: any;
-            contourTexture?: any;
-            anchor?: any;
-            offset?: any;
-            position?: any;
-        };
-    };
-    promiseCache: Map<string, Promise<any>>;
-    loadStages: {
-        product: boolean;
-        productContour: boolean;
-        productTexture: boolean;
-    };
-    isSceneStructureLoaded: boolean;
-    resources: FloorPlanCore['resources'];
-    productContourCacheAge: number;
-    productDataCacheAge: number;
-    initialLoading: boolean;
-    _loadCounter: number;
-    on: (event: LoadingEvent, callback: Function, ctx?: any) => this;
-    once: (event: LoadingEvent, callback: Function, ctx?: any) => this;
-    off: (event: LoadingEvent, callback?: Function) => this;
-    emit: (event: LoadingEvent, ...args: any[]) => this;
-    constructor(resources: FloorPlanCore['resources'], settings: FloorPlanCore['settings']);
-    loadStatus({ args }: {
-        args: any;
-    }): void;
-    reset(): void;
-}
-
-interface StartupOptions {
-    /** option to hide certain elements */
-    hideElements?: HideableElement[];
-    preserveViewbox?: string;
-    /** option to disable panning and zooming */
-    panZoom?: boolean;
-    /** if set, panning and zooming is restricted to the scene boundingbox plus the margin */
-    panZoomMargin?: number;
-    /** rotation angle for the floor plan in degrees (counterclockwise) */
-    planRotation?: number | null;
-    /** if set room stamps have a fixed size - otherwise they adapt to the zoom level */
-    roomStampSize?: number;
-    /** toggle overlaying UI elements */
-    ui?: UI;
-    /** floor plan theming */
-    theme?: FloorPlanTheme;
-    /** mapping table for custom space labels */
-    spaceLabelMapping?: SpaceLabelMapping;
-    /** set the unit system */
-    units?: Units;
-    /** min and max zooming factor. Defaults to [3, 300] */
-    zoomRange?: [number, number];
-}
-/**
- * This is the place to give the floor plan your own style
- */
-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, ElementTheme>;
-        floorPlan?: {
-            grayscale: boolean;
-        };
-        roomStamp?: {
-            /** @deprecated show the usage information in room stamps */
-            showUsage?: boolean;
-            /** @deprecated show the area information in room stamps */
-            showArea?: boolean;
-            /** show the area information in room stamps */
-            roomStampDisplay?: ('usage' | 'area' | 'customId' | 'name')[];
-            /** text color for room stamps */
-            text?: RGBArray;
-            /** whether the room stamp text should have an outline to assist with contrast issues */
-            textOutline?: boolean;
-        };
-        asset?: ElementTheme;
-        space?: SpaceTheme;
-        wall?: ElementTheme;
-        wallContour?: ElementTheme;
-        box?: ElementTheme;
-        curtain?: ElementTheme;
-        closet?: ElementTheme;
-        door?: ElementTheme;
-        kitchen?: ElementTheme;
-        railing?: ElementTheme;
-        stairs?: ElementTheme;
-        window?: ElementTheme;
-        column?: ElementTheme;
-        polybox?: ElementTheme;
-    };
-};
-/**
- * Background of the floor plan canvas
- */
-type BackgroundOptions = {
-    /** background-color: hex code for color, set to 'transparent' for transparent background */
-    color?: string;
-    /** show a dynamic grid */
-    showGrid?: boolean;
-};
-/**
- * Elements that can be hidden in the floor plan
- */
-type HideableElement = SceneNode['type'] | 'roomStamp';
-type UI = {
-    /** Show a dynamic scale indicator */
-    scale?: boolean;
-    /** Show the current cursor position in plan coordinates */
-    coordinates?: boolean;
-};
-/**
- * Map space labels by space usage or space id to a custom name
- * @example { kitchen: 'cuisine' }
- */
-type SpaceLabelMapping = {
-    [label: string]: string;
-};
-/**
- * Which unit system and how to display the units
- */
-type Units = {
-    /** meters or feet? */
-    system?: 'metric' | 'imperial';
-    /** how many decimals should be shown for lengths? */
-    lengthDecimals?: number;
-    /** how many decimals should be shown for areas? */
-    areaDecimals?: number;
-    /** if 'area', it displays e.g. 12 m². If 'boundingBox'it displays e.g. 4 m x 3 m */
-    roomDimensions?: 'area' | 'boundingBox';
-};
-type FpeComputed = {
-    wallContours: PolygonList[];
-    relations: {
-        spaces: SpaceRelations[];
-    };
-    snapPoints: Polygon;
-    snapMargin: number;
-};
-type FpeCoreEvent = 'update-settings';
-type Resources = {
-    spaces: SpaceResource[];
-    assets: AssetResource[];
-    products: {
-        [productId: string]: ProductData;
-    };
-    productContours: {
-        [productId: string]: PolygonList;
-    };
-    productBoundingBoxes: {
-        [productId: string]: PolygonList;
-    };
-};
-/**
- * The main Floor plan engine SDK class
- */
-declare class FloorPlanCore {
-    settings: FpeConfig;
-    static readonly version: any;
-    readonly fpeId: string;
-    resources: Resources;
-    computed: FpeComputed;
-    loader: FpeLoader$1;
-    scene: Scene;
-    isBrowser: boolean;
-    utils: any;
-    location: {
-        latitude: number;
-        longitude: number;
-    };
-    protected _emitter: TinyEmitter;
-    constructor({ options, scene }?: {
-        options?: FpeConfig;
-        scene?: Scene;
-    });
-    on(event: FpeCoreEvent, callback: Function, ctx?: any): this;
-    once(event: FpeCoreEvent, callback: Function, ctx?: any): this;
-    off(event: FpeCoreEvent, callback?: Function): this;
-    emit(event: FpeCoreEvent, ...args: any[]): this;
-    initScene(scene: any): void;
-    /**
-     * Load a scene with it's unique identifier the sceneId
-     * @param {string} sceneId id of the scene to load
-     * @param {AccessToken} accessToken Space API v2 [publishable](../space-api/v2/introduction.md#publishable-access-token) or [temporary](../space-api/v2/introduction.md#temporary-access-token) access token
-     * @returns {Promise.<Boolean, Error>} returns promise which resolves when loading is done
-     */
-    loadScene(sceneId: string, accessTokenOptions?: TokenOptions): Promise<boolean | Error>;
-    getSpaces(): void;
-    /**
-     * Change options after the floor plan engine instance has been created
-     */
-    set(args?: FpeConfig): void;
-    /**
-     * Get a list of spaces and assets for a specific plan position
-     * @param {*} pos - plan position
-     * @returns {Object} - list of spaces and assets
-     */
-    getResourcesFromPosition(pos: Point2d): {
-        spaces: SpaceData[];
-        assets: AssetData[];
-    };
-    /**
-     * get bounding box of a scene node
-     * @param {SceneNode | string} node - Element or Element id
-     * @param {*} margin
-     */
-    getElementBoundingBox(node: any, margin?: number): BoundingBox2d;
-    /**
-     * Destroy the floor plan instance
-     */
-    destroy(): void;
-}
-interface FpeConfig extends StartupOptions {
-    api?: {
-        accessToken?: string;
-        productDataCacheAge?: number;
-        productContourCacheAge?: number;
-    } & TokenOptions;
-    loadTextures?: boolean;
-    showFloorPlan?: boolean;
-    showSpaceDividers?: boolean;
-    showCeilingLamps?: boolean;
-    svgViewBoxDim?: number;
-    xrayMode?: boolean;
-    svgMode?: boolean;
-    destroyOnDomRemove?: boolean;
-}
-interface ElementTheme {
-    fill?: ShapeStyle['fill'];
-    fillOpacity?: number;
-    stroke?: ShapeStyle['stroke'];
-}
-interface SpaceTheme extends ElementTheme {
-    usage?: {
-        [key: string]: ElementTheme;
-    };
-    program?: {
-        [key: string]: ElementTheme;
-    };
-}
-
-interface InfoWindowArgs {
-    /** pixel width of the window - default 100 */
-    width?: number;
-    /** pixel height of the window - default 80 */
-    height?: number;
-    /** coordinates of the window in meters */
-    pos?: Point2d;
-    /** html string as content of the info window */
-    html?: string;
-    /** If true , a close button will appear in the top right corner of the info window. */
-    closeButton?: boolean;
-}
-interface InfoWindowState extends InfoWindowArgs {
-    floorPlan?: FloorPlanEngine;
-}
-declare class InfoWindow {
-    private _floorPlan;
-    pos: Point2d;
-    height: number;
-    width: number;
-    closeButton: any;
-    html: any;
-    el: Element;
-    private _anchorPos;
-    private _getPosition;
-    constructor({ width, height, pos, html, closeButton, floorPlan }?: InfoWindowState);
-    _createInfoWindow(): void;
-    _setContent(): void;
-    _updateInfoWindow(): void;
-    set({ width, height, pos, html, closeButton }: {
-        width: any;
-        height: any;
-        pos: any;
-        html: any;
-        closeButton: any;
-    }): void;
-    remove(): void;
-}
-
-interface HtmlMarkerArgs {
-    /** coordinates of the window in meters */
-    pos?: Point2d;
-    offset?: Point2d;
-    /** html string as content of the info window */
-    el?: HTMLElement;
-    /** If true , a close button will appear in the top right corner of the info window. */
-    closeButton?: boolean;
-}
-interface HtmlMarkerState extends HtmlMarkerArgs {
-    floorPlan: FloorPlanEngine;
-}
-declare class HtmlMarker {
-    pos: Point2d;
-    size: Point2d;
-    offset: Point2d;
-    isHidden: boolean;
-    id: string;
-    el: HTMLElement;
-    private _floorPlan;
-    private _anchorPos;
-    constructor({ pos, offset, el, floorPlan }: HtmlMarkerState);
-    _updateHtmlMarker: () => void;
-    _updateHtmlMarkerStyle(): void;
-    set({ pos, offset }: Pick<HtmlMarkerArgs, 'pos' | 'offset'>): void;
-    remove(): void;
-}
-
-type FpeLoader = FloorPlanCore['loader'];
-type ScreenPosition = {
-    x: number;
-    y: number;
-};
-declare class Ticker {
-    methods: {
-        [name: string]: {
-            fn: Function;
-            ctx: WebGlView;
-        };
-    };
-    add: (name: string, fn: Function, ctx: WebGlView) => void;
-    remove: (name: string) => void;
-}
-type ViewEvent = 'pan' | 'zoom' | 'viewbox' | 'resize-canvas' | 'scene-rendered' | 'focus';
-type BaseLayers = 'base' | 'scene' | 'annotation' | 'helper';
-declare class WebGlView extends TinyEmitter {
-    windowPos: Point2d;
-    zoom: number;
-    client: Point2d;
-    layers: Map<string, PlanLayer>;
-    viewbox: BoundingBox2d;
-    viewportNeedsUpdate: boolean;
-    viewportPaused: boolean;
-    viewportInFocus: boolean;
-    parentEl: HTMLElement;
-    _settings: FpeConfig;
-    redrawScene: () => void;
-    gfxNodes: {
-        [nodeId: string]: {
-            nodeContainer?: any;
-            loadStage?: number;
-            textureId?: string;
-        };
-    };
-    _dummyTexture: any;
-    _oldTime: number;
-    ticker?: Ticker;
-    on: (event: ViewEvent, callback: Function, ctx?: any) => this;
-    once: (event: ViewEvent, callback: Function, ctx?: any) => this;
-    off: (event: ViewEvent, callback?: Function) => this;
-    emit: (event: ViewEvent, ...args: any[]) => this;
-    constructor(loader: FpeLoader, settings: FpeConfig, fpeId: string);
-    /**
-     * main animation loop
-     */
-    draw(): void;
-    startAnimationLoop(): void;
-    stopAnimationLoop(): void;
-    updateView(): void;
-    watchResize(): Promise<void>;
-    get gfxNodeCount(): number;
-    reset(): void;
-    pause(interaction?: string): void;
-    resume(interaction?: string): void;
-}
-
-/** style definition used internally for rendering a node */
-interface StyleProps extends ShapeStyle {
-    /** draw a dashed contour */
-    dash?: boolean;
-}
-
-interface GraphicArgs {
-    shapes: Shape[];
-    position?: Point2d;
-    alpha?: number;
-    clearLayer?: boolean;
-    scale?: number;
-    interactive?: boolean;
-    id?: string;
-    isHandler?: boolean;
-    scaleOnZoom?: boolean;
-}
-interface PlanGraphicArgs extends GraphicArgs {
-    floorPlan: FloorPlanEngine;
-    [key: string]: any;
-}
-type GraphicUpdate = {
-    position?: Point2d;
-    style?: StyleProps;
-    shapes?: Shape[];
-};
-declare class PlanGraphic {
-    shapes: Shape[];
-    scaleOnZoom: boolean;
-    gfxScale: number;
-    private floorPlan;
-    constructor({ shapes, position, alpha, scale, clearLayer, interactive, id, isHandler, scaleOnZoom, baseLayer, container, floorPlan }: PlanGraphicArgs);
-    set({ position, style, shapes }?: GraphicUpdate): void;
-    on(event: string, callback: any, context?: any): this;
-    off(event: string, callback?: any): this;
-    destroy(): void;
-    private addDragEvent;
-    private removeDragEvent;
-}
-
-declare class PlanLayer {
-    graphics: Set<PlanGraphic>;
-    id: string;
-    private baseLayer;
-    private floorPlan;
-    constructor(floorPlan: FloorPlanEngine, baseLayer?: BaseLayers, id?: string);
-    addGraphic(args: GraphicArgs): PlanGraphic;
-    deleteGraphic(graphic: PlanGraphic): void;
-    /**
-     * Draw shapes on the layer
-     * @deprecated
-     */
-    draw(args: GraphicArgs): PlanGraphic;
-    drawImage({ url, width, height, mask, options }: {
-        url: any;
-        width: any;
-        height: any;
-        mask: any;
-        options: any;
-    }): void;
-    /**
-     * clear all shapes from the layer
-     */
-    clear(): void;
-    /**
-     * destroy layer and all shapes
-     */
-    destroy(): void;
-}
-
-interface MarkerArgs {
-    /** coordinates of the marker in meters */
-    pos?: Point2d;
-    /** color of the marker, hex code */
-    color?: string;
-    /** size in pixels */
-    size?: number;
-    floorPlan?: FloorPlanEngine;
-}
-interface MarkerUpdateArgs {
-    events?: {
-        [event: string]: {
-            callback: any;
-            context: any;
-        };
-    };
-}
-declare class MarkerPin {
-    pos: Point2d;
-    color: string;
-    size: number;
-    id: string;
-    layer: PlanLayer;
-    graphic: PlanGraphic;
-    private floorPlan;
-    constructor({ pos, color, size, floorPlan }: MarkerArgs);
-    draw(): void;
-    remove(): void;
-    on(eventType: string, callback: any, context?: any): void;
-    off(eventType?: string, callback?: any): void;
-    set(updateArgs: MarkerUpdateArgs): void;
-}
-
-type Animate = number | boolean;
-
-declare class Helper extends TinyEmitter {
-    floorPlan: FloorPlanEngine;
-    helperId: string;
-    constructor({ floorPlan, helperId }: {
-        floorPlan: FloorPlanEngine;
-        helperId: string;
-    });
-    destroy(): void;
-}
-
-type FpeEvent = FpeCoreEvent | 'click' | 'dblclick' | 'context-menu' | 'mousemove' | 'drop' | 'drag-move' | 'drag-start' | 'drag-end' | 'key' | 'keyup';
-interface ExportImage {
-    /** output format: png, jpg */
-    format?: 'png' | 'jpg';
-    /** fle name relevant if download is true */
-    fileName?: string;
-    /** only relevant if format is jpg */
-    quality?: number;
-    /** desired output format */
-    output?: 'base64' | 'text';
-    /** target width of the image */
-    maxWidth?: number;
-    /** If true, methods triggers a file download directly */
-    download?: boolean;
-}
-interface FpeInteraction {
-    lastSceneClick: Point2d;
-    cursor: Point2d;
-    cursorTarget: SceneNode;
-    isDragging: boolean;
-    isPanning: boolean;
-    lastClick: {
-        time: number;
-        pos: ScreenPosition;
-    };
-    metaKey: boolean;
-    ctrlKey: boolean;
-    altKey: boolean;
-    shiftKey: boolean;
-    dragOffset: Point2d;
-    cursorAction: 'split-wall' | 'duplicate' | 'move' | 'select' | 'none';
-    _dragStart: ScreenPosition;
-    preventFocusoutOnAltKeyup: boolean;
-}
-/**
- * The main Floor plan engine SDK class
- */
-declare class FloorPlanEngine extends FloorPlanCore {
-    fpeNode?: HTMLElement;
-    view: WebGlView;
-    interaction: FpeInteraction;
-    availableHelpers: {
-        [name: string]: typeof Helper;
-    };
-    helper: {
-        [name: string]: Helper;
-    };
-    constructor({ container, options, scene }?: {
-        container?: Element;
-        options?: FpeConfig;
-        scene?: Scene;
-    });
-    prevent(e: any): void;
-    /**
-     * Subscribe to an event
-     */
-    on(event: FpeEvent, callback: Function, ctx?: any): this;
-    /**
-     * Subscribe to an event once
-     */
-    once(event: FpeEvent, callback: Function, ctx?: any): this;
-    /**
-     */
-    off(event: FpeEvent, callback?: Function): this;
-    emit(event: FpeEvent, ...args: any[]): this;
-    handleDrop(evt: any): void;
-    /**
-     * Change options after the floor plan engine instance has been created
-     * @param {StartupOptions} args - Startup options
-     */
-    set(args: FpeConfig): void;
-    mountFloorPlan(root: Element): void;
-    initDrawing(): void;
-    initDrawingEvents(): void;
-    generateUi(): void;
-    getSceneBoundingBox(margin?: number): BoundingBox2d;
-    /**
-     * Get a bounding box containing the scene, with some padding
-     * @param {BoundingBox2d} sceneBoundingBox - bounding box of the scene, in meters.
-     * @param {number} rectLeft - left edge of a rectangle into which the scene should fit, in pixels.
-     * @param {number} rectTop - top edge of a rectangle into which the scene should fit, in pixels.
-     * @param {number} rectRight - right edge of a rectangle into which the scene should fit, in pixels.
-     * @param {number} rectBottom - bottom edge of a rectangle into which the scene should fit, in pixels.
-     * @param {number} viewportWidth - width in pixels of the canvas.
-     * @param {number} viewportHeight - height in pixels of the canvas.
-     * @returns {BoundingBox2d} returns a new bounding box
-     */
-    getZoomExtentsBoundingBox(sceneBoundingBox: BoundingBox2d, rectLeft: number, rectTop: number, rectRight: number, rectBottom: number, viewportWidth: number, viewportHeight: number): BoundingBox2d;
-    /**
-     * Zoom to the extent of the scene in the viewport ( wait for loadScene promise )
-     * @param {number} [margin = 1] - margin around scene in meters. Defaults to 1 meter
-     * @param {Animate} [animate = false] - duration in milliseconds of the animation for the viewport transform. If true, the duration will be 500ms. If false or not provided there will be no animation
-     * @param {BoundingBox2d} [boundingBox = null] - bounding box to zoom to. Can for example be calculated via getZoomExtentsBoundingBox(…). If provided, the margin parameter will be ignored
-     * @returns {Promise.<Boolean, Error>} returns promise which resolves when animation is done
-     */
-    zoomExtents(margin?: number, animate?: Animate, boundingBox?: BoundingBox2d): Promise<boolean>;
-    /**
-     * Zoom to the bounding box of an element ( wait for loadScene promise )
-     * @param {string | SceneNode} node - id of an asset or a space or the node itself
-     * @param {number} [margin = 1] - margin around scene in meters
-     * @param {Animate} [animate] - duration of the animation for the viewport transform, if not provided there will be no animation
-     * @returns {Promise.<Boolean, Error>} returns promise which resolves when animation is done
-     */
-    zoomToElement(node: any, margin?: number, animate?: Animate): Promise<boolean | Error>;
-    /**
-     * set zoom to a specific bounding box
-     * @param {BoundingBox} bb - bounding box
-     * @param {Animate} [animate] - duration of the animation for the viewport transform, if not provided there will be no animation
-     * @returns {Promise.<Boolean, Error>} returns promise which resolves when animation is done
-     */
-    setZoom(bb: BoundingBox2d, animate?: Animate): Promise<boolean>;
-    /**
-     * zoom the current view by a factor
-     * @param {number} factor - zoom factor, larger than 1 zooms in, smaller than 1 zooms out
-     * @param {Animate} [animate = true] - duration of the animation for the viewport transform, if not provided there will be no animation
-     * @returns {Promise.<Boolean, Error>} returns promise which resolves when animation is done
-     */
-    zoomByFactor(factor: number, animate?: Animate): Promise<boolean>;
-    /**
-     * Add HTML info window
-     */
-    addInfoWindow(args?: InfoWindowArgs): InfoWindow;
-    /**
-     * Add custom HTML marker
-     */
-    addHtmlMarker(args?: HtmlMarkerArgs): HtmlMarker;
-    /**
-     * Add plan marker
-     */
-    addMarker({ pos, color, size }?: MarkerArgs): MarkerPin;
-    /**
-     * Convert screen coordinates to plan coordinates
-     */
-    getPlanPosition(point: Point2d): Point2d;
-    /**
-     * Convert plan coordinates to screen coordinates
-     */
-    getScreenPosition(point: Point2d): Point2d;
-    /**
-     * create plan layer or return existing by id
-     */
-    addLayer({ id, baseLayer }?: {
-        id?: string;
-        baseLayer?: BaseLayers;
-    }): PlanLayer;
-    /**
-     * get plan layer by name
-     */
-    getLayer(id: any): PlanLayer;
-    /**
-     * create plan graphic
-     * @deprecated use floorPlan.addLayer(<name>)
-     * @returns {PlanLayer}
-     */
-    addPlanGraphic(): PlanLayer;
-    /**
-     * Adds a helper and removes previous instances of it
-     */
-    addHelper(helper: string | typeof Helper, options?: any): Helper;
-    removeHelper(helperId: string): void;
-    /**
-     * Export the current view as an image
-     */
-    exportImage({ format, fileName, quality, output, maxWidth, download }?: ExportImage): Promise<string | Error>;
-    /**
-     * Destroy the floor plan instance
-     */
-    destroy(): void;
-}
-
-export { FloorPlanEngine, type GraphicArgs, type Point2d, type Polygon, type PolygonList, type Shape, polygonIntersection, polygonOffset, polygonUnion };
+/**
+ * This interface was referenced by `AuthJson`'s JSON-Schema
+ * via the `definition` "actionScope".
+ */
+declare type ActionScope =
+| "manageJoinRequests"
+| "access"
+| "archive"
+| "bake"
+| "changeRole"
+| "close"
+| "create"
+| "createFromOrder"
+| "delete"
+| "export"
+| "import"
+| "invite"
+| "query"
+| "queryPublic"
+| "queryPrivate"
+| "read"
+| "readPrivate"
+| "readPublic"
+| "update"
+| "remove"
+| "write"
+| "addUser"
+| "removeUser"
+| "settings";
+
+declare type Animate = number | boolean;
+
+declare interface ApiUrls {
+    spaceApiUrl?: string;
+    apiStorageUrl?: string;
+    apiProductDataPath?: string;
+}
+
+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 type BaseLayers = 'base' | 'scene' | 'preview' | 'annotation' | 'helper';
+
+declare interface BaseShape {
+    type: string;
+    style?: ShapeStyle;
+}
+
+declare interface BezierCurve extends BaseShape {
+    type: 'curve:quadraticBezier';
+    points: Polygon;
+}
+
+declare type BoundingBox2d = {
+    min: Vector2_2;
+    max: Vector2_2;
+};
+
+declare type BoundingBox3d = {
+    min: Vector3;
+    max: Vector3;
+};
+
+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 | CircleCurve | CompositeCurve;
+
+declare type ClosedCurveType = RectangleCurveType | PolygonCurveType | CircleCurveType | CompositeCurveType;
+
+declare interface CommonParameters$1 {
+    materials: LayoutRampMaterials;
+}
+
+declare interface CommonParameters$2 {
+    segmentCount: number;
+    segmentLength: number;
+    materials: LayoutRailingMaterials;
+}
+
+declare interface CommonParameters$3 {
+    wallCabinet: boolean;
+    leftHighCabinetCount: number;
+    rightHighCabinetCount: number;
+    sinkElementSlot: number;
+    cooktopElementSlot: number;
+    ovenElementSlot: number;
+    materials: LayoutKitchenMaterials;
+}
+
+declare interface CommonParameters$4 {
+    frameThickness: number;
+    frameDepth: number;
+    doorType: DoorType;
+    doorAngle: number;
+    hardware: boolean;
+    hingeSide: HingeSide;
+    doorSide: DoorSide;
+    materials: LayoutDoorMaterials;
+}
+
+declare interface CommonParameters$5 {
+    counterHeight: number;
+    materials: LayoutCaseworkMaterials;
+}
+
+declare interface CommonParameters$6 {
+    materials: LayoutBeamMaterials;
+}
+
+declare interface CommonParameters {
+    frameThickness: number;
+    frameDepth: number;
+    panelLength: number;
+    panelCount: number;
+    materials: LayoutWindowMaterials;
+}
+
+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";
+
+/**
+ * This interface was referenced by `AuthJson`'s JSON-Schema
+ * via the `definition` "createTemporaryAccessToken".
+ */
+declare interface CreateTemporaryAccessToken {
+    scopes: ScopeDefinitionArray;
+    durationSeconds?: number;
+}
+
+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 interface CustomStairsParameters {
+    stairsType: CustomStairsType;
+    height: number;
+    stepWidth: number;
+    railing: 'none' | 'left' | 'right' | 'both';
+    materials: LayoutStairsMaterials;
+}
+
+declare type CustomStairsParametersJson = Partial<CustomStairsParameters>;
+
+declare type CustomStairsType = 'custom';
+
+declare interface DimensionParameters$1 {
+    length: number;
+    height: number;
+}
+
+declare interface DimensionParameters$2 {
+    length: number;
+    height: number;
+}
+
+declare type DimensionParameters = {
+    length: number;
+    width: number;
+    height: number;
+};
+
+declare type DoorSide = 'side1' | 'side2';
+
+declare type DoorType = 'singleSwing' | 'doubleSwing' | 'slidingDoor' | 'opening' | 'elevatorDoor' | 'garageDoor';
+
+declare interface EdgeCanSplitOptions {
+    minimumLength?: number;
+}
+
+declare type EdgeElementMap = {
+    'element:curtainWall': LayoutCurtainWall;
+    'element:spaceDivider': LayoutSpaceDivider;
+    'element:wall': LayoutWall;
+};
+
+declare interface EdgeSplitOptions {
+    vertexId?: string;
+    edgeId?: string;
+    elementId?: string;
+}
+
+declare interface EdgeSplitReturnValue {
+    vertex: SpatialGraphVertex;
+    edge: SpatialGraphEdge;
+    element?: LayoutEdgeElement;
+}
+
+declare type EdgeType = 'graph:adjacentTo' | 'graph:connectedTo';
+
+declare interface ExportImage {
+    /** output format: png, jpg */
+    format?: 'png' | 'jpg';
+    /** fle name relevant if download is true */
+    fileName?: string;
+    /** only relevant if format is jpg */
+    quality?: number;
+    /** desired output format */
+    output?: 'base64' | 'text';
+    /** target width of the image */
+    maxWidth?: number;
+    /** If true, methods triggers a file download directly */
+    download?: boolean;
+}
+
+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";
+
+/**
+ * The main Floor plan engine SDK class
+ */
+declare class FloorPlanCore {
+    settings: FpeConfig;
+    static readonly version: any;
+    readonly fpeId: string;
+    computed: FpeComputed;
+    loader: FpeLoader;
+    layout: SpaceGraphLayout;
+    spaceGraph: SpaceGraph;
+    isBrowser: boolean;
+    utils: any;
+    location: {
+        latitude: number;
+        longitude: number;
+        /** angle measured in degrees from the north line (=0 degrees). Value should be between -180 and 180 degrees (positive clockwise) */
+        bearing: number;
+    };
+    protected _emitter: TinyEmitter;
+    constructor({ options }?: {
+        options?: FpeConfig;
+    });
+    on<EventType extends FpeCoreEvent, Context>(event: EventType, handler: FpeCoreEventHandler<EventType>, ctx?: Context): this;
+    once<EventType extends FpeCoreEvent, Context>(event: EventType, handler: FpeCoreEventHandler<EventType>, ctx?: Context): this;
+    off<EventType extends FpeCoreEvent>(event: EventType, handler?: FpeCoreEventHandler<EventType>): this;
+    emit<EventType extends FpeCoreEvent>(event: EventType, ...args: FpeCoreEventMap[EventType]): this;
+    loadLayout(layout: SpaceGraphLayout, { skipGeometryCompute }?: {
+        skipGeometryCompute?: boolean;
+    }): void;
+    loadSpaceGraph(spaceGraph: SpaceGraph, { skipGeometryCompute, layoutId }?: {
+        skipGeometryCompute?: boolean;
+        layoutId?: string;
+    }): void;
+    loadSpaceGraphJson(spaceGraphJson: SpaceGraphJson): void;
+    /**
+     * Load a floor with its unique identifier the floorId
+     * @param {string} floorId id of the floor to load
+     * @param {AccessToken} accessTokenOptions Space API v2 [publishable](../space-api/v2/introduction.md#publishable-access-token) or [temporary](../space-api/v2/introduction.md#temporary-access-token) access token
+     * @returns {Promise.<Boolean, Error>} returns promise which resolves when loading is done
+     */
+    loadFloorById(floorId: string, accessTokenOptions?: TokenOptions): Promise<boolean | Error>;
+    /**
+     * Change options after the floor plan engine instance has been created
+     */
+    set(args?: FpeConfig): void;
+    /**
+     * Get a list of spaces and assets for a specific plan position
+     * @param {*} position - plan position
+     * @returns {Object} - list of spaces and assets
+     */
+    getResourcesFromPosition(position: Vector2_2): {
+        spaces: LayoutSpace[];
+        assets: LayoutAsset[];
+    };
+    /**
+     * Destroy the floor plan instance
+     */
+    destroy(): void;
+}
+
+/**
+ * The main Floor plan engine SDK class
+ */
+export declare class FloorPlanEngine extends FloorPlanCore {
+    fpeNode?: HTMLElement;
+    view: WebGlView;
+    interaction: FpeInteraction;
+    availableHelpers: {
+        [name: string]: typeof Helper;
+    };
+    helper: {
+        [name: string]: Helper;
+    };
+    preventUpdateOnSpaceGraphEvent: boolean;
+    constructor({ container, options }?: {
+        container?: Element;
+        options?: FpeConfig;
+    });
+    prevent(e: any): void;
+    /**
+     * Subscribe to an event
+     */
+    on<EventType extends FpeEvent, Context>(event: EventType, handler: FpeEventHandler<EventType>, ctx?: Context): this;
+    /**
+     * Subscribe to an event once
+     */
+    once<EventType extends FpeEvent, Context>(event: EventType, handler: FpeEventHandler<EventType>, ctx?: Context): this;
+    /**
+     * Unsubscribe from an event
+     */
+    off<EventType extends FpeEvent, Context>(event: EventType, handler?: FpeEventHandler<EventType>, ctx?: Context): this;
+    emit<EventType extends FpeEvent>(event: EventType, ...args: FpeEventMap[EventType]): this;
+    handleDrop(evt: DragEvent): void;
+    /**
+     * Change options after the floor plan engine instance has been created
+     * @param args - Startup options
+     */
+    set(args: FpeConfig): void;
+    drawNodePreview(id: string, layout: SpaceGraphLayout, layer: PlanLayer, style?: ShapeStyle): void;
+    drawNodeUpdate(id: string, style?: 'selected' | ShapeStyle | false): void;
+    drawResourceUpdate({ resourceId }: {
+        resourceId: string;
+    }): void;
+    mountFloorPlan(root: Element): void;
+    initDrawing(): void;
+    initDrawingEvents(): void;
+    freeDrawingEvents(): void;
+    generateUi(): void;
+    getBoundingBox(margin?: number): BoundingBox2d;
+    /**
+     * Get a bounding box containing the layout, with some padding
+     * @param layoutBoundingBox - bounding box of the layout, in meters.
+     * @param rectLeft - left edge of a rectangle into which the layout should fit, in pixels.
+     * @param rectTop - top edge of a rectangle into which the layout should fit, in pixels.
+     * @param rectRight - right edge of a rectangle into which the layout should fit, in pixels.
+     * @param rectBottom - bottom edge of a rectangle into which the layout should fit, in pixels.
+     * @param viewportWidth - width in pixels of the canvas.
+     * @param viewportHeight - height in pixels of the canvas.
+     * @returns returns a new bounding box
+     */
+    getZoomExtentsBoundingBox(layoutBoundingBox: BoundingBox2d, rectLeft: number, rectTop: number, rectRight: number, rectBottom: number, viewportWidth: number, viewportHeight: number): BoundingBox2d;
+    /**
+     * Zoom to the extent of the scene in the viewport ( wait for loadScene promise )
+     * @param margin - margin around scene in meters. Defaults to 1 meter
+     * @param animate - duration in milliseconds of the animation for the viewport transform. If true, the duration will be 500ms. If false or not provided there will be no animation
+     * @param boundingBox - bounding box to zoom to. Can for example be calculated via getZoomExtentsBoundingBox(…). If provided, the margin parameter will be ignored
+     * @returns returns promise which resolves when animation is done
+     */
+    zoomExtents(margin?: number, animate?: Animate, boundingBox?: BoundingBox2d): Promise<boolean>;
+    /**
+     * Zoom to the bounding box of an element ( wait for loadScene promise )
+     * @param node - id of a node or the node itself
+     * @param margin - margin around scene in meters
+     * @param animate - duration of the animation for the viewport transform, if not provided there will be no animation
+     * @returns returns promise which resolves when animation is done
+     */
+    zoomToElement(node: string | LayoutElement | SpatialGraphEdge | LayoutSpace, margin?: number, animate?: Animate): Promise<boolean | Error>;
+    /**
+     * set zoom to a specific bounding box
+     * @param bb - bounding box
+     * @param animate - duration of the animation for the viewport transform, if not provided there will be no animation
+     * @returns returns promise which resolves when animation is done
+     */
+    setZoom(bb: BoundingBox2d, animate?: Animate): Promise<boolean>;
+    /**
+     * zoom the current view by a factor
+     * @param factor - zoom factor, larger than 1 zooms in, smaller than 1 zooms out
+     * @param animate - duration of the animation for the viewport transform, if not provided there will be no animation
+     * @returns returns promise which resolves when animation is done
+     */
+    zoomByFactor(factor: number, animate?: Animate): Promise<boolean>;
+    /**
+     * Add HTML info window
+     */
+    addInfoWindow(args?: InfoWindowArgs): InfoWindow;
+    /**
+     * Add custom HTML marker
+     */
+    addHtmlMarker(args?: HtmlMarkerArgs): HtmlMarker;
+    /**
+     * Add plan marker
+     */
+    addMarker({ position, color, size }?: MarkerArgs): MarkerPin;
+    /**
+     * Convert screen coordinates to plan coordinates
+     */
+    getPlanPosition(point: Vector2_2): Vector2_2;
+    /**
+     * Convert plan coordinates to screen coordinates
+     */
+    getScreenPosition(point: Vector2_2): Vector2_2;
+    /**
+     * create plan layer or return existing by id
+     */
+    addLayer({ id, baseLayer }?: {
+        id?: string;
+        baseLayer?: BaseLayers;
+    }): PlanLayer;
+    /**
+     * get plan layer by name
+     */
+    getLayer(id: any): PlanLayer;
+    /**
+     * create plan graphic
+     * @deprecated use floorPlan.addLayer(<name>)
+     * @returns
+     */
+    addPlanGraphic(): PlanLayer;
+    /**
+     * Adds a helper and removes previous instances of it
+     */
+    addHelper(helper: string | typeof Helper, options?: any): Helper;
+    removeHelper(helperId: string): void;
+    /**
+     * Export the current view as an image
+     */
+    exportImage({ format, fileName, quality, output, maxWidth, download }?: ExportImage): Promise<string | Error>;
+    /**
+     * Destroy the floor plan instance
+     */
+    destroy(): void;
+}
+
+/**
+ * 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?: {
+            /** @deprecated show the usage information in room stamps */
+            showUsage?: boolean;
+            /** @deprecated show the area information in room stamps */
+            showArea?: boolean;
+            /** show the area information in room stamps */
+            roomStampDisplay?: ('usage' | 'area' | 'customId' | 'name' | 'id')[];
+            /** 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 type FpeComputed = {
+    wallContours: PolygonWithHoles[];
+    snapPoints: Vector2_2[];
+    snapMargin: number;
+};
+
+declare interface FpeConfig extends StartupOptions {
+    api?: {
+        productDataCacheAge?: number;
+        productContourCacheAge?: number;
+    } & TokenOptions;
+    loadTextures?: boolean;
+    showFloorPlan?: boolean;
+    showSpaceDividers?: boolean;
+    showCeilingLamps?: boolean;
+    svgViewBoxDim?: number;
+    svgMode?: boolean;
+    destroyOnDomRemove?: boolean;
+}
+
+export declare type FpeCoreEvent = keyof FpeCoreEventMap;
+
+declare type FpeCoreEventHandler<EventType extends FpeCoreEvent> = FpeCoreEventMap[EventType] extends any[] ? (...args: FpeCoreEventMap[EventType]) => void : never;
+
+declare type FpeCoreEventMap = {
+    'update-settings': [event: FpeConfig];
+    'space-api-floor-loaded': [id: string];
+    'space-api-floor-error': [id: string, error: string];
+};
+
+export declare type FpeDragEvent = {
+    position: Vector2_2;
+    screenPos: Vector2_2;
+    sourceEvent: FpeInteractionEvent;
+};
+
+export declare type FpeDropEvent = {
+    position: Vector2_2;
+    screenPos: Vector2_2;
+    verticalPos: number;
+    sourceEvent: DragEvent;
+};
+
+export declare type FpeEvent = keyof FpeEventMap;
+
+declare type FpeEventHandler<EventType extends FpeEvent> = FpeEventMap[EventType] extends any[] ? (...args: FpeEventMap[EventType]) => void : never;
+
+export declare type FpeEventMap = FpeCoreEventMap & {
+    click: [event: FpePointerEvent];
+    dblclick: [event: FpePointerEvent];
+    'context-menu': [event: FpePointerEvent];
+    mousemove: [event: FpePointerEvent];
+    drop: [event: FpeDropEvent];
+    'drag-move': [event: FpeDragEvent];
+    'drag-start': [event: FpeDragEvent];
+    'drag-end': [event: FpeDragEvent];
+    key: [event: FpeKeyEvent];
+    keyup: [event: FpeKeyEvent];
+    focus: [event: boolean];
+    'resource-loaded': [event: {
+        resourceId: string;
+    }];
+    'spaces-loaded': [];
+    'loading-status': [event: {
+        totalCount: number;
+        doneCount: number;
+    }];
+    'loading-done': [event: {
+        totalCount: number;
+    }];
+};
+
+declare interface FpeInteraction {
+    lastSceneClick: Vector2_2;
+    cursor: Vector2_2;
+    cursorTarget: LayoutElement | LayoutSpace;
+    isDragging: boolean;
+    isPanning: boolean;
+    lastClick: {
+        time: number;
+        position: ScreenPosition;
+    };
+    metaKey: boolean;
+    ctrlKey: boolean;
+    altKey: boolean;
+    shiftKey: boolean;
+    dragOffset: Vector2_2;
+    cursorAction: 'split-wall' | 'duplicate' | 'move' | 'select' | 'none';
+    _dragStart: ScreenPosition;
+    preventFocusoutOnAltKeyup: boolean;
+}
+
+export declare type FpeInteractionEvent = FpeInteractionEventType[keyof FpeInteractionEventType];
+
+export declare type FpeInteractionEventType = {
+    /* Excluded from this release type: pixi */
+    dom: MouseEvent;
+};
+
+export declare type FpeKeyEvent = {
+    key: string;
+    lowerCaseKey: string;
+    sourceEvent: KeyboardEvent;
+};
+
+declare class FpeLoader extends TinyEmitter {
+    promiseCache: Map<string, Promise<any>>;
+    loadStages: {
+        product: boolean;
+        productContour: boolean;
+        productTexture: boolean;
+    };
+    queue: Record<ResourceFormats, Map<string, Promise<any>>>;
+    resources: {
+        nodes: Map<string, Set<LayoutAsset | LayoutFloorPlanImageAnnotation>>;
+        productJson: Map<string, ProductAttributes>;
+        productContour: Map<string, Polygon[]>;
+        texture: Map<string, TextureData>;
+    };
+    floorPlan: FloorPlanCore;
+    productContourCacheAge: number;
+    productDataCacheAge: number;
+    initialLoading: boolean;
+    _requestCounter: number;
+    _loadCounter: number;
+    on: (event: LoadingEvent, callback: Function, ctx?: any) => this;
+    once: (event: LoadingEvent, callback: Function, ctx?: any) => this;
+    off: (event: LoadingEvent, callback?: Function) => this;
+    emit: (event: LoadingEvent, ...args: any[]) => this;
+    constructor(floorPlan: FloorPlanCore);
+    loadStatus(): void;
+    loadResources(resourceId: string, node: LayoutAsset, formats: ResourceFormats[]): Promise<any[]>;
+    loadResource(resourceId: string, node: LayoutAsset, format: ResourceFormats): any;
+    reset(): void;
+}
+
+export declare type FpePointerEvent = {
+    nodeId?: string;
+    position: Vector2_2;
+    isDoubleClick?: boolean;
+    sourceEvent: FpeInteractionEvent;
+};
+
+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;
+}
+
+export declare interface GraphicArgs {
+    shapes: Shape[];
+    position?: Vector2_2;
+    alpha?: number;
+    clearLayer?: boolean;
+    scale?: number;
+    interactive?: boolean;
+    updatePositionOnDrag?: boolean;
+    id?: string;
+    isHandler?: boolean;
+    scaleOnZoom?: boolean;
+}
+
+declare type GraphicUpdate = {
+    position?: Vector2_2;
+    style?: ShapeStyle;
+    shapes?: Shape[];
+};
+
+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;
+}
+
+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 class Helper extends TinyEmitter {
+    floorPlan: FloorPlanEngine;
+    helperId: string;
+    constructor({ floorPlan, helperId }: {
+        floorPlan: FloorPlanEngine;
+        helperId: string;
+    });
+    destroy(): void;
+}
+
+/**
+ * Elements that can be hidden in the floor plan
+ */
+declare type HideableElement = LayoutElement['type'] | LayoutSpace['type'] | SpatialGraphEdge['type'] | LayoutAnnotation['type'] | 'roomStamp';
+
+declare type HingeSide = 'left' | 'right';
+
+declare class HtmlMarker {
+    position: Vector2_2;
+    size: Vector2_2;
+    offset: Vector2_2;
+    isHidden: boolean;
+    id: string;
+    el: HTMLElement;
+    private _floorPlan;
+    private _anchorPos;
+    constructor({ position, offset, el, floorPlan }: HtmlMarkerState);
+    _updateHtmlMarker: () => void;
+    _updateHtmlMarkerStyle(): void;
+    set({ position, offset }: Pick<HtmlMarkerArgs, 'position' | 'offset'>): void;
+    remove(): void;
+}
+
+declare interface HtmlMarkerArgs {
+    /** coordinates of the window in meters */
+    position?: Vector2_2;
+    offset?: Vector2_2;
+    /** html string as content of the info window */
+    el?: HTMLElement;
+    /** If true , a close button will appear in the top right corner of the info window. */
+    closeButton?: boolean;
+}
+
+declare interface HtmlMarkerState extends HtmlMarkerArgs {
+    floorPlan: FloorPlanEngine;
+}
+
+declare type IndexRange = {
+    type: 'index:range';
+    start: number;
+    end: number;
+};
+
+declare class InfoWindow {
+    private _floorPlan;
+    position: Vector2_2;
+    height: number;
+    width: number;
+    closeButton: any;
+    html: any;
+    el: Element;
+    private _anchorPos;
+    private _getPosition;
+    constructor({ width, height, position, html, closeButton, floorPlan }?: InfoWindowState);
+    _createInfoWindow(): void;
+    _setContent(): void;
+    _updateInfoWindow(): void;
+    set({ width, height, position, html, closeButton }: {
+        width: any;
+        height: any;
+        position: any;
+        html: any;
+        closeButton: any;
+    }): void;
+    remove(): void;
+}
+
+declare interface InfoWindowArgs {
+    /** pixel width of the window - default 100 */
+    width?: number;
+    /** pixel height of the window - default 80 */
+    height?: number;
+    /** coordinates of the window in meters */
+    position?: Vector2_2;
+    /** html string as content of the info window */
+    html?: string;
+    /** If true , a close button will appear in the top right corner of the info window. */
+    closeButton?: boolean;
+}
+
+declare interface InfoWindowState extends InfoWindowArgs {
+    floorPlan?: FloorPlanEngine;
+}
+
+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;
+}
+
+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$6;
+
+declare type LayoutBeamParametersJson = DimensionParameters & Partial<CommonParameters$6>;
+
+declare type LayoutBeamType = typeof LayoutBeamTypeValue;
+
+declare const LayoutBeamTypeValue = "element:beam";
+
+declare class LayoutBoundary {
+    vertices: SpatialGraphVertex[];
+    edges: SpatialGraphEdge[];
+    geometryProfile: Vector2[];
+}
+
+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$5;
+
+declare type LayoutCaseworkParametersJson = DimensionParameters & Partial<CommonParameters$5>;
+
+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;
+    height: number;
+    materials: LayoutColumnMaterials;
+}
+
+declare type LayoutColumnParametersJson = Partial<LayoutColumnParameters>;
+
+declare type LayoutColumnProfile = RectangleCurve | CircleCurve | PolygonCurve;
+
+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$4;
+
+declare type LayoutDoorParametersJson = DimensionParameters$2 & Partial<CommonParameters$4>;
+
+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;
+    getEndVertex(): SpatialGraphVertex;
+    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[];
+}
+
+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;
+    getBoundingBox(localTransform?: boolean): TransformBoundingBox3d;
+    removeElement(element: LayoutElement): void;
+    copyForClone(element: LayoutElement): void;
+    setParameters(parameters: RecursivePartial<LayoutElementParameters>): void;
+    getSpaces(): LayoutSpace[];
+}
+
+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;
+    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;
+
+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$3;
+
+declare type LayoutKitchenParametersJson = DimensionParameters & Partial<CommonParameters$3>;
+
+declare type LayoutKitchenType = typeof LayoutKitchenTypeValue;
+
+declare const LayoutKitchenTypeValue = "element:kitchen";
+
+declare type LayoutNode = SpatialGraphNode | LayoutSpace | LayoutElement | LayoutAnnotation | LayoutView;
+
+declare class LayoutNodeBase extends SpaceGraphNodeBase {
+    type: LayoutNodeType;
+    layout: SpaceGraphLayout;
+    constructor(id: string, type: LayoutNodeType);
+}
+
+declare interface LayoutNodeBaseJson extends SpaceGraphNodeBaseJson {
+    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[];
+}
+
+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$2;
+
+declare type LayoutRailingParametersJson = DimensionParameters & Partial<CommonParameters$2>;
+
+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$1;
+
+declare type LayoutRampParametersJson = DimensionParameters & Partial<CommonParameters$1>;
+
+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;
+
+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;
+    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;
+    attachSlab(slab: LayoutBoundarySlab): void;
+    detachSlab(slab: LayoutBoundarySlab): void;
+}
+
+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(): {
+        min: Vector3;
+        max: Vector3;
+        transform: Transform3d;
+    };
+}
+
+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;
+}
+
+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 type LayoutView = Layout2dView | Layout3dView;
+
+declare class LayoutViewBase extends LayoutNodeBase {
+    type: LayoutViewType;
+    parameters: LayoutViewParameters;
+    copyForClone(view: LayoutView): void;
+    setParameters(parameters: RecursivePartial<LayoutViewParameters>): void;
+}
+
+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(): {
+        min: Vector3;
+        max: Vector3;
+        transform: Transform3d;
+    };
+}
+
+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 {
+    width: number;
+    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$1 & CommonParameters;
+
+declare type LayoutWindowParametersJson = DimensionParameters$1 & Partial<CommonParameters>;
+
+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 type LoadingEvent = 'loading-done' | 'loading-status' | 'resource-loaded' | 'product-load-texture' | 'spaces-loaded' | 'assets-loaded';
+
+declare interface MarkerArgs {
+    /** coordinates of the marker in meters */
+    position?: Vector2_2;
+    /** color of the marker, hex code */
+    color?: string;
+    /** size in pixels */
+    size?: number;
+    floorPlan?: FloorPlanEngine;
+}
+
+declare class MarkerPin {
+    position: Vector2_2;
+    color: string;
+    size: number;
+    id: string;
+    layer: PlanLayer;
+    graphic: PlanGraphic;
+    private floorPlan;
+    constructor({ position, color, size, floorPlan }: MarkerArgs);
+    draw(): void;
+    remove(): void;
+    on(eventType: string, callback: any, context?: any): void;
+    off(eventType?: string, callback?: any): void;
+    set(updateArgs: MarkerUpdateArgs): void;
+}
+
+declare interface MarkerUpdateArgs {
+    events?: {
+        [event: string]: {
+            callback: any;
+            context: any;
+        };
+    };
+}
+
+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";
+
+declare type NodesByType<NodeMap extends NodeTypeMap = {}> = {
+    -readonly [K in keyof NodeMap]: InstanceType<NodeMap[K]>[];
+};
+
+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 interface OrthogonalStairsParameters {
+    stairsType: OrthogonalStairsType;
+    length: number;
+    width: number;
+    height: number;
+    stepWidth: number;
+    circulation: 'left' | 'right';
+    railing: 'none' | 'left' | 'right' | 'both';
+    materials: LayoutStairsMaterials;
+}
+
+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 class PlanGraphic {
+    shapes: Shape[];
+    /* Excluded from this release type: gfx */
+    scaleOnZoom: boolean;
+    /* Excluded from this release type: container */
+    gfxScale: number;
+    private floorPlan;
+    constructor({ shapes, position, alpha, scale, clearLayer, interactive, id, isHandler, scaleOnZoom, updatePositionOnDrag, baseLayer, container, floorPlan }: PlanGraphicArgs);
+    set({ position, style, shapes }?: GraphicUpdate): void;
+    private doUpdatePositionOnDrag;
+    on(event: string, callback: any, context?: any): this;
+    off(event: string, callback?: any): this;
+    destroy(): void;
+    private addDragEvent;
+    private removeDragEvent;
+}
+
+declare interface PlanGraphicArgs extends GraphicArgs {
+    floorPlan: FloorPlanEngine;
+    /* Excluded from this release type: baseLayer */
+    /* Excluded from this release type: container */
+    [key: string]: any;
+}
+
+declare class PlanLayer {
+    /* Excluded from this release type: container */
+    graphics: Set<PlanGraphic>;
+    id: string;
+    private baseLayer;
+    private floorPlan;
+    constructor(floorPlan: FloorPlanEngine, baseLayer?: BaseLayers, id?: string);
+    addGraphic(args: GraphicArgs): PlanGraphic;
+    deleteGraphic(graphic: PlanGraphic): void;
+    /**
+     * clear all shapes from the layer
+     */
+    clear(): void;
+    /**
+     * destroy layer and all shapes
+     */
+    destroy(): void;
+}
+
+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 BaseShape {
+    type: 'curve:polygonWithHoles';
+    polygons: 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 ProductAttributes = SpaceGraphProduct['attributes'];
+
+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 type ResourceFormats = 'productJson' | 'productContour' | 'texture';
+
+/**
+ * This interface was referenced by `AuthJson`'s JSON-Schema
+ * via the `definition` "resourceScope".
+ */
+declare type ResourceScope =
+| "customFields"
+| "customAttributes"
+| "customAttributeValues"
+| "organization"
+| "dxf"
+| "floor"
+| "job"
+| "order"
+| "product"
+| "user"
+| "team"
+| "superadmin"
+| "token"
+| "subscription"
+| "graphql";
+
+declare type Rgb = [number, number, number];
+
+declare type RgbA = [number, number, number, number];
+
+declare type RotationEntry = number | NumberList | NumberRange;
+
+/**
+ * This interface was referenced by `AuthJson`'s JSON-Schema
+ * via the `definition` "scopeDefinition".
+ */
+declare interface ScopeDefinition {
+    resource: ResourceScope;
+    action?: ActionScope;
+    resourceId?: string;
+}
+
+/**
+ * This interface was referenced by `AuthJson`'s JSON-Schema
+ * via the `definition` "scopeDefinitionArray".
+ */
+declare type ScopeDefinitionArray = ScopeDefinition[];
+
+declare type ScreenPosition = {
+    x: number;
+    y: number;
+};
+
+export declare const setApiUrls: ({ apiStorageUrl: newApiStorageUrl, spaceApiUrl, apiProductDataPath: newApiProductDataPath }?: ApiUrls) => void;
+
+export declare type Shape = PolygonCurve_2 | PolygonWithHolesCurve | PolylineCurve_2 | RectangleCurve_2 | CircleCurve_2 | LineCurve_2 | GroupShape | TextShape | ArcCurve_2 | BezierCurve | CompositeCurve_2;
+
+declare type ShapeLayers = Record<string, Shape[]>;
+
+declare interface ShapeStyle {
+    stroke?: string | number | number[];
+    strokeWidth?: number | 'native';
+    strokeOpacity?: number;
+    fill?: string | number | number[] | false;
+    fillOpacity?: number;
+    dash?: boolean;
+}
+
+declare class SpaceGraph {
+    spatialStructure: SpaceGraphSpatialStructure;
+    products: SpaceGraphProduct[];
+    productsById: Record<string, SpaceGraphProduct>;
+    productsByType: NodesByType<{
+        readonly 'product:static': typeof SpaceGraphProduct;
+    }>;
+    geometries: SpaceGraphGeometryJson[];
+    geometriesById: Record<string, SpaceGraphGeometryJson>;
+    geometriesByType: NodesByType<{
+        readonly 'geometry:plane': typeof PlaneGeometry;
+        readonly 'geometry:cuboid': typeof CuboidGeometry;
+        readonly 'geometry:sphere': typeof SphereGeometry;
+        readonly 'geometry:extrusion': typeof ExtrusionGeometry;
+        readonly 'geometry:mesh': typeof MeshGeometry;
+        readonly 'geometry:uri': typeof 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': typeof PlaneGeometry;
+        readonly 'geometry:cuboid': typeof CuboidGeometry;
+        readonly 'geometry:sphere': typeof SphereGeometry;
+        readonly 'geometry:extrusion': typeof ExtrusionGeometry;
+        readonly 'geometry:mesh': typeof MeshGeometry;
+        readonly 'geometry:uri': typeof UriGeometry;
+        readonly 'spatialGraph:edge': typeof SpatialGraphEdge;
+        readonly 'spatialGraph:vertex': typeof SpatialGraphVertex;
+        readonly 'layout:space': typeof LayoutSpace;
+        readonly 'view:2d': typeof Layout2dView;
+        readonly 'view:3d': typeof Layout3dView;
+        readonly 'annotation:floorPlanDxf': typeof LayoutFloorPlanDxfAnnotation;
+        readonly 'annotation:floorPlanImage': typeof LayoutFloorPlanImageAnnotation;
+        readonly 'element:ceiling': typeof LayoutBoundarySlab;
+        readonly 'element:floor': typeof LayoutBoundarySlab;
+        readonly 'element:boundaryWall': typeof LayoutBoundaryWall;
+        readonly 'element:curtainWall': typeof LayoutCurtainWall;
+        readonly 'element:spaceDivider': typeof LayoutSpaceDivider;
+        readonly 'element:wall': typeof LayoutWall;
+        readonly 'element:opening': typeof LayoutOpening;
+        readonly 'element:asset': typeof LayoutAsset;
+        readonly 'element:beam': typeof LayoutBeam;
+        readonly 'element:casework': typeof LayoutCasework;
+        readonly 'element:column': typeof LayoutColumn;
+        readonly 'element:door': typeof LayoutDoor;
+        readonly 'element:generic': typeof LayoutGeneric;
+        readonly 'element:kitchen': typeof LayoutKitchen;
+        readonly 'element:railing': typeof LayoutRailing;
+        readonly 'element:ramp': typeof LayoutRamp;
+        readonly 'element:roof': typeof LayoutRoof;
+        readonly 'element:slab': typeof LayoutSlab;
+        readonly 'element:stairs': typeof LayoutStairs;
+        readonly 'element:stairFlight': typeof LayoutStairFlight;
+        readonly 'element:window': typeof LayoutWindow;
+    }>;
+    private emitter;
+    constructor();
+    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;
+    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;
+}
+
+declare class SpaceGraphBasicMaterial extends SpaceGraphNodeBase {
+    type: SpaceGraphBasicMaterialType;
+    colorDiffuse: Rgb;
+    colorSpecular: Rgb;
+    specularCoefficient: number;
+    opacity: number;
+    constructor(id: string);
+    copyForClone(material: SpaceGraphBasicMaterial): void;
+}
+
+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;
+}
+
+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);
+}
+
+declare interface SpaceGraphColorMaterialJson extends SpaceGraphMaterialBaseJson {
+    type: SpaceGraphColorMaterialType;
+    value: Rgb | RgbA | string;
+}
+
+declare type SpaceGraphColorMaterialType = typeof SpaceGraphColorMaterialTypeValue;
+
+declare const SpaceGraphColorMaterialTypeValue = "material:color";
+
+declare class SpaceGraphEmbeddedMaterial extends SpaceGraphNodeBase {
+    type: SpaceGraphEmbeddedMaterialType;
+    reference: string;
+    format: SpaceGraphEmbeddedMaterialFormat;
+    constructor(id: string, reference: string, format: SpaceGraphEmbeddedMaterialFormat);
+}
+
+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];
+    'node-id-change': [SpaceGraphNodeBase, string];
+    'node-property-change': [SpaceGraphNodeBase, string];
+    '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];
+    'element-parameters-change': [LayoutElementBase];
+    'element-transform-change': [LayoutTransformElementBase];
+    '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;
+}
+
+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': typeof LayoutCurtainWall;
+        readonly 'element:spaceDivider': typeof LayoutSpaceDivider;
+        readonly 'element:wall': typeof LayoutWall;
+        readonly 'element:opening': typeof LayoutOpening;
+        readonly 'element:asset': typeof LayoutAsset;
+        readonly 'element:beam': typeof LayoutBeam;
+        readonly 'element:casework': typeof LayoutCasework;
+        readonly 'element:column': typeof LayoutColumn;
+        readonly 'element:door': typeof LayoutDoor;
+        readonly 'element:generic': typeof LayoutGeneric;
+        readonly 'element:kitchen': typeof LayoutKitchen;
+        readonly 'element:railing': typeof LayoutRailing;
+        readonly 'element:ramp': typeof LayoutRamp;
+        readonly 'element:roof': typeof LayoutRoof;
+        readonly 'element:slab': typeof LayoutSlab;
+        readonly 'element:stairs': typeof LayoutStairs;
+        readonly 'element:stairFlight': typeof LayoutStairFlight;
+        readonly 'element:window': typeof LayoutWindow;
+    }>;
+    annotations: LayoutAnnotation[];
+    annotationsById: Record<string, LayoutAnnotation>;
+    annotationsByType: NodesByType<{
+        readonly 'annotation:floorPlanDxf': typeof LayoutFloorPlanDxfAnnotation;
+        readonly 'annotation:floorPlanImage': typeof LayoutFloorPlanImageAnnotation;
+    }>;
+    views: LayoutView[];
+    viewsById: Record<string, LayoutView>;
+    viewsByType: NodesByType<{
+        readonly 'view:2d': typeof Layout2dView;
+        readonly 'view:3d': typeof 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;
+}
+
+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 | 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;
+}
+
+declare interface SpaceGraphNodeBaseJson extends SpaceGraphTypedValueJson {
+    /** @format uuid */
+    id: string;
+    name?: string;
+    customId?: string;
+}
+
+declare class SpaceGraphProduct extends SpaceGraphNodeBase {
+    type: SpaceGraphProductType;
+    attributes: SpaceGraphProductAttributes;
+    geometries: GeometryOperationJson[];
+    constructor(id: string);
+    copyForClone(product: SpaceGraphProduct): void;
+    setAttributes(attributesJson: SpaceGraphProductAttributesJson): void;
+}
+
+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 SpaceGraphNodeBaseJson {
+    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[];
+}
+
+declare type SpaceGraphSpatialStructure = SpaceGraphBuilding | SpaceGraphFloor | SpaceGraphLayout;
+
+declare class SpaceGraphSpatialStructureBase extends SpaceGraphNodeBase {
+    type: SpaceGraphSpatialStructureType;
+    constructor(id: string, type: SpaceGraphSpatialStructureType);
+}
+
+declare interface SpaceGraphSpatialStructureBaseJson extends SpaceGraphNodeBaseJson {
+    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);
+}
+
+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;
+}
+
+/**
+ * Map space labels by space usage or space id to a custom name
+ * @example { kitchen: 'cuisine' }
+ */
+declare type SpaceLabelMapping = {
+    [label: string]: string;
+};
+
+declare interface SpaceShapeStyle extends ShapeStyle {
+    usage?: {
+        [key: string]: ShapeStyle;
+    };
+    program?: {
+        [key: string]: ShapeStyle;
+    };
+}
+
+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];
+    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;
+}
+
+declare interface SpatialGraphEdgeJson extends SpatialGraphNodeBaseJson {
+    type: SpatialGraphEdgeType;
+    vertices: [string, string];
+}
+
+declare type SpatialGraphEdgeType = typeof SpatialGraphEdgeTypeValue;
+
+declare const SpatialGraphEdgeTypeValue = "spatialGraph:edge";
+
+declare type SpatialGraphNode = 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;
+}
+
+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;
+    width: number;
+    height: number;
+    circulation: 'left' | 'right';
+    materials: LayoutStairFlightMaterials;
+}
+
+declare type SpiralStairFlightParametersJson = Partial<SpiralStairFlightParameters>;
+
+declare interface SpiralStairsParameters {
+    stairsType: SpiralStairsType;
+    radius: number;
+    angle: number;
+    height: number;
+    stepWidth: number;
+    circulation: 'left' | 'right';
+    railing: 'none' | 'left' | 'right' | 'both';
+    materials: LayoutStairsMaterials;
+}
+
+declare type SpiralStairsParametersJson = Partial<SpiralStairsParameters>;
+
+declare type SpiralStairsType = 'spiral';
+
+declare interface StartupOptions {
+    /** do not render elements of given types (e.g. 'element:asset', 'element:door', …), or 'roomStamp' */
+    hideElements?: HideableElement[];
+    preserveViewbox?: string;
+    /** option to disable panning and zooming */
+    panZoom?: boolean;
+    /** if set, panning and zooming is restricted to the scene boundingbox plus the margin */
+    panZoomMargin?: number;
+    /** if set room stamps have a fixed size - otherwise they adapt to the zoom level */
+    roomStampSize?: number;
+    /** toggle overlaying UI elements */
+    ui?: UI;
+    /** floor plan theming */
+    theme?: FloorPlanTheme;
+    /** custom shape layers */
+    shapeLayers?: ShapeLayers;
+    /** mapping table for custom space labels */
+    spaceLabelMapping?: SpaceLabelMapping;
+    /** set the unit system */
+    units?: Units;
+    /** min and max zooming factor. Defaults to [3, 300] */
+    zoomRange?: [number, number];
+}
+
+declare interface StraightStairFlightParameters {
+    stairFlightType: 'straight';
+    length: number;
+    width: number;
+    height: number;
+    materials: LayoutStairFlightMaterials;
+}
+
+declare type StraightStairFlightParametersJson = Partial<StraightStairFlightParameters>;
+
+declare interface StraightStairsParameters {
+    stairsType: StraightStairsType;
+    length: number;
+    width: number;
+    height: number;
+    railing: 'none' | 'left' | 'right' | 'both';
+    materials: LayoutStairsMaterials;
+}
+
+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;
+}
+
+/**
+ * This interface was referenced by `AuthJson`'s JSON-Schema
+ * via the `definition` "temporaryAccessToken".
+ */
+declare interface TemporaryAccessToken {
+    authorization: string;
+    expiresAt: number;
+}
+
+declare type TemporaryAccessTokenFunction = (args: CreateTemporaryAccessToken) => Promise<TemporaryAccessToken>;
+
+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 TextureData = {
+    textureUrl: string;
+    applyFilter: TextureFilter;
+    texture?: any;
+    contourTexture?: any;
+    imageData?: any;
+    error?: {
+        message: string;
+    };
+    anchor?: {
+        x: number;
+        y: number;
+    };
+    offset?: {
+        x: number;
+        y: number;
+    };
+    position?: {
+        x: number;
+        y: number;
+    };
+};
+
+declare enum TextureFilter {
+    None = 0,
+    Default = 1,
+    Grayscale = 2
+}
+
+declare class Ticker {
+    methods: {
+        [name: string]: {
+            fn: Function;
+            ctx: WebGlView;
+        };
+    };
+    add: (name: string, fn: Function, ctx: WebGlView) => void;
+    remove: (name: string) => void;
+}
+
+declare class TinyEmitter {
+    on(event: string, callback: Function, ctx?: any): this;
+    once(event: string, callback: Function, ctx?: any): this;
+    emit(event: string, ...args: any[]): this;
+    off(event: string, callback?: Function): this;
+}
+
+declare interface TokenOptions {
+    publishableAccessToken?: string;
+    secretAccessToken?: string;
+    temporaryAccessToken?: TemporaryAccessToken;
+    temporaryAccessTokenFunction?: TemporaryAccessTokenFunction;
+    temporaryAccessTokenScopes?: ScopeDefinitionArray;
+    sdkVersion?: string;
+}
+
+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 type UI = {
+    /** Show a dynamic scale indicator */
+    scale?: boolean;
+    /** Show the current cursor position in plan coordinates */
+    coordinates?: boolean;
+};
+
+/**
+ * Which unit system and how to display the units
+ */
+declare type Units = {
+    /** meters or feet? */
+    system?: 'metric' | 'imperial';
+    /** how many decimals should be shown for lengths? */
+    lengthDecimals?: number;
+    /** how many decimals should be shown for areas? */
+    areaDecimals?: number;
+    /** if 'area', it displays e.g. 12 m². If 'boundingBox'it displays e.g. 4 m x 3 m */
+    roomDimensions?: 'area' | 'boundingBox';
+};
+
+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 type ViewEvent = 'pan' | 'zoom' | 'viewbox' | 'resize-canvas' | 'scene-rendered' | 'focus';
+
+declare class WebGlView extends TinyEmitter {
+    windowPos: Vector2_2;
+    zoom: number;
+    client: Vector2_2;
+    layers: Map<string, PlanLayer>;
+    viewbox: BoundingBox2d;
+    styleCache: Record<string, ShapeStyle | 'selected'>;
+    viewportNeedsUpdate: boolean;
+    viewportPaused: boolean;
+    viewportInFocus: boolean;
+    wallNodesToUpdate: any[];
+    wallNodeUpdateInProgress: boolean;
+    parentEl: HTMLElement;
+    _settings: FpeConfig;
+    /* Excluded from this release type: gfxLayers */
+    redrawScene: () => void;
+    /* Excluded from this release type: gfxNodes */
+    /* Excluded from this release type: _viewport */
+    /* Excluded from this release type: _canvasMargin */
+    /* Excluded from this release type: _renderer */
+    /* Excluded from this release type: _stage */
+    _dummyTexture: any;
+    /* Excluded from this release type: _zoomTarget */
+    _oldTime: number;
+    ticker?: Ticker;
+    on: (event: ViewEvent, callback: Function, ctx?: any) => this;
+    once: (event: ViewEvent, callback: Function, ctx?: any) => this;
+    off: (event: ViewEvent, callback?: Function) => this;
+    emit: (event: ViewEvent, ...args: any[]) => this;
+    constructor(loader: FpeLoader, settings: FpeConfig, parentEl: HTMLElement);
+    /**
+     * main animation loop
+     */
+    draw(): void;
+    startAnimationLoop(): void;
+    stopAnimationLoop(): void;
+    updateView(): void;
+    watchResize(): Promise<void>;
+    get gfxNodeCount(): number;
+    reset(): void;
+    pause(interaction?: string): void;
+    resume(interaction?: string): void;
+}
+
+export { }