@combeenation/3d-viewer 7.1.3 → 8.1.0-alpha1

package/dist/lib-cjs/api/util/globalTypes.d.ts

@@ -1,455 +1,469 @@
-/// <reference types="gsap" />
-declare type Viewer = import('../classes/viewer').Viewer;
-declare type Variant = import('../classes/variant').Variant;
-declare type VariantInstance = import('../classes/variantInstance').VariantInstance;
-declare type VariantParameterizable = import('../classes/variantParameterizable').VariantParameterizable;
-/**
- * Alias for {@link Element} which can be used to prevent name clashes with the web APIs
- * [Element](https://developer.mozilla.org/en-US/docs/Web/API/Element) class
- */
-declare type VariantElement = import('../classes/element').Element;
-declare type DottedPath = import('../classes/dottedPath').DottedPath;
-declare type ViewerLight = import('../classes/viewerLight').ViewerLight;
-declare type SceneManager = import('../manager/sceneManager').SceneManager;
-declare type FuzzyMap<K, V> = import('../classes/fuzzyMap').FuzzyMap<K, V>;
-declare type Scene = import('@babylonjs/core/scene').Scene;
-declare type Vector3 = import('@babylonjs/core/Maths/math.vector').Vector3;
-declare type Color3 = import('@babylonjs/core/Maths/math.color').Color3;
-declare type Color4 = import('@babylonjs/core/Maths/math.color').Color4;
-declare type Material = import('@babylonjs/core/Materials/material').Material;
-declare type PBRMaterial = import('@babylonjs/core/Materials/PBR/pbrMaterial').PBRMaterial;
-declare type StandardMaterial = import('@babylonjs/core/Materials/standardMaterial').StandardMaterial;
-declare type DynamicTexture = import('@babylonjs/core/Materials/Textures/dynamicTexture').DynamicTexture;
-declare type Mesh = import('@babylonjs/core/Meshes/mesh').Mesh;
-declare type AbstractMesh = import('@babylonjs/core/Meshes/abstractMesh').AbstractMesh;
-declare type InstancedMesh = import('@babylonjs/core/Meshes/instancedMesh').InstancedMesh;
-declare type TransformNode = import('@babylonjs/core/Meshes/transformNode').TransformNode;
-declare type Engine = import('@babylonjs/core/Engines/engine').Engine;
-/**
- * See Babylon JS docs for more information about available [EngineOptions](https://doc.babylonjs.com/typedoc/interfaces/babylon.engineoptions).
- */
-declare type EngineOptions = import('@babylonjs/core/Engines/thinEngine').EngineOptions;
-declare type ArcRotateCamera = import('@babylonjs/core/Cameras/arcRotateCamera').ArcRotateCamera;
-declare type IScreenshotSize = import('@babylonjs/core/Misc/interfaces/screenshotSize').IScreenshotSize;
-declare type BabylonAnimation = import('@babylonjs/core/Animations/animation').Animation;
-declare type CubeTexture = import('@babylonjs/core/Materials/Textures/cubeTexture').CubeTexture;
-declare type MeshBuilder = typeof import('@babylonjs/core/Meshes/meshBuilder').MeshBuilder;
-declare type Texture = import('@babylonjs/core/Materials/Textures/texture').Texture;
-declare type HemisphericLight = import('@babylonjs/core/Lights/hemisphericLight').HemisphericLight;
-declare type DirectionalLight = import('@babylonjs/core/Lights/directionalLight').DirectionalLight;
-declare type IInspectorOptions = import('@babylonjs/core/Debug').IInspectorOptions;
-declare type IExportOptions = import('@babylonjs/serializers/glTF/2.0').IExportOptions;
-declare type EventEmitter = import('eventemitter3');
-declare type Undefinable<T> = T | undefined;
-declare type Nullable<T> = T | null;
-declare type PathDefinitions = {
-    include: string[];
-    exclude?: string[];
-};
-declare type TraceableDefinition = {
-    path: string;
-};
-declare type TraceableDefinitions = {
-    [name: string]: TraceableDefinition;
-};
-declare type PaintableDefinition = {
-    path: string;
-    textureOptions: {
-        width: number;
-        height: number;
-    } | number;
-};
-declare type PaintableDefinitions = {
-    [name: string]: PaintableDefinition;
-};
-declare type Asset = {
-    rootUrl: string;
-    fileName: string | undefined;
-};
-declare type ElementDefinitions = {
-    [name: string]: ElementDefinition | string[];
-};
-declare type ElementDefinition = {
-    paths: PathDefinitions;
-    traceables?: TraceableDefinitions;
-    paintables?: PaintableDefinitions;
-};
-declare type TransformationDefinition = {
-    scaling: Vector3;
-    position: Vector3;
-    rotation: Vector3;
-};
-declare type EnvironmentDefinition = {
-    environmentColor?: Color3;
-    environmentIntensity?: number;
-    environment?: string;
-    environmentBackground?: string;
-    environmentRotation?: number;
-    environmentUseDefault?: boolean;
-};
-declare type StructureJson = {
-    /**
-     * `scene` describes the visualisation of the babylon `scene` such as the incidence of light and camera position. If a
-     * string is given, the {@link Viewer} will resolve the URL or path and pass the parsed JSON to this property.
-     */
-    scene?: string | SceneJson;
-    /**
-     * `setup` is a kind of construction plan for the {@link Viewer}. You can pass a {@link SetupJson} or a string, which
-     * must represent a valid URL or path. If a string is given, the {@link Viewer} will resolve the URL or path and pass
-     * the parsed JSON to this property. The {@link SetupJson} is responsible for managing a list of
-     * {@link VariantInstanceDefinition}s. These definitions define the instances that should be instantiated during the
-     * bootstrapping process. Each instance has a name and a reference to it's {@link Variant}.
-     */
-    setup?: string | SetupJson;
-    file?: string;
-    glTF?: Asset | string;
-    parameterDeclaration?: ParameterDeclarations;
-    parameters?: ParameterBag;
-    elements?: ElementDefinitions;
-    lights?: LightDefinitions;
-    grounds?: GroundDefinitions;
-    /**
-     * `variants` is a declarative description of 3D-model variations in the configurator. Each variant itself is a
-     * {@link StructureJson} which must at least define a `name` in the key of the list and the properties `glTF` and
-     * `elements` in the value. FYI: Babylon.js's sandbox can show you the path of the 3D-model to properly define the
-     * `paths`.
-     *
-     * Example Code
-     * ```js
-     * variants: {
-     *     'My Pretty Variant' {
-     *         glTF: {
-     *             rootUrl: 'https:/my.awesome.domain/path/to/my/project/',
-     *             fileName: 'my_3d_model_file.glb',
-     *         },
-     *         elements: {
-     *             'My Little Element': {
-     *                 paths: {
-     *                     includes: ['__root__.MeshName']
-     *                 }
-     *             }
-     *         }
-     *     }
-     * }
-     * ```
-     * `MeshName` has to be identical to the path in the glb-file of the 3D-model.
-     */
-    variants?: {
-        [id: string]: StructureJson;
-    };
-};
-/**
- * Extends the `StructureJson` by removing the optional flag from some properties which surely exist in the auto
- * generated spec
- */
-declare type AutoSpecStructureJson = StructureJson & {
-    scene: AutoSpecSceneJson;
-    setup: SetupJson;
-    variants: {
-        [id: string]: StructureJson;
-    };
-};
-declare type SceneJson = {
-    parameterDeclaration?: ParameterDeclarations;
-    parameters?: ParameterBag;
-    meshPicking?: boolean;
-    engine?: {
-        antialiasing?: boolean;
-        options?: EngineOptions;
-    };
-    scene: SceneDefinition;
-    animations?: AnimationDefinitions;
-    placements?: PlacementDefinitions;
-    /**
-     * Information about [material cloning](pages/Release%20Notes/releases/4-3-0.html#material-cloning-on-mutation).
-     * Default value is `false`.
-     */
-    cloneMaterialsOnMutation?: boolean;
-};
-/**
- * Extends the `SceneJson` by removing the optional flag from some properties which surely exist in the auto generated
- * spec
- */
-declare type AutoSpecSceneJson = SceneJson & {
-    engine: {
-        antialiasing: boolean;
-        options: EngineOptions;
-    };
-};
-declare type SceneDefinition = {
-    globals: SceneGlobals;
-    cameras?: CameraDefinitions;
-};
-declare type SceneGlobals = {
-    'shadows'?: {
-        enabled: boolean;
-        type: 'contact';
-        settings: [];
-        generator: [];
-        receiver: [];
-    };
-    /**
-     * `aa` or anti aliasing is not needed if hard edges are desired.\
-     * FYI: aa smooths edges and avoids stairs-effects.
-     */
-    'aa'?: 'fxaa';
-    'tone-mapping'?: boolean;
-    /**
-     * @bloom is widely known as glow. There you can define it’s size (Specifies the size of the bloom blur kernel,
-     * relative to the final output size) and threshold (The luminance threshold to find bright areas of the image to
-     * bloom).
-     * Further Information under [BloomEffect](https://doc.babylonjs.com/typedoc/classes/babylon.bloomeffect).
-     *
-     * @dof short for "depth-of-field" defines the focus in the view. Parameters in settings are listed in [Depth of Field and Other Lens Effects link](https://doc.babylonjs.com/divingDeeper/postProcesses/dofLenseEffects).
-     * @exposure specifies the intensity of the lightning of the view (not 3D-Model).
-     * @sharpen´s parameter `settings` are listed in [Default Rendering Pipeline Sharpening link](https://doc.babylonjs.com/divingDeeper/postProcesses/defaultRenderingPipeline#sharpening).
-     */
-    'camera-settings'?: {
-        contrast: number;
-        exposure: number;
-        bloom?: {
-            enabled: boolean;
-            size?: number;
-            threshold?: number;
-        };
-        dof?: {
-            enabled: boolean;
-            settings: {};
-        };
-        sharpen?: {
-            enabled: boolean;
-            settings: {};
-        };
-    };
-};
-/**
- * {@link Viewer.screenshot} internally uses Babylon.js [ScreenshotTools.CreateScreenshotUsingRenderTarget](https://doc.babylonjs.com/typedoc/classes/babylon.screenshottools#createscreenshotusingrendertarget). \
- * See this link for additional info about the properties.
- */
-declare type ScreenshotSettings = {
-    /** Defaults to canvas width & height */
-    size?: IScreenshotSize;
-    /**
-     * Default `image/png`
-     *
-     * **Info regarding JPEG:** \
-     * Use mimeType `image/jpeg` (**not** `image/jpg`) when creating jpeg's. \
-     * Also ensure that {@link Scene.clearColor | viewer.scene.clearColor} has an alpha value of `1` as jpeg's don't
-     * support transparency. Otherwise background will always be black for jpeg's.
-     */
-    mimeType?: string;
-    /** Default `1` */
-    samples?: number;
-    /** Default `false` */
-    antialiasing?: boolean;
-    /** Default `screenshot.png` */
-    fileName?: string;
-    /** Default `false` */
-    renderSprites?: boolean;
-};
-/**
- * Use this to define geometry to be excluded from autofocus, GLB export, etc.
- */
-declare type ExcludedGeometry = Mesh | AbstractMesh | VariantInstance | Variant | VariantElement | Node | TagManagerSubject;
-declare type ExcludedGeometryList = ExcludedGeometry[];
-declare type AutofocusSettings = {
-    /**
-     * Can be used to customize the margins shown around the 3d model when calling {@link Viewer.autofocusActiveCamera}.\
-     * Defaults to 1.5 when not set explicitly.
-     */
-    radiusFactor?: number;
-    adjustWheelPrecision?: boolean;
-    adjustPanningSensibility?: boolean;
-    adjustPinchPrecision?: boolean;
-    /** Desired horizontal camera angle, this won't be overwritten by the autofocus function */
-    alpha?: number;
-    /** Desired vertical camera angle, this won't be overwritten by the autofocus function */
-    beta?: number;
-    /** Optional animation for the focusing camera movement */
-    animation?: string | AnimationDefinition;
-    /** Optional list of geometry to be excluded from consideration */
-    exclude?: ExcludedGeometryList;
-};
-declare type LightDefinitions = {
-    [name: string]: LightDefinition | string;
-};
-declare type LightDefinition = {
-    type: 'baked' | 'hemispheric' | 'point' | 'directional' | 'spot';
-    path?: string;
-    shadowGenerator?: ShadowGeneratorDefinition;
-};
-declare type ShadowGeneratorDefinition = {
-    mapSize: number;
-    [others: string]: any;
-};
-declare type GroundDefinitions = {
-    [ground: string]: GroundDefinition;
-};
-declare type GroundDefinition = {
-    type: 'baked' | 'ground' | 'heightmap';
-    meshId?: string;
-    url?: string;
-    width?: number;
-    height?: number;
-    subdivisions?: number;
-    receiveShadows?: boolean;
-    minHeight?: number;
-    maxHeight?: number;
-    alphaFilter?: number;
-    onReady?: any;
-};
-declare type CameraDefinitions = {
-    [camera: string]: CameraDefinition;
-};
-declare type CameraDefinition = {
-    /**
-     * `fov` or "Field Of View" defines as it says the view of the scene. Further information about its [theory](https://en.wikipedia.org/wiki/Field_of_view) and [implementation](https://doc.babylonjs.com/typedoc/classes/babylon.camera#fov).
-     */
-    fov?: number;
-    active?: boolean;
-    /**
-     * `arc` is a default camera position where the 3D-model is the center and the camera rotates around the 3D-model.
-     * More Information about `arc` in [ArcRotateCamera](https://doc.babylonjs.com/typedoc/classes/babylon.arcrotatecamera).
-     *
-     * NOTE: While "baked" camera definitions from a GLB or babylon file can currently not be instatiated within the
-     * `Specification`, it's still possible to use them in the viewer.\
-     * For the moment all camera definitions inside these files are automatically added to the scene and can be actived
-     * using the {@link Viewer.switchCamera} function.\
-     * The `newCamera` input has to match the name of the camera node inside the GLB/babylon file.
-     */
-    type: 'arc';
-    /**
-     * `target` overrides `arc`´s position and repositions the camera. The string has the syntax (x?: number, y?: number, z?: number) like [Vector3](https://doc.babylonjs.com/typedoc/classes/babylon.vector3).
-     */
-    target?: string;
-};
-declare type VariantInstanceDefinition = {
-    name?: string;
-    variant: DottedPathArgument;
-    parameters?: ParameterBag;
-    tagManagerParameterValues?: TagManagerParameterValue[];
-    lazy?: boolean;
-};
-declare type SetupJson = {
-    instances: VariantInstanceDefinition[];
-};
-declare type ParameterDeclarations = {
-    [name: string]: ParameterDeclaration;
-};
-declare type ParameterDeclaration = {
-    type: 'string' | 'boolean' | 'number' | 'color' | 'select' | 'vector' | 'csl';
-    parser?: any;
-    options?: ParameterValue[];
-};
-declare type ParameterValue = string | number | boolean;
-declare type ParameterBag = {
-    [name: string]: ParameterValue;
-};
-declare type ParsedParameterBag = {
-    [name: string]: any;
-};
-declare type DottedPathArgument = string | string[] | DottedPath;
-declare type ParameterObserverResult = boolean | void;
-declare type ParameterObserver = (payload: any, oldValue: Undefinable<ParameterValue>, newValue: ParameterValue) => Promise<ParameterObserverResult>;
-declare type PlacementDefinitions = {
-    [name: string]: PlacementDefinition;
-};
-declare type PlacementDefinition = {
-    position?: string | Vector3;
-    alpha?: number;
-    beta?: number;
-    radius?: number;
-    target?: string | Vector3;
-};
-declare type AnimationDefinitions = {
-    [name: string]: AnimationDefinition;
-};
-/**
- * See [GSAP API Docs](https://greensock.com/docs/v3/GSAP/Tween/vars) for description of `GSAPTWeenVars`.
- *
- * You can use the [GreenSock Ease Visualizer](https://greensock.com/ease-visualizer/) to create an animation of your
- * liking and simply copy the `ease` function shown at the bottom of the visualizer into the `ease` property of your
- * {@link AnimationDefinition}.
- *
- * The `GSAPTWeenVars` are extended by the `shortestWay` property.\
- * This property defines if the camera should move to the target position within the shortest possible distance.\
- * If `shortestWay` is `false`, the camera moves the whole difference between the current camera position and the target
- * position and that could be > 360, which can appear very unconvenient to the operator.\
- * The default value of this flag is `true`.
- *
- * Example usage in {@link SceneJson | SceneJson.animations}:
- *
- * ```js
- * // ...
- * scene: {
- *   // ...
- *   animations: {
- *     DefaultCameraAnimation: {
- *       ease: 'Power3.easeInOut',
- *       duration: 0.8,
- *     },
- *   },
- *   // ...
- * }
- * // ...
- * ```
- */
-declare type AnimationDefinition = GSAPTweenVars & {
-    shortestWay?: boolean;
-};
-/**
- * Extends Babylon.js's {@link IExportOptions} by some viewer specific settings
- */
-interface IExportOptionsExtended extends IExportOptions {
-    /**
-     * In certain situations multiple meshes in the viewer scene have the same name (e.g. when cloning instances).\
-     * If this option is set, the exporter adjusts all mesh names before export to have a unique name.\
-     * This is required e.g. if the exported file is used to show an AR scene with the model viewer which requires all
-     * meshes to have unique names.
-     */
-    createUniqueMeshNames?: boolean;
-}
-declare type SpecGenerationData = {
-    name: string;
-    url: string;
-};
-/**
- * Key = Old tag name\
- * Value = New tag name
- */
-declare type TagMapping = {
-    [tagName: string]: string;
-};
-declare type TagManagerSubject = {
-    tagName?: string;
-    nodeName?: string;
-};
-/**
- * The observer should return `false` in cases where the given value was not actually applied. E.g. when wanting to
- * apply a property on the given `node`s material which doesn't exist at the time the observer is called etc.
- */
-declare type TagManagerParameterObserver = (payload: TagManagerParameterObserverPayload) => Promise<ParameterObserverResult>;
-declare type TagManagerParameterBag = FuzzyMap<TagManagerSubject, ParameterBag>;
-declare type TagManagerParameterObserverBag = Map<string, TagManagerParameterObserver>;
-declare type TagManagerParameterObserverPayload = {
-    subject: TagManagerSubject;
-    nodes: TransformNode[];
-    newValue: ParameterValue;
-    oldValue: Undefinable<ParameterValue>;
-};
-declare type TagManagerParameterValue = {
-    tagName?: string;
-    nodeName?: string;
-    parameterName: string;
-    value: ParameterValue;
-};
-declare type NodeNamingStrategyPayload = {
-    variantInstance: VariantInstance;
-    variant: Variant;
-    variantParameterizable: VariantParameterizable;
-};
-declare type NodeNamingStrategyHandler = (node: TransformNode, payload: NodeNamingStrategyPayload) => string;
-declare type NodeNamingStrategy = {
-    handler: NodeNamingStrategyHandler;
-    payload: NodeNamingStrategyPayload;
-};
+/// <reference types="gsap" />
+declare type Viewer = import('../classes/viewer').Viewer;
+declare type Variant = import('../classes/variant').Variant;
+declare type VariantInstance = import('../classes/variantInstance').VariantInstance;
+declare type VariantParameterizable = import('../classes/variantParameterizable').VariantParameterizable;
+/**
+ * Alias for {@link Element} which can be used to prevent name clashes with the web APIs
+ * [Element](https://developer.mozilla.org/en-US/docs/Web/API/Element) class
+ */
+declare type VariantElement = import('../classes/element').Element;
+declare type DottedPath = import('../classes/dottedPath').DottedPath;
+declare type ViewerLight = import('../classes/viewerLight').ViewerLight;
+declare type SceneManager = import('../manager/sceneManager').SceneManager;
+declare type FuzzyMap<K, V> = import('../classes/fuzzyMap').FuzzyMap<K, V>;
+declare type Scene = import('@babylonjs/core/scene').Scene;
+declare type Vector3 = import('@babylonjs/core/Maths/math.vector').Vector3;
+declare type Color3 = import('@babylonjs/core/Maths/math.color').Color3;
+declare type Color4 = import('@babylonjs/core/Maths/math.color').Color4;
+declare type Material = import('@babylonjs/core/Materials/material').Material;
+declare type PBRMaterial = import('@babylonjs/core/Materials/PBR/pbrMaterial').PBRMaterial;
+declare type StandardMaterial = import('@babylonjs/core/Materials/standardMaterial').StandardMaterial;
+declare type DynamicTexture = import('@babylonjs/core/Materials/Textures/dynamicTexture').DynamicTexture;
+declare type Mesh = import('@babylonjs/core/Meshes/mesh').Mesh;
+declare type AbstractMesh = import('@babylonjs/core/Meshes/abstractMesh').AbstractMesh;
+declare type InstancedMesh = import('@babylonjs/core/Meshes/instancedMesh').InstancedMesh;
+declare type TransformNode = import('@babylonjs/core/Meshes/transformNode').TransformNode;
+declare type Engine = import('@babylonjs/core/Engines/engine').Engine;
+/**
+ * See Babylon JS docs for more information about available [EngineOptions](https://doc.babylonjs.com/typedoc/interfaces/babylon.engineoptions).
+ */
+declare type EngineOptions = import('@babylonjs/core/Engines/thinEngine').EngineOptions;
+declare type ArcRotateCamera = import('@babylonjs/core/Cameras/arcRotateCamera').ArcRotateCamera;
+declare type IScreenshotSize = import('@babylonjs/core/Misc/interfaces/screenshotSize').IScreenshotSize;
+declare type BabylonAnimation = import('@babylonjs/core/Animations/animation').Animation;
+declare type CubeTexture = import('@babylonjs/core/Materials/Textures/cubeTexture').CubeTexture;
+declare type MeshBuilder = typeof import('@babylonjs/core/Meshes/meshBuilder').MeshBuilder;
+declare type Texture = import('@babylonjs/core/Materials/Textures/texture').Texture;
+declare type HemisphericLight = import('@babylonjs/core/Lights/hemisphericLight').HemisphericLight;
+declare type DirectionalLight = import('@babylonjs/core/Lights/directionalLight').DirectionalLight;
+declare type IInspectorOptions = import('@babylonjs/core/Debug').IInspectorOptions;
+declare type IExportOptions = import('@babylonjs/serializers/glTF/2.0').IExportOptions;
+declare type EventEmitter = import('eventemitter3');
+declare type Undefinable<T> = T | undefined;
+declare type Nullable<T> = T | null;
+declare type PathDefinitions = {
+    include: string[];
+    exclude?: string[];
+};
+declare type TraceableDefinition = {
+    path: string;
+};
+declare type TraceableDefinitions = {
+    [name: string]: TraceableDefinition;
+};
+declare type PaintableDefinition = {
+    path: string;
+    textureOptions: {
+        width: number;
+        height: number;
+    } | number;
+};
+declare type PaintableDefinitions = {
+    [name: string]: PaintableDefinition;
+};
+declare type Asset = {
+    rootUrl: string;
+    fileName: string | undefined;
+};
+declare type ElementDefinitions = {
+    [name: string]: ElementDefinition | string[];
+};
+declare type ElementDefinition = {
+    paths: PathDefinitions;
+    traceables?: TraceableDefinitions;
+    paintables?: PaintableDefinitions;
+};
+declare type TransformationDefinition = {
+    scaling: Vector3;
+    position: Vector3;
+    rotation: Vector3;
+};
+declare type EnvironmentDefinition = {
+    environmentColor?: Color3;
+    environmentIntensity?: number;
+    environment?: string;
+    environmentBackground?: string;
+    environmentRotation?: number;
+    environmentUseDefault?: boolean;
+};
+declare type StructureJson = {
+    /**
+     * `scene` describes the visualisation of the babylon `scene` such as the incidence of light and camera position. If a
+     * string is given, the {@link Viewer} will resolve the URL or path and pass the parsed JSON to this property.
+     */
+    scene?: string | SceneJson;
+    /**
+     * `setup` is a kind of construction plan for the {@link Viewer}. You can pass a {@link SetupJson} or a string, which
+     * must represent a valid URL or path. If a string is given, the {@link Viewer} will resolve the URL or path and pass
+     * the parsed JSON to this property. The {@link SetupJson} is responsible for managing a list of
+     * {@link VariantInstanceDefinition}s. These definitions define the instances that should be instantiated during the
+     * bootstrapping process. Each instance has a name and a reference to it's {@link Variant}.
+     */
+    setup?: string | SetupJson;
+    file?: string;
+    glTF?: Asset | string;
+    parameterDeclaration?: ParameterDeclarations;
+    parameters?: ParameterBag;
+    elements?: ElementDefinitions;
+    lights?: LightDefinitions;
+    grounds?: GroundDefinitions;
+    /**
+     * `variants` is a declarative description of 3D-model variations in the configurator. Each variant itself is a
+     * {@link StructureJson} which must at least define a `name` in the key of the list and the properties `glTF` and
+     * `elements` in the value. FYI: Babylon.js's sandbox can show you the path of the 3D-model to properly define the
+     * `paths`.
+     *
+     * Example Code
+     * ```js
+     * variants: {
+     *     'My Pretty Variant' {
+     *         glTF: {
+     *             rootUrl: 'https:/my.awesome.domain/path/to/my/project/',
+     *             fileName: 'my_3d_model_file.glb',
+     *         },
+     *         elements: {
+     *             'My Little Element': {
+     *                 paths: {
+     *                     includes: ['__root__.MeshName']
+     *                 }
+     *             }
+     *         }
+     *     }
+     * }
+     * ```
+     * `MeshName` has to be identical to the path in the glb-file of the 3D-model.
+     */
+    variants?: {
+        [id: string]: StructureJson;
+    };
+};
+/**
+ * Extends the `StructureJson` by removing the optional flag from some properties which surely exist in the auto
+ * generated spec
+ */
+declare type AutoSpecStructureJson = StructureJson & {
+    scene: AutoSpecSceneJson;
+    setup: SetupJson;
+    variants: {
+        [id: string]: StructureJson;
+    };
+};
+declare type SceneJson = {
+    parameterDeclaration?: ParameterDeclarations;
+    parameters?: ParameterBag;
+    meshPicking?: boolean;
+    engine?: {
+        antialiasing?: boolean;
+        options?: EngineOptions;
+    };
+    scene: SceneDefinition;
+    animations?: AnimationDefinitions;
+    placements?: PlacementDefinitions;
+    /**
+     * Information about [material cloning](pages/Release%20Notes/releases/4-3-0.html#material-cloning-on-mutation).
+     * Default value is `false`.
+     */
+    cloneMaterialsOnMutation?: boolean;
+};
+/**
+ * Extends the `SceneJson` by removing the optional flag from some properties which surely exist in the auto generated
+ * spec
+ */
+declare type AutoSpecSceneJson = SceneJson & {
+    engine: {
+        antialiasing: boolean;
+        options: EngineOptions;
+    };
+};
+declare type SceneDefinition = {
+    globals: SceneGlobals;
+    cameras?: CameraDefinitions;
+};
+declare type SceneGlobals = {
+    'shadows'?: {
+        enabled: boolean;
+        type: 'contact';
+        settings: [];
+        generator: [];
+        receiver: [];
+    };
+    /**
+     * `aa` or anti aliasing is not needed if hard edges are desired.\
+     * FYI: aa smooths edges and avoids stairs-effects.
+     */
+    'aa'?: 'fxaa';
+    'tone-mapping'?: boolean;
+    /**
+     * @bloom is widely known as glow. There you can define it’s size (Specifies the size of the bloom blur kernel,
+     * relative to the final output size) and threshold (The luminance threshold to find bright areas of the image to
+     * bloom).
+     * Further Information under [BloomEffect](https://doc.babylonjs.com/typedoc/classes/babylon.bloomeffect).
+     *
+     * @dof short for "depth-of-field" defines the focus in the view. Parameters in settings are listed in [Depth of Field and Other Lens Effects link](https://doc.babylonjs.com/divingDeeper/postProcesses/dofLenseEffects).
+     * @exposure specifies the intensity of the lightning of the view (not 3D-Model).
+     * @sharpen´s parameter `settings` are listed in [Default Rendering Pipeline Sharpening link](https://doc.babylonjs.com/divingDeeper/postProcesses/defaultRenderingPipeline#sharpening).
+     */
+    'camera-settings'?: {
+        contrast: number;
+        exposure: number;
+        bloom?: {
+            enabled: boolean;
+            size?: number;
+            threshold?: number;
+        };
+        dof?: {
+            enabled: boolean;
+            settings: {};
+        };
+        sharpen?: {
+            enabled: boolean;
+            settings: {};
+        };
+    };
+};
+/**
+ * {@link Viewer.screenshot} internally uses Babylon.js [ScreenshotTools.CreateScreenshotUsingRenderTarget](https://doc.babylonjs.com/typedoc/classes/babylon.screenshottools#createscreenshotusingrendertarget). \
+ * See this link for additional info about the properties.
+ */
+declare type ScreenshotSettings = {
+    /** Defaults to canvas width & height */
+    size?: IScreenshotSize;
+    /**
+     * Default `image/png`
+     *
+     * **Info regarding JPEG:** \
+     * Use mimeType `image/jpeg` (**not** `image/jpg`) when creating jpeg's. \
+     * Also ensure that {@link Scene.clearColor | viewer.scene.clearColor} has an alpha value of `1` as jpeg's don't
+     * support transparency. Otherwise background will always be black for jpeg's.
+     */
+    mimeType?: string;
+    /** Default `1` */
+    samples?: number;
+    /** Default `false` */
+    antialiasing?: boolean;
+    /** Default `screenshot.png` */
+    fileName?: string;
+    /** Default `false` */
+    renderSprites?: boolean;
+};
+/**
+ * Use this to define geometry to be excluded from autofocus, GLB export, etc.
+ */
+declare type ExcludedGeometry = TransformNode | VariantInstance | Variant | VariantElement | TagManagerSubject;
+declare type ExcludedGeometryList = ExcludedGeometry[];
+declare type AutofocusSettings = {
+    /**
+     * Can be used to customize the margins shown around the 3d model when calling {@link Viewer.autofocusActiveCamera}.\
+     * Defaults to 1.5 when not set explicitly.
+     */
+    radiusFactor?: number;
+    adjustWheelPrecision?: boolean;
+    adjustPanningSensibility?: boolean;
+    adjustPinchPrecision?: boolean;
+    /** Desired horizontal camera angle, this won't be overwritten by the autofocus function */
+    alpha?: number;
+    /** Desired vertical camera angle, this won't be overwritten by the autofocus function */
+    beta?: number;
+    /** Optional animation for the focusing camera movement */
+    animation?: string | AnimationDefinition;
+    /** Optional list of geometry to be excluded from consideration */
+    exclude?: ExcludedGeometryList;
+};
+declare type LightDefinitions = {
+    [name: string]: LightDefinition | string;
+};
+declare type LightDefinition = {
+    type: 'baked' | 'hemispheric' | 'point' | 'directional' | 'spot';
+    path?: string;
+    shadowGenerator?: ShadowGeneratorDefinition;
+};
+declare type ShadowGeneratorDefinition = {
+    mapSize: number;
+    [others: string]: any;
+};
+declare type GroundDefinitions = {
+    [ground: string]: GroundDefinition;
+};
+declare type GroundDefinition = {
+    type: 'baked' | 'ground' | 'heightmap';
+    meshId?: string;
+    url?: string;
+    width?: number;
+    height?: number;
+    subdivisions?: number;
+    receiveShadows?: boolean;
+    minHeight?: number;
+    maxHeight?: number;
+    alphaFilter?: number;
+    onReady?: any;
+};
+declare type CameraDefinitions = {
+    [camera: string]: CameraDefinition;
+};
+declare type CameraDefinition = {
+    /**
+     * `fov` or "Field Of View" defines as it says the view of the scene. Further information about its [theory](https://en.wikipedia.org/wiki/Field_of_view) and [implementation](https://doc.babylonjs.com/typedoc/classes/babylon.camera#fov).
+     */
+    fov?: number;
+    active?: boolean;
+    /**
+     * `arc` is a default camera position where the 3D-model is the center and the camera rotates around the 3D-model.
+     * More Information about `arc` in [ArcRotateCamera](https://doc.babylonjs.com/typedoc/classes/babylon.arcrotatecamera).
+     *
+     * NOTE: While "baked" camera definitions from a GLB or babylon file can currently not be instatiated within the
+     * `Specification`, it's still possible to use them in the viewer.\
+     * For the moment all camera definitions inside these files are automatically added to the scene and can be actived
+     * using the {@link Viewer.switchCamera} function.\
+     * The `newCamera` input has to match the name of the camera node inside the GLB/babylon file.
+     */
+    type: 'arc';
+    /**
+     * `target` overrides `arc`´s position and repositions the camera. The string has the syntax (x?: number, y?: number, z?: number) like [Vector3](https://doc.babylonjs.com/typedoc/classes/babylon.vector3).
+     */
+    target?: string;
+};
+declare type VariantInstanceDefinition = {
+    name?: string;
+    variant: DottedPathArgument;
+    parameters?: ParameterBag;
+    lazy?: boolean;
+};
+declare type SetupJson = {
+    instances: VariantInstanceDefinition[];
+};
+declare type ParameterDeclarations = {
+    [name: string]: ParameterDeclaration;
+};
+declare type ParameterDeclaration = {
+    type: 'string' | 'boolean' | 'number' | 'color' | 'select' | 'vector' | 'csl';
+    parser?: any;
+    options?: ParameterValue[];
+};
+declare type ParameterValue = string | number | boolean;
+declare type ParameterBag = {
+    [name: string]: ParameterValue;
+};
+declare type ParsedParameterBag = {
+    [name: string]: any;
+};
+declare type DottedPathArgument = string | string[] | DottedPath;
+declare type ParameterObserverResult = boolean | void;
+declare type ParameterObserver = (object: any, oldValue: Undefinable<ParameterValue>, newValue: ParameterValue) => Promise<ParameterObserverResult>;
+declare type PlacementDefinitions = {
+    [name: string]: PlacementDefinition;
+};
+declare type PlacementDefinition = {
+    position?: string | Vector3;
+    alpha?: number;
+    beta?: number;
+    radius?: number;
+    target?: string | Vector3;
+};
+declare type AnimationDefinitions = {
+    [name: string]: AnimationDefinition;
+};
+/**
+ * See [GSAP API Docs](https://greensock.com/docs/v3/GSAP/Tween/vars) for description of `GSAPTWeenVars`.
+ *
+ * You can use the [GreenSock Ease Visualizer](https://greensock.com/ease-visualizer/) to create an animation of your
+ * liking and simply copy the `ease` function shown at the bottom of the visualizer into the `ease` property of your
+ * {@link AnimationDefinition}.
+ *
+ * The `GSAPTWeenVars` are extended by the `shortestWay` property.\
+ * This property defines if the camera should move to the target position within the shortest possible distance.\
+ * If `shortestWay` is `false`, the camera moves the whole difference between the current camera position and the target
+ * position and that could be > 360, which can appear very unconvenient to the operator.\
+ * The default value of this flag is `true`.
+ *
+ * Example usage in {@link SceneJson | SceneJson.animations}:
+ *
+ * ```js
+ * // ...
+ * scene: {
+ *   // ...
+ *   animations: {
+ *     DefaultCameraAnimation: {
+ *       ease: 'Power3.easeInOut',
+ *       duration: 0.8,
+ *     },
+ *   },
+ *   // ...
+ * }
+ * // ...
+ * ```
+ */
+declare type AnimationDefinition = GSAPTweenVars & {
+    shortestWay?: boolean;
+};
+/**
+ * Extends Babylon.js's {@link IExportOptions} by some viewer specific settings
+ */
+interface IExportOptionsExtended extends IExportOptions {
+    /**
+     * Refraction textures get lost when exporting the scene to GLB.\
+     * The short explanation is that refraction is calculated by "RenderTargetTexture", which is created in real time from
+     * the camera perspective. This data is not available in the GLB export, therefore the texture gets removed.\
+     * However if `exchangeRefractionMaterials` is set, a fallback material with a similar look is exported instead. This
+     * fallback material solves the refraction with a combination of certain color, roughness, metallic and transparency
+     * mode settings.
+     */
+    exchangeRefractionMaterials?: boolean;
+}
+declare type SpecGenerationData = {
+    name: string;
+    url: string;
+};
+/**
+ * Key = Old tag name\
+ * Value = New tag name
+ */
+declare type TagMapping = {
+    [tagName: string]: string;
+};
+declare type TagManagerSubject = {
+    tagName?: string;
+    nodeName?: string;
+    materialName?: string;
+};
+declare type TagManagerParameterObserverResult = ParameterObserverResult;
+/**
+ * The observer should return `false` in cases where the given value was not actually applied. E.g. when wanting to
+ * apply a property on the given `node`s material which doesn't exist at the time the observer is called etc.
+ */
+declare type TagManagerParameterObserver = (payload: TagManagerParameterObserverPayload) => Promise<TagManagerParameterObserverResult>;
+declare type TagManagerParameterBag = FuzzyMap<TagManagerSubject, ParameterBag>;
+declare type TagManagerParameterObserverBag = Map<string, TagManagerParameterObserver>;
+declare type TagManagerParameterObserverPayload = {
+    subject: TagManagerSubject;
+    nodes: TransformNode[];
+    materials: Material[];
+    newValue: ParameterValue;
+    oldValue: Undefinable<ParameterValue>;
+};
+declare type TagManagerParameterValue = {
+    tagName?: string;
+    nodeName?: string;
+    materialName?: string;
+    parameterName: string;
+    value: ParameterValue;
+};
+declare type TagManagerParameterObserverResultBag = {
+    subject: TagManagerSubject;
+    parameter: string;
+    nodes: TransformNode[];
+    materials: Material[];
+    oldValue: ParameterValue;
+    newValue: ParameterValue;
+    parameterObserverResult: TagManagerParameterObserverResult;
+};
+declare type NodeNamingStrategyPayload = {
+    variantInstance: VariantInstance;
+    variant: Variant;
+    variantParameterizable: VariantParameterizable;
+};
+declare type NodeNamingStrategyHandler = (node: TransformNode, payload: NodeNamingStrategyPayload) => string;
+declare type NodeNamingStrategy = {
+    handler: NodeNamingStrategyHandler;
+    payload: NodeNamingStrategyPayload;
+};