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

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";

package/types/plugins/XML3DLoaderPlugin/XML3DLoaderPlugin.d.ts

@@ -0,0 +1,65 @@
+import { Plugin, Viewer, PerformanceModel } from "../../viewer";
+
+export declare type XML3DLoaderPluginConfiguration = {
+  /** Optional ID for this plugin, so that we can find it within {@link Viewer.plugins}. */
+  id?: string;
+  /** Path to the directory that contains the bundled [zip.js](https://gildas-lormeau.github.io/zip.js/) archive */
+  workerScriptsPath: string;
+  /** What type of materials to create while loading */
+  materialType?: "MetallicMaterial" | "SpecularMaterial" | "PhongMaterial";
+  /** When true, will create a {@link MetaModel} for the model in {@link MetaScene.metaModels}. */
+  createMetaModel?: boolean;
+}
+
+export declare type LoadXML3DModel = {
+  /** ID to assign to the model's root {@link Entity}, unique among all components in the Viewer's {@link Scene}. */
+  id: string;
+  /** Path to a 3DXML file. */
+  src: string;
+  /** Whether or not xeokit renders the {@link Entity} with edges emphasized. */
+  edges?: boolean;
+  /** The model's World-space 3D position. */
+  position?: number[];
+  /** The model's World-space scale. */
+  scale?: number[];
+  /** The model's World-space rotation, as Euler angles given 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. */
+  matrix?: number[];
+  /** When true, allows visible backfaces, wherever specified in the 3DXML. When false, ignores backfaces. */
+  backfaces?: boolean;
+  /** When xraying, highlighting, selecting or edging, this is the threshold angle between normals of adjacent triangles, below which their shared wireframe edge is not drawn. */
+  edgeThreshold?: number;
+  /** What type of materials to create while loading: "MetallicMaterial" to create {@link MetallicMaterial}s, "SpecularMaterial" to create {@link SpecularMaterial}s or "PhongMaterial" to create {@link PhongMaterial}s. As it loads XML3D's Phong materials, the XMLLoaderPlugin will do its best approximate conversion of those to the specified workflow. */
+  materialType?: "MetallicMaterial" | "SpecularMaterial" | "PhongMaterial";
+  /** When true, will create a {@link MetaModel} for the model in {@link MetaScene.metaModels}. */
+  createMetaModel?: boolean;
+};
+
+/**
+ * {@link Viewer} plugin that loads models from [3DXML](https://en.wikipedia.org/wiki/3DXML) files.
+ */
+export declare class XML3DLoaderPlugin extends Plugin {
+  /**
+   * @constructor
+   * @param {Viewer} viewer The Viewer.
+   * @param {XML3DLoaderPluginConfiguration} cfg  Plugin configuration.
+   */
+  constructor(viewer: Viewer, cfg?:XML3DLoaderPluginConfiguration );
+
+  /**
+   * Supported 3DXML schema versions
+   * @type {string[]}
+   */
+  supportedSchemas: string[];
+
+  /**
+   * Loads a 3DXML model from a file into this XML3DLoaderPlugin's {@link Viewer}.
+   *
+   * Creates a tree of {@link Entity}s within the Viewer's {@link Scene} that represents the model.
+   *
+   * @param {LoadXML3DModel} params  Loading parameters.
+   * @returns {Entity} 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: LoadXML3DModel): PerformanceModel;
+}

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

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

package/types/plugins/index.d.ts

@@ -0,0 +1,34 @@
+export * from "./AngleMeasurementsPlugin";
+export * from "./AnnotationsPlugin";
+export * from "./AxisGizmoPlugin";
+export * from "./BCFViewpointsPlugin";
+export * from "./CityJSONLoaderPlugin";
+export * from "./DistanceMeasurementsPlugin";
+export * from "./FastNavPlugin";
+export * from "./GLTFLoaderPlugin";
+export * from "./LASLoaderPlugin";
+export * from "./NavCubePlugin";
+export * from "./OBJLoaderPlugin";
+export * from "./SectionPlanesPlugin";
+export * from "./SkyboxesPlugin";
+export * from "./STLLoaderPlugin";
+export * from "./StoreyViewsPlugin";
+export * from "./TreeViewPlugin";
+export * from "./ViewCullPlugin";
+export * from "./XKTLoaderPlugin";
+export * from "./WebIFCLoaderPlugin";
+export * from "./XML3DLoaderPlugin";
+
+export declare type ModelStats = {
+  sourceFormat: string;
+  schemaVersion: string;
+  title: string;
+  author: string;
+  created: string;
+  numMetaObjects: number;
+  numPropertySets: number;
+  numObjects: number;
+  numGeometries: number;
+  numTriangles: number;
+  numVertices: number;
+};

package/types/viewer/Configs.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Manages global configurations for all {@link Viewer}s.
+ */
+export declare abstract class Configs {
+  /**
+   * Sets whether double precision mode is enabled for Viewers.
+   *
+   * When double precision mode is enabled (default), Viewers will accurately render models that contain
+   * double-precision coordinates, without jittering.
+   *
+   */
+  set doublePrecisionEnabled(doublePrecision: boolean);
+
+  /**
+   * Gets whether double precision mode is enabled for all Viewers.
+   *
+   * @returns {boolean}
+   */
+  get doublePrecisionEnabled(): boolean;
+}

package/types/viewer/Plugin.d.ts

@@ -0,0 +1,69 @@
+import { Viewer } from "./Viewer";
+
+/**
+ @desc Base class for {@link Viewer} plugin classes.
+ */
+export declare abstract class Plugin {
+    /**
+     * Creates this Plugin and installs it into the given {@link Viewer}.
+     *
+     * @param {string} id ID for this plugin, unique among all plugins in the viewer.
+     * @param {Viewer} viewer The viewer.
+     * @param {Object} [cfg] Options
+     */
+    constructor(id: string, viewer: Viewer, cfg?: {});
+
+    /**
+     * ID for this Plugin, unique within its {@link Viewer}.
+     *
+     * @type {string}
+     */
+    id: string;
+
+    /**
+     * The Viewer that contains this Plugin.
+     *
+     * @type {Viewer}
+     */
+    viewer: Viewer;
+
+    /**
+     * Subscribes to an event fired at this Plugin.
+     * @param {String} event The event
+     * @param {Function} callback Callback fired on the event
+     */
+    on(event: string, callback: ()=> void): void;
+
+    /**
+     * Fires an event at this Plugin.
+     * @param {String} event The event type name
+     * @param {Object} value The event parameters
+     */
+    fire(event: string, value: any): void;
+
+    /**
+     * Logs a message to the JavaScript developer console, prefixed with the ID of this Plugin.
+     *
+     * @param {String} msg The error message
+     */
+    log(msg: string): void;
+
+    /**
+     * Logs a warning message to the JavaScript developer console, prefixed with the ID of this Plugin.
+     *
+     * @param {String} msg The error message
+     */
+    warn(msg: string): void;
+
+    /**
+     * Logs an error message to the JavaScript developer console, prefixed with the ID of this Plugin.
+     *
+     * @param {String} msg The error message
+     */
+    error(msg: string): void;
+
+    /**
+     * Destroys this Plugin and removes it from its {@link Viewer}.
+     */
+    destroy(): void;
+}

package/types/viewer/Viewer.d.ts

@@ -0,0 +1,212 @@
+import { LocaleService } from "./localization/LocaleService";
+import { Scene } from "./scene/scene/Scene";
+import { MetaScene } from "./metadata/MetaScene";
+import { Camera } from "./scene/camera/Camera";
+import { CameraFlightAnimation } from "./scene/camera/CameraFlightAnimation";
+import { CameraControl } from "./scene/CameraControl/CameraControl";
+import { Plugin } from "./Plugin";
+
+export declare type ViewerConfiguration = {
+  /** Optional ID for this Viewer, defaults to the ID of {@link Viewer.scene}, which xeokit automatically generates. */
+  id?: string;
+  /** ID of an existing HTML canvas for the {@link Viewer.scene} - either this or canvasElement is mandatory. When both values are given, the element reference is always preferred to the ID. */
+  canvasId?: string;
+  /** Reference of an existing HTML canvas for the {@link Viewer.scene} - either this or canvasId is mandatory. When both values are given, the element reference is always preferred to the ID. */
+  canvasElement?: HTMLCanvasElement;
+  /** Optional reference to HTML element on which key events should be handled. Defaults to the HTML Document. */
+  keyboardEventsElement?: HTMLElement;
+  /** ID of existing HTML element to show the {@link Spinner} - internally creates a default element automatically if this is omitted. */
+  spinnerElementId?: string;
+  /** The number of times the {@link Viewer.scene} renders per frame. */
+  passes?: number;
+  /** When doing multiple passes per frame, specifies if to clear the canvas before each pass (true) or just before the first pass (false). */
+  clearEachPass?: boolean;
+  /** Whether or not to preserve the WebGL drawing buffer. This needs to be ````true```` for {@link Viewer.getSnapshot} to work.*/
+  preserveDrawingBuffer?: boolean;
+  /** Whether or not the canvas is transparent. */
+  transparent?: boolean;
+  /** Whether or not you want alpha composition with premultiplied alpha. Highlighting and selection works best when this is ````false````. */
+  premultipliedAlpha?: boolean;
+  /** When true, expects that all textures and colors are premultiplied gamma. */
+  gammaInput?: boolean;
+  /** Whether or not to render with pre-multiplied gama. */
+  gammaOutput?: boolean;
+  /** The gamma factor to use when rendering with pre-multiplied gamma. */
+  gammaFactor?: number;
+  /** Sets the canvas background color to use when ````transparent```` is false. */
+  backgroundColor?: number[];
+  /**When ````transparent```` is false, set this ````true```` to derive the canvas background color from {@link AmbientLight.color}, or ````false```` to set the canvas background to ````backgroundColor````. */
+  backgroundColorFromAmbientLight?: boolean;
+  /** The measurement unit type. */
+  units?: "meters" | "centimeters" | "millimeters" | "yards" | "feet" | "inches" ;
+  /** The number of Real-space units in each World-space coordinate system unit. */
+  scale?: number;
+  /** The Real-space 3D origin, in current measurement units, at which the World-space coordinate origin ````[0,0,0]```` sits. */
+  origin?: number[];
+  /** Whether to enable Scalable Ambient Obscurance (SAO) effect. See {@link SAO} for more info. */
+  saoEnabled?: boolean;
+  /** Whether to enable anti-aliasing. */
+  antialias?: boolean;
+  /** Whether writing into the depth buffer is enabled or disabled when rendering transparent objects. */
+  alphaDepthMask?: boolean;
+  /** Whether to enable {@link Entity.offset}. For best performance, only set this ````true```` when you need to use {@link Entity.offset}. */
+  entityOffsetsEnabled?: boolean;
+  /** Whether to enable full-precision accuracy when surface picking with {@link Scene.pick}. */
+  pickSurfacePrecisionEnabled?: boolean;
+  /** Whether to enable logarithmic depth buffer. */
+  logarithmicDepthBufferEnabled?: boolean;
+  /** Whether to enable physically-based rendering. */
+  pbrEnabled?: boolean;
+  /** Optional locale-based translation service. */
+  localeService?: LocaleService;
+};
+
+/**
+ * The 3D Viewer at the heart of the xeokit SDK.
+ */
+export declare class Viewer {
+  /**
+   * @constructor
+   * @param {ViewerConfiguration} cfg Viewer configuration.
+   */
+  constructor(cfg: ViewerConfiguration);
+
+  /**
+   * The viewer's locale service.
+   *
+   * This is configured via the Viewer's constructor.
+   *
+   * By default, this service will be an instance of {@link LocaleService}, which will just return
+   * null translations for all given strings and phrases.
+   *
+   * @property localeService
+   * @type {LocaleService}
+   * @since 2.0
+   */
+  localeService: LocaleService;
+
+  /**
+   * The Viewer's {@link Scene}.
+   * @property scene
+   * @type {Scene}
+   */
+  scene: Scene;
+
+  /**
+   * Metadata about the {@link Scene} and the models and objects within it.
+   * @property metaScene
+   * @type {MetaScene}
+   * @readonly
+   */
+  readonly metaScene: MetaScene;
+
+  /**
+   * The Viewer's ID.
+   * @property id
+   *
+   * @type {String|Number}
+   */
+  id: string | number;
+
+  /**
+   * The Viewer's {@link Camera}. This is also found on {@link Scene.camera}.
+   * @property camera
+   * @type {Camera}
+   */
+  camera: Camera;
+
+  /**
+   * The Viewer's {@link CameraFlightAnimation}, which
+   * is used to fly the {@link Scene}'s {@link Camera} to given targets.
+   * @property cameraFlight
+   * @type {CameraFlightAnimation}
+   */
+  cameraFlight: CameraFlightAnimation;
+
+  /**
+   * The Viewer's {@link CameraControl}, which
+   * controls the {@link Scene}'s {@link Camera} with mouse,  touch and keyboard input.
+   * @property cameraControl
+   * @type {CameraControl}
+   */
+  cameraControl: CameraControl;
+
+  /**
+   * Subscribes to an event fired at this Viewer.
+   *
+   * @param {String} event The event
+   * @param {Function} callback Callback fired on the event
+   */
+  on(event: string, callback: Function): void;
+
+  /**
+   * Fires an event at this Viewer.
+   *
+   * @param {String} event Event name
+   * @param {Object} value Event parameters
+   */
+  fire(event: string, value: any): void;
+
+  /**
+   * Logs a message to the JavaScript developer console, prefixed with the ID of this Viewer.
+   *
+   * @param {String} msg The message
+   */
+  log(msg: string): void;
+
+  /**
+   * Logs an error message to the JavaScript developer console, prefixed with the ID of this Viewer.
+   *
+   * @param {String} msg The error message
+   */
+  error(msg: string): void;
+
+  /**
+   * Installs a Plugin.
+   *
+   * @private
+   */
+  addPlugin(plugin: Plugin): void;
+
+  /**
+   * Enter snapshot mode.
+   *
+   * Switches rendering to a hidden snapshot canvas.
+   *
+   * Exit snapshot mode using {@link Viewer.endSnapshot}.
+   */
+  beginSnapshot(): void;
+
+  /**
+   * Gets a snapshot of this Viewer's {@link Scene} as a Base64-encoded image.
+   *
+   * #### Usage:
+   *
+   * ````javascript
+   * const imageData = viewer.getSnapshot({
+   *    width: 500,
+   *    height: 500,
+   *    format: "png"
+   * });
+   * ````
+   * @param {*} [params] Capture options.
+   * @param {Number} [params.width] Desired width of result in pixels - defaults to width of canvas.
+   * @param {Number} [params.height] Desired height of result in pixels - defaults to height of canvas.
+   * @param {String} [params.format="jpeg"] Desired format; "jpeg", "png" or "bmp".
+   * @param {Boolean} [params.includeGizmos=false] When true, will include gizmos like {@link SectionPlane} in the snapshot.
+   * @returns {String} String-encoded image data URI.
+   */
+  getSnapshot(params: { width?: number, height?: number, format?: "jpeg" | "png"| "bmp", includeGizmos?: boolean }): string;
+
+  /**
+   * Exits snapshot mode.
+   *
+   * Switches rendering back to the main canvas.
+   *
+   */
+  endSnapshot(): void;
+
+  /** Destroys this Viewer.
+   */
+  destroy(): void;
+}