@combeenation/3d-viewer 5.0.1 → 5.0.3-beta2

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

@@ -1,356 +1,366 @@
-/// <reference types="gsap" />
-declare type Viewer = import('../classes/viewer').Viewer;
-declare type Variant = import('../classes/variant').Variant;
-declare type VariantInstance = import('../classes/variantInstance').VariantInstance;
-/**
- * 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 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;
-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 EventEmitter = import('eventemitter3');
-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 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: BabylonJS'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;
-    };
-};
-declare type SceneJson = {
-    parameterDeclaration?: ParameterDeclarations;
-    parameters?: ParameterBag;
-    meshPicking?: boolean;
-    /**
-     * Information about [EngineOptions](https://doc.babylonjs.com/typedoc/interfaces/babylon.engineoptions).
-     */
-    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)
-     */
-    cloneMaterialsOnMutation?: boolean;
-};
-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 Babylons [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 | VariantInstance | Variant | VariantElement)[];
-declare type AutofocusSettings = {
-    /**
-     * Can be used to customize the margins shown around the 3d model when calling {@link 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?: ExcludedGeometry;
-};
-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 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 ParameterObserver = (object: any, oldValue: ParameterValue, newValue: ParameterValue) => void;
-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;
-};
+/// <reference types="gsap" />
+declare type Viewer = import('../classes/viewer').Viewer;
+declare type Variant = import('../classes/variant').Variant;
+declare type VariantInstance = import('../classes/variantInstance').VariantInstance;
+/**
+ * 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 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;
+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 EventEmitter = import('eventemitter3');
+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: BabylonJS'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;
+    };
+};
+declare type SceneJson = {
+    parameterDeclaration?: ParameterDeclarations;
+    parameters?: ParameterBag;
+    meshPicking?: boolean;
+    /**
+     * Information about [EngineOptions](https://doc.babylonjs.com/typedoc/interfaces/babylon.engineoptions).
+     */
+    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)
+     */
+    cloneMaterialsOnMutation?: boolean;
+};
+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 Babylons [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;
+declare type ExcludedGeometryList = ExcludedGeometry[];
+declare type AutofocusSettings = {
+    /**
+     * Can be used to customize the margins shown around the 3d model when calling {@link 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 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 ParameterObserver = (object: any, oldValue: ParameterValue, newValue: ParameterValue) => void;
+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;
+};