@xeokit/xeokit-sdk 2.2.4 → 2.2.5-beta-2

package/types/plugins/TreeViewPlugin/TreeViewPlugin.d.ts

@@ -0,0 +1,136 @@
+import { Plugin, Viewer } from "../../viewer";
+import { ModelTreeView } from "./ModelTreeView";
+import { TreeViewNode } from "./TreeViewNode";
+
+export declare type TreeViewPluginConfiguration = {
+  /** DOM element to contain the TreeViewPlugin. */
+  containerElement: HTMLElement;
+  /** When ````true```` (default), will automatically add each model as it's created. Set this ````false```` if you want to manually add models using {@link TreeViewPlugin#addModel} instead. */
+  autoAddModels?: boolean;
+  /** Optional depth to which to initially expand the tree. */
+  autoExpandDepth?: number;
+  /** How to organize the tree nodes: "containment", "storeys" or "types". See the class documentation for details. */
+  hierarchy?: "containment" | "storeys" | "types";
+  /** When true, will sort the children of each node. */
+  sortNodes?: boolean;
+  /** When true, will not contain nodes that don't have content in the {@link Scene}. These are nodes whose {@link MetaObject}s don't have {@link Entity}s. */
+  pruneEmptyNodes?: boolean;
+};
+
+/**
+ * A {@link Viewer} plugin that provides an HTML tree view to navigate the IFC elements in models.
+ */
+export declare class TreeViewPlugin extends Plugin {
+  /**
+   * @constructor
+   *
+   * @param {Viewer} viewer The Viewer.
+   * @param {TreeViewPluginConfiguration} cfg Plugin configuration.
+   */
+  constructor(viewer: Viewer, cfg: TreeViewPluginConfiguration);
+
+  /**
+   * Sets how the nodes are organized within this tree view.
+   *
+   * Default value is "containment".
+   *
+   * @type {String}
+   */
+  set hierarchy(arg: "containment" | "storeys" | "types");
+
+  /**
+   * Gets how the nodes are organized within this tree view.
+   *
+   * @type {String}
+   */
+  get hierarchy(): "containment" | "storeys" | "types";
+
+  /**
+   * Returns the map of {@link ModelTreeView}s.
+   *
+   * Each ModelTreeView is mapped to the ID of its model.
+   *
+   * @return {*|{}}
+   */
+  get modelTreeViews(): any;
+
+  /**
+   * Adds a model to this tree view.
+   *
+   * The model will be automatically removed when destroyed.
+   *
+   * To automatically add each model as it's created, instead of manually calling this method each time,
+   * provide a ````autoAddModels: true```` to the TreeViewPlugin constructor.
+   *
+   * @param {String} modelId ID of a model {@link Entity} in {@link Scene#models}.
+   * @param {Object} [options] Options for model in the tree view.
+   * @param {String} [options.rootName] Optional display name for the root node. Ordinary, for "containment"
+   * and "storeys" hierarchy types, the tree would derive the root node name from the model's "IfcProject" element
+   * name. This option allows to override that name when it is not suitable as a display name.
+   * @returns {ModelTreeView} ModelTreeView for the newly-added model. If this method succeeded in adding the model,
+   * then {@link ModelTreeView#valid} will equal ````true````. Otherwise, that property will be ````false````
+   * and {@link ModelTreeView#errors} will contain error messages.
+   */
+  addModel(modelId: string, options?: {
+      rootName?: string;
+  }): ModelTreeView;
+
+  /**
+   * Removes a model from this tree view.
+   *
+   * Does nothing if model not currently in tree view.
+   *
+   * @param {String} modelId ID of a model {@link Entity} in {@link Scene#models}.
+   */
+  removeModel(modelId: string): void;
+
+  /**
+   * Collapses all trees within this tree view.
+   */
+  collapse(): void;
+
+  /**
+   * Highlights the tree view node that represents the given object {@link Entity}.
+   *
+   * This causes the tree view to collapse, then expand to reveal the node, then highlight the node.
+   *
+   * If a node is previously highlighted, de-highlights that node and collapses the tree first.
+   *
+   * Note that if the TreeViewPlugin was configured with ````pruneEmptyNodes: true```` (default configuration), then the
+   * node won't exist in the tree if it has no Entitys in the {@link Scene}. in that case, nothing will happen.
+   *
+   * Within the DOM, the node is represented by an ````<li>```` element. This method will add a ````.highlighted-node```` class to
+   * the element to make it appear highlighted, removing that class when de-highlighting it again. See the CSS rules
+   * in the TreeViewPlugin examples for an example of that class.
+   *
+   * @param {String} objectId ID of the {@link Entity}.
+   */
+  showNode(objectId: string): void;
+
+  /**
+   * De-highlights the node previously shown with {@link TreeViewPlugin#showNode}.
+   *
+   * Does nothing if no node is currently shown.
+   *
+   * If the node is currently scrolled into view, keeps the node in view.
+   */
+  unShowNode(): void;
+
+  /**
+   * Expands the tree to the given depth.
+   *
+   * Collapses the tree first.
+   *
+   * @param {Number} depth Depth to expand to.
+   */
+  expandToDepth(depth: number): void;
+
+  /**
+   * Iterates over a subtree of the tree view's {@link TreeViewNode}s, calling the given callback for each
+   * node in depth-first pre-order.
+   *
+   * @param {TreeViewNode} node Root of the subtree.
+   * @param {Function} callback Callback called at each {@link TreeViewNode}, with the TreeViewNode given as the argument.
+   */
+  withNodeTree(node: TreeViewNode, callback: (node: TreeViewNode) => void): void;
+}

package/types/plugins/TreeViewPlugin/index.d.ts

@@ -0,0 +1 @@
+export * from "./TreeViewPlugin";

package/types/plugins/ViewCullPlugin/ViewCullPlugin.d.ts

@@ -0,0 +1,34 @@
+import { Plugin, Viewer } from "../../viewer";
+
+export declare type ViewCullPluginConfiguration = {
+  /** Optional ID for this plugin, so that we can find it within {@link Viewer#plugins}. */
+  id?: string;
+  /** Maximum depth of the kd-tree. */
+  maxTreeDepth?: number;
+};
+
+/**
+ * {@link Viewer} plugin that performs view frustum culling to accelerate rendering performance.
+ */
+export class ViewCullPlugin extends Plugin {
+  /**
+   * @constructor
+   * @param {Viewer} viewer The Viewer.
+   * @param {ViewCullPluginConfiguration} cfg  Plugin configuration.
+   */
+  constructor(viewer: Viewer, cfg?: ViewCullPluginConfiguration);
+
+  /**
+   * Sets whether view culling is enabled.
+   *
+   * @param {Boolean} enabled Whether to enable view culling.
+   */
+  set enabled(arg: boolean);
+
+  /**
+   * Gets whether view culling is enabled.
+   *
+   * @retutns {Boolean} Whether view culling is enabled.
+   */
+  get enabled(): boolean;
+}

package/types/plugins/ViewCullPlugin/index.d.ts

@@ -0,0 +1 @@
+export * from "./ViewCullPlugin";

package/types/plugins/WebIFCLoaderPlugin/WebIFCLoaderPlugin.d.ts

@@ -0,0 +1,230 @@
+import { Plugin, Viewer, PerformanceModel, IFCObjectDefaults } from "../../viewer";
+import { ModelStats } from "../index";
+
+/**
+ * Default data access strategy for {@link WebIFCLoaderPlugin}.
+ */
+ export declare interface IWebIFCDefaultDataSource {
+  /**
+   * Gets the contents of the given IFC file in an arraybuffer.
+   *
+   * @param {String|Number} src Path or ID of an IFC file.
+   * @param {Function} ok Callback fired on success, argument is the IFC file in an arraybuffer.
+   * @param {Function} error Callback fired on error.
+   */
+  getIFC(src: string | number, ok: (buffer: ArrayBuffer)=> void, error: (e: Error)=> void): void;
+}
+
+export declare type WebIFCLoaderPluginConfiguration = {
+  id?: string;
+  wasmPath: string;
+  objectDefaults?: any;
+  dataSource?: IWebIFCDefaultDataSource;
+  includeTypes?: string[];
+  excludeTypes?: string[];
+  excludeUnclassifiedObjects?: boolean;
+};
+
+export declare type LoadWebIFCModel = {
+  /** ID to assign to the root {@link Entity#id}, unique among all components in the Viewer's {@link Scene}, generated automatically by default. */
+  id?: string;
+  /** Path to a IFC file, as an alternative to the ````ifc```` parameter. */
+  src?: string;
+  /** The IFC file data, as an alternative to the ````src```` parameter. */
+  ifc?: ArrayBuffer;
+  /** Whether to load IFC metadata (metaobjects and property sets). */
+  loadMetadata?: boolean;
+  /** Map of initial default states for each loaded {@link Entity} that represents an object. Default value is {@link IFCObjectDefaults}. */
+  objectDefaults?: IFCObjectDefaults;
+  /** When loading metadata, only loads objects that have {@link MetaObject}s with {@link MetaObject#type} values in this list. */
+  includeTypes?: string[];
+  /** When loading metadata, never loads objects that have {@link MetaObject}s with {@link MetaObject#type} values in this list. */
+  excludeTypes?: string[];
+  /** Whether or not xeokit renders the model with edges emphasized. */
+  edges?: boolean;
+  /** The model's World-space double-precision 3D origin. Use this to position the model within xeokit's World coordinate system, using double-precision coordinates. */
+  origin?: number[];
+  /** The model single-precision 3D position, relative to the ````origin```` parameter. */
+  position?: number[];
+  /** The model's scale. */
+  scale?: number[];
+  /** The model's orientation, given as Euler angles in degrees, for each of the X, Y and Z axis. */
+  rotation?: number[];
+  /** The model's world transform matrix. Overrides the position, scale and rotation parameters. Relative to ````origin````. */
+  matrix?: number[];
+  /**  Indicates if Scalable Ambient Obscurance (SAO) will apply to the model. SAO is configured by the Scene's {@link SAO} component. Only works when {@link SAO#enabled} is also ````true```` */
+  saoEnabled?: boolean;
+  /** Indicates if physically-based rendering (PBR) will apply to the model. Only works when {@link Scene#pbrEnabled} is also ````true````. */
+  pbrEnabled?: boolean;
+  /** When we set this ````true````, then we force rendering of backfaces for the model. When we leave this ````false````, then we allow the Viewer to decide when to render backfaces. In that case, the Viewer will hide backfaces on watertight meshes, show backfaces on open meshes, and always show backfaces on meshes when we slice them open with {@link SectionPlane}s. */
+  backfaces?: boolean;
+  /** When loading metadata and this is ````true````, will only load {@link Entity}s that have {@link MetaObject}s (that are not excluded). This is useful when we don't want Entitys in the Scene that are not represented within IFC navigation components, such as {@link TreeViewPlugin}. */
+  excludeUnclassifiedObjects?: boolean;
+  /** Indicates whether to globalize each {@link Entity#id} and {@link MetaObject#id}, in case you need to prevent ID clashes with other models. */
+  globalizeObjectIds?: boolean;
+  /** Collects model statistics. */
+  stats?: ModelStats;
+};
+
+/**
+ * {@link Viewer} plugin that uses [web-ifc](https://github.com/tomvandig/web-ifc) to load BIM models directly from IFC files.
+ */
+export declare class WebIFCLoaderPlugin extends Plugin {
+  /**
+   * @constructor
+   *
+   * @param {Viewer} viewer The Viewer.
+   * @param {WebIFCLoaderPluginConfiguration} cfg  Plugin configuration.
+   */
+  constructor(viewer: Viewer, cfg?: WebIFCLoaderPluginConfiguration);
+
+  /**
+   * Sets a custom data source through which the WebIFCLoaderPlugin can load IFC files.
+   *
+   * Default value is {@link WebIFCDefaultDataSource}, which loads via HTTP.
+   *
+   * @type {Object}
+   */
+  set dataSource(arg: IWebIFCDefaultDataSource);
+
+  /**
+   * Gets the custom data source through which the WebIFCLoaderPlugin can load IFC files.
+   *
+   * Default value is {@link WebIFCDefaultDataSource}, which loads via HTTP.
+   *
+   * @type {Object}
+   */
+  get dataSource(): IWebIFCDefaultDataSource;
+
+  /**
+   * Sets map of initial default states for each loaded {@link Entity} that represents an object.
+   *
+   * Default value is {@link IFCObjectDefaults}.
+   *
+   * @type {IFCObjectDefaults}
+   */
+  set objectDefaults(arg: IFCObjectDefaults);
+
+  /**
+   * Gets map of initial default states for each loaded {@link Entity} that represents an object.
+   *
+   * Default value is {@link IFCObjectDefaults}.
+   *
+   * @type {IFCObjectDefaults}
+   */
+  get objectDefaults(): IFCObjectDefaults;
+
+  /**
+   * Sets the whitelist of the IFC types loaded by this WebIFCLoaderPlugin.
+   *
+   * When loading IFC models, causes this WebIFCLoaderPlugin to only load objects whose types are in this
+   * list. An object's type is indicated by its {@link MetaObject}'s {@link MetaObject#type}.
+   *
+   * Default value is ````undefined````.
+   *
+   * @type {String[]}
+   */
+  set includeTypes(arg: string[]);
+
+  /**
+   * Gets the whitelist of the IFC types loaded by this WebIFCLoaderPlugin.
+   *
+   * When loading IFC models, causes this WebIFCLoaderPlugin to only load objects whose types are in this
+   * list. An object's type is indicated by its {@link MetaObject}'s {@link MetaObject#type}.
+   *
+   * Default value is ````undefined````.
+   *
+   * @type {String[]}
+   */
+  get includeTypes(): string[];
+
+  /**
+   * Sets the blacklist of IFC types that are never loaded by this WebIFCLoaderPlugin.
+   *
+   * When IFC models, causes this WebIFCLoaderPlugin to **not** load objects whose types are in this
+   * list. An object's type is indicated by its {@link MetaObject}'s {@link MetaObject#type}.
+   *
+   * Default value is ````undefined````.
+   *
+   * @type {String[]}
+   */
+  set excludeTypes(arg: string[]);
+
+  /**
+   * Gets the blacklist of IFC types that are never loaded by this WebIFCLoaderPlugin.
+   *
+   * When loading IFC models, causes this WebIFCLoaderPlugin to **not** load objects whose types are in this
+   * list. An object's type is indicated by its {@link MetaObject}'s {@link MetaObject#type}.
+   *
+   * Default value is ````undefined````.
+   *
+   * @type {String[]}
+   */
+  get excludeTypes(): string[];
+
+  /**
+   * Sets whether we load objects that don't have IFC types.
+   *
+   * When loading IFC models and this is ````true````, WebIFCLoaderPlugin will not load objects
+   * that don't have IFC types.
+   *
+   * Default value is ````false````.
+   *
+   * @type {Boolean}
+   */
+  set excludeUnclassifiedObjects(arg: boolean);
+
+  /**
+   * Gets whether we load objects that don't have IFC types.
+   *
+   * When loading IFC models and this is ````true````, WebIFCLoaderPlugin will not load objects
+   * that don't have IFC types.
+   *
+   * Default value is ````false````.
+   *
+   * @type {Boolean}
+   */
+  get excludeUnclassifiedObjects(): boolean;
+
+  /**
+   * Gets the ````IFC```` format versions supported by this WebIFCLoaderPlugin.
+   * @returns {string[]}
+   */
+  get supportedVersions(): string[];
+
+  /**
+   * Sets whether WebIFCLoaderPlugin globalizes each {@link Entity#id} and {@link MetaObject#id} as it loads a model.
+   *
+   * Set  this ````true```` when you need to load multiple instances of the same model, to avoid ID clashes
+   * between the objects in the different instances.
+   *
+   * When we load a model with this set ````true````, then each {@link Entity#id} and {@link MetaObject#id} will be
+   * prefixed by the ID of the model, ie. ````<modelId>#<objectId>````.
+   *
+   * {@link Entity#originalSystemId} and {@link MetaObject#originalSystemId} will always hold the original, un-prefixed, ID values.
+   *
+   * Default value is ````false````.
+   *
+   * See the main {@link WebIFCLoaderPlugin} class documentation for usage info.
+   *
+   * @type {Boolean}
+   */
+  set globalizeObjectIds(arg: boolean);
+
+  /**
+   * Gets whether WebIFCLoaderPlugin globalizes each {@link Entity#id} and {@link MetaObject#id} as it loads a model.
+   *
+   * Default value is ````false````.
+   *
+   * @type {Boolean}
+   */
+  get globalizeObjectIds(): boolean;
+
+  /**
+   * Loads an ````IFC```` model into this WebIFCLoaderPlugin's {@link Viewer}.
+   *
+   * @param {LoadWebIFCModel} params Loading parameters.
+   * @returns {PerformanceModel} Entity representing the model, which will have {@link Entity#isModel} set ````true```` and will be registered by {@link Entity#id} in {@link Scene#models}.
+   */
+  load(params?: LoadWebIFCModel): PerformanceModel;
+}

package/types/plugins/WebIFCLoaderPlugin/index.d.ts

@@ -0,0 +1 @@
+export * from "./WebIFCLoaderPlugin";

package/types/plugins/XKTLoaderPlugin/XKTLoaderPlugin.d.ts

@@ -0,0 +1,277 @@
+import { Plugin, Viewer, PerformanceModel, IFCObjectDefaults } from "../../viewer";
+
+export declare type XKTLoaderPluginConfiguration = {
+  /** Optional ID for this plugin, so that we can find it within {@link Viewer#plugins}. */
+  id?: string;
+  /** Map of initial default states for each loaded {@link Entity} that represents an object.  Default value is {@link IFCObjectDefaults}.*/
+  objectDefaults?: IFCObjectDefaults;
+  /** A custom data source through which the XKTLoaderPlugin can load model and metadata files. Defaults to an instance of {@link XKTDefaultDataSource}, which loads uover HTTP. */
+  dataSource?: IXKTDefaultDataSource;
+  /** When loading metadata, only loads objects that have {@link MetaObject}s with {@link MetaObject#type} values in this list. */
+  includeTypes?: string[];
+  /** When loading metadata, never loads objects that have {@link MetaObject}s with {@link MetaObject#type} values in this list. */
+  excludeTypes?: string[];
+  /** When loading metadata and this is ````true````, will only load {@link Entity}s that have {@link MetaObject}s (that are not excluded). This is useful when we don't want Entitys in the Scene that are not represented within IFC navigation components, such as {@link TreeViewPlugin}. */
+  excludeUnclassifiedObjects?: boolean;
+  /** Indicates whether to enable geometry reuse */
+  reuseGeometries?: boolean;
+  /** Maximum geometry batch size, as number of vertices. */
+  maxGeometryBatchSize?: number;
+};
+
+export declare type LoadXKTModel = {
+  /** ID to assign to the root {@link Entity#id}, unique among all components in the Viewer's {@link Scene}, generated automatically by default. */
+  id?: string;
+  /** Path to a *````.xkt````* file, as an alternative to the ````xkt```` parameter. */
+  src?: string;
+  /** The *````.xkt````* file data, as an alternative to the ````src```` parameter. */
+  xkt?: ArrayBuffer;
+  /** Path to an optional metadata file, as an alternative to the ````metaModelData```` parameter. */
+  metaModelSrc?: string;
+  /** JSON model metadata, as an alternative to the ````metaModelSrc```` parameter. */
+  metaModelData?: any;
+  /** Map of initial default states for each loaded {@link Entity} that represents an object. Default value is {@link IFCObjectDefaults}. */
+  objectDefaults?: object;
+  /** When loading metadata, only loads objects that have {@link MetaObject}s with {@link MetaObject#type} values in this list. */
+  includeTypes?: string[]
+  /** When loading metadata, never loads objects that have {@link MetaObject}s with {@link MetaObject#type} values in this list. */
+  excludeTypes?: string[];
+  /** Whether or not xeokit renders the model with edges emphasized. */
+  edges?: boolean;
+  /** The model's World-space double-precision 3D origin. Use this to position the model within xeokit's World coordinate system, using double-precision coordinates. */
+  origin?: number[];
+  /** The model single-precision 3D position, relative to the ````origin```` parameter. */
+  position?: number[];
+  /** The model's scale. */
+  scale?: number[];
+  /** The model's orientation, given as Euler angles in degrees, for each of the X, Y and Z axis. */
+  rotation?: number[];
+  /** The model's world transform matrix. Overrides the position, scale and rotation parameters. Relative to ````origin````.*/
+  matrix?: number[];
+  /** Indicates if Scalable Ambient Obscurance (SAO) will apply to the model. SAO is configured by the Scene's {@link SAO} component. Only works when {@link SAO#enabled} is also ````true```` */
+  saoEnabled?: boolean;
+  /** Indicates if physically-based rendering (PBR) will apply to the model. Only works when {@link Scene#pbrEnabled} is also ````true````. */
+  pbrEnabled?: boolean;
+  /** When we set this ````true````, then we force rendering of backfaces for the model. */
+  backfaces?: boolean;
+  /** When loading metadata and this is ````true````, will only load {@link Entity}s that have {@link MetaObject}s (that are not excluded). */
+  excludeUnclassifiedObjects?: boolean;
+  /** Indicates whether to globalize each {@link Entity#id} and {@link MetaObject#id}, in case you need to prevent ID clashes with other models. */
+  globalizeObjectIds?: boolean;
+  /** Indicates whether to enable geometry reuse */
+  reuseGeometries?: boolean;
+}
+
+export declare interface IXKTDefaultDataSource {
+  /**
+     * Gets metamodel JSON.
+     *
+     * @param {String|Number} metaModelSrc Identifies the metamodel JSON asset.
+     * @param {Function(*)} ok Fired on successful loading of the metamodel JSON asset.
+     * @param {Function(*)} error Fired on error while loading the metamodel JSON asset.
+     */
+  getMetaModel(metaModelSrc: string | number, ok: (json: any)=> void, error: (e: Error)=> void): void;
+
+  /**
+     * Gets the contents of the given ````.xkt```` file in an arraybuffer.
+     *
+     * @param {String|Number} src Path or ID of an ````.xkt```` file.
+     * @param {Function} ok Callback fired on success, argument is the ````.xkt```` file in an arraybuffer.
+     * @param {Function} error Callback fired on error.
+     */
+  getXKT(src: string | number, ok: (buffer: ArrayBuffer)=> void, error: (e: Error)=> void): void;
+}
+
+/**
+ * {@link Viewer} plugin that loads models from xeokit's optimized *````.XKT````* format.
+ *
+ */
+ export declare class XKTLoaderPlugin extends Plugin {
+  /**
+   * @constructor
+   *
+   * @param {Viewer} viewer The Viewer.
+   * @param {XKTLoaderPluginConfiguration} cfg  Plugin configuration.
+   */
+  constructor(viewer: Viewer, cfg?: XKTLoaderPluginConfiguration);
+
+  /**
+   * Sets a custom data source through which the XKTLoaderPlugin can load models and metadata.
+   *
+   * Default value is {@link XKTDefaultDataSource}, which loads via HTTP.
+   *
+   * @type {IXKTDefaultDataSource}
+   */
+  set dataSource(arg: IXKTDefaultDataSource);
+
+  /**
+   * Gets the custom data source through which the XKTLoaderPlugin can load models and metadata.
+   *
+   * Default value is {@link XKTDefaultDataSource}, which loads via HTTP.
+   *
+   * @type {IXKTDefaultDataSource}
+   */
+  get dataSource(): IXKTDefaultDataSource;
+
+  /**
+   * Sets map of initial default states for each loaded {@link Entity} that represents an object.
+   *
+   * @type {IFCObjectDefaults}
+   */
+  set objectDefaults(arg: IFCObjectDefaults);
+
+  /**
+   * Gets map of initial default states for each loaded {@link Entity} that represents an object.
+   *
+   * @type {IFCObjectDefaults}
+   */
+  get objectDefaults(): IFCObjectDefaults;
+
+  /**
+   * Sets the whitelist of the IFC types loaded by this XKTLoaderPlugin.
+   *
+   * When loading models with metadata, causes this XKTLoaderPlugin to only load objects whose types are in this
+   * list. An object's type is indicated by its {@link MetaObject}'s {@link MetaObject#type}.
+   *
+   * Default value is ````undefined````.
+   *
+   * @type {String[]}
+   */
+  set includeTypes(arg: string[]);
+
+  /**
+   * Gets the whitelist of the IFC types loaded by this XKTLoaderPlugin.
+   *
+   * When loading models with metadata, causes this XKTLoaderPlugin to only load objects whose types are in this
+   * list. An object's type is indicated by its {@link MetaObject}'s {@link MetaObject#type}.
+   *
+   * Default value is ````undefined````.
+   *
+   * @type {String[]}
+   */
+
+  get includeTypes(): string[];
+
+  /**
+   * Sets the blacklist of IFC types that are never loaded by this XKTLoaderPlugin.
+   *
+   * When loading models with metadata, causes this XKTLoaderPlugin to **not** load objects whose types are in this
+   * list. An object's type is indicated by its {@link MetaObject}'s {@link MetaObject#type}.
+   *
+   * Default value is ````undefined````.
+   *
+   * @type {String[]}
+   */
+  set excludeTypes(arg: string[]);
+
+  /**
+   * Gets the blacklist of IFC types that are never loaded by this XKTLoaderPlugin.
+   *
+   * When loading models with metadata, causes this XKTLoaderPlugin to **not** load objects whose types are in this
+   * list. An object's type is indicated by its {@link MetaObject}'s {@link MetaObject#type}.
+   *
+   * Default value is ````undefined````.
+   *
+   * @type {String[]}
+   */
+  get excludeTypes(): string[];
+
+  /**
+   * Sets whether we load objects that don't have IFC types.
+   *
+   * When loading models with metadata and this is ````true````, XKTLoaderPlugin will not load objects
+   * that don't have IFC types.
+   *
+   * Default value is ````false````.
+   *
+   * @type {Boolean}
+   */
+  set excludeUnclassifiedObjects(arg: boolean);
+
+  /**
+   * Gets whether we load objects that don't have IFC types.
+   *
+   * When loading models with metadata and this is ````true````, XKTLoaderPlugin will not load objects
+   * that don't have IFC types.
+   *
+   * Default value is ````false````.
+   *
+   * @type {Boolean}
+   */
+  get excludeUnclassifiedObjects(): boolean;
+
+  /**
+   * Sets whether XKTLoaderPlugin enables geometry reuse when loading models.
+   *
+   * Default value is ````true````.
+   *
+   * Geometry reuse saves memory, but can impact Viewer performance when there are many reused geometries. For
+   * this reason, we can set this ````false```` to disable geometry reuse for models loaded by this XKTLoaderPlugin
+   * (which will then "expand" the geometry instances into batches instead).
+   *
+   * The result will be be less WebGL draw calls (which are expensive), at the cost of increased memory footprint.
+   *
+   * See [#769](https://github.com/xeokit/xeokit-sdk/issues/769) for more info.
+   *
+   * @type {Boolean}
+   */
+  set reuseGeometries(arg: boolean);
+
+  /**
+   * Gets whether XKTLoaderPlugin enables geometry reuse when loading models.
+   *
+   * Default value is ````true````.
+   *
+   * @type {Boolean}
+   */
+  get reuseGeometries(): boolean;
+
+  /**
+   * Gets the ````.xkt```` format versions supported by this XKTLoaderPlugin/
+   * @returns {string[]}
+   */
+  get supportedVersions(): string[];
+
+  /**
+   * Sets whether XKTLoaderPlugin globalizes each {@link Entity#id} and {@link MetaObject#id} as it loads a model.
+   *
+   * Set  this ````true```` when you need to load multiple instances of the same model, to avoid ID clashes
+   * between the objects in the different instances.
+   *
+   * When we load a model with this set ````true````, then each {@link Entity#id} and {@link MetaObject#id} will be
+   * prefixed by the ID of the model, ie. ````<modelId>#<objectId>````.
+   *
+   * {@link Entity#originalSystemId} and {@link MetaObject#originalSystemId} will always hold the original, un-prefixed, ID values.
+   *
+   * Default value is ````false````.
+   *
+   * See the main {@link XKTLoaderPlugin} class documentation for usage info.
+   *
+   * @type {Boolean}
+   */
+  set globalizeObjectIds(arg: boolean);
+
+  /**
+   * Gets whether XKTLoaderPlugin globalizes each {@link Entity#id} and {@link MetaObject#id} as it loads a model.
+   *
+   * Default value is ````false````.
+   *
+   * @type {Boolean}
+   */
+  get globalizeObjectIds(): boolean;
+
+
+  /**
+   * Loads an ````.xkt```` model into this XKTLoaderPlugin's {@link Viewer}.
+   *
+   * Since xeokit/xeokit-sdk 1.9.0, XKTLoaderPlugin has supported XKT 8, which bundles the metamodel
+   * data (eg. an IFC element hierarchy) in the XKT file itself. For XKT 8, we therefore no longer need to
+   * load the metamodel data from a separate accompanying JSON file, as we did with previous XKT versions.
+   * However, if we do choose to specify a separate metamodel JSON file to load (eg. for backward compatibility
+   * in data pipelines), then that metamodel will be loaded and the metamodel in the XKT 8 file will be ignored.
+   *
+   * @param {LoadXKTModel} params Loading parameters.
+   * @returns {PerformanceModel} Entity representing the model, which will have {@link Entity#isModel} set ````true```` and will be registered by {@link Entity#id} in {@link Scene#models}.
+   */
+  load(params: LoadXKTModel): PerformanceModel;
+}

package/types/plugins/XKTLoaderPlugin/index.d.ts

@@ -0,0 +1 @@
+export * from "./XKTLoaderPlugin";