@archilogic/floor-plan-sdk 3.2.1 → 4.4.1

package/dist/fpe.d.ts

@@ -0,0 +1,1476 @@
+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 };