@combeenation/3d-viewer 0.0.1-types

package/dist/types/node_modules/@babylonjs/serializers/glTF/2.0/glTFMaterialExporter.d.ts

@@ -0,0 +1,231 @@
+/**
+ * Utility methods for working with glTF material conversion properties.  This class should only be used internally
+ * @internal
+ */
+export class _GLTFMaterialExporter {
+    /**
+     * Specifies if two colors are approximately equal in value
+     * @param color1 first color to compare to
+     * @param color2 second color to compare to
+     * @param epsilon threshold value
+     */
+    static _FuzzyEquals(color1: any, color2: any, epsilon: any): boolean;
+    /**
+     * Computes the metallic factor
+     * @param diffuse diffused value
+     * @param specular specular value
+     * @param oneMinusSpecularStrength one minus the specular strength
+     * @returns metallic value
+     */
+    static _SolveMetallic(diffuse: any, specular: any, oneMinusSpecularStrength: any): number;
+    /**
+     * Sets the glTF alpha mode to a glTF material from the Babylon Material
+     * @param glTFMaterial glTF material
+     * @param babylonMaterial Babylon material
+     */
+    static _SetAlphaMode(glTFMaterial: any, babylonMaterial: any): void;
+    constructor(exporter: any);
+    /**
+     * Mapping to store textures
+     */
+    _textureMap: {};
+    _exporter: any;
+    /**
+     * Gets the materials from a Babylon scene and converts them to glTF materials
+     * @param exportMaterials
+     * @param mimeType texture mime type
+     * @param hasTextureCoords specifies if texture coordinates are present on the material
+     */
+    _convertMaterialsToGLTFAsync(exportMaterials: any, mimeType: any, hasTextureCoords: any): Promise<void>;
+    /**
+     * Makes a copy of the glTF material without the texture parameters
+     * @param originalMaterial original glTF material
+     * @returns glTF material without texture parameters
+     */
+    _stripTexturesFromMaterial(originalMaterial: any): {
+        name: any;
+        doubleSided: any;
+        alphaMode: any;
+        alphaCutoff: any;
+        emissiveFactor: any;
+        pbrMetallicRoughness: {
+            baseColorFactor: any;
+            metallicFactor: any;
+            roughnessFactor: any;
+        };
+    };
+    /**
+     * Specifies if the material has any texture parameters present
+     * @param material glTF Material
+     * @returns boolean specifying if texture parameters are present
+     */
+    _hasTexturesPresent(material: any): any;
+    _getTextureInfo(babylonTexture: any): any;
+    /**
+     * Converts a Babylon StandardMaterial to a glTF Metallic Roughness Material
+     * @param babylonStandardMaterial
+     * @returns glTF Metallic Roughness Material representation
+     */
+    _convertToGLTFPBRMetallicRoughness(babylonStandardMaterial: any): {
+        baseColorFactor: any[];
+        metallicFactor: number;
+        roughnessFactor: number;
+    };
+    /**
+     * Converts a Babylon Standard Material to a glTF Material
+     * @param babylonStandardMaterial BJS Standard Material
+     * @param mimeType mime type to use for the textures
+     * @param hasTextureCoords specifies if texture coordinates are present on the submesh to determine if textures should be applied
+     */
+    _convertStandardMaterialAsync(babylonStandardMaterial: any, mimeType: any, hasTextureCoords: any): Promise<any>;
+    _finishMaterial(promises: any, glTFMaterial: any, babylonMaterial: any, mimeType: any): Promise<any>;
+    /**
+     * Converts an image typed array buffer to a base64 image
+     * @param buffer typed array buffer
+     * @param width width of the image
+     * @param height height of the image
+     * @param mimeType mimetype of the image
+     * @returns base64 image string
+     */
+    _createBase64FromCanvasAsync(buffer: any, width: any, height: any, mimeType: any): Promise<any>;
+    /**
+     * Generates a white texture based on the specified width and height
+     * @param width width of the texture in pixels
+     * @param height height of the texture in pixels
+     * @param scene babylonjs scene
+     * @returns white texture
+     */
+    _createWhiteTexture(width: any, height: any, scene: any): RawTexture;
+    /**
+     * Resizes the two source textures to the same dimensions.  If a texture is null, a default white texture is generated.  If both textures are null, returns null
+     * @param texture1 first texture to resize
+     * @param texture2 second texture to resize
+     * @param scene babylonjs scene
+     * @returns resized textures or null
+     */
+    _resizeTexturesToSameDimensions(texture1: any, texture2: any, scene: any): {
+        texture1: any;
+        texture2: any;
+    };
+    /**
+     * Converts an array of pixels to a Float32Array
+     * Throws an error if the pixel format is not supported
+     * @param pixels - array buffer containing pixel values
+     * @returns Float32 of pixels
+     */
+    _convertPixelArrayToFloat32(pixels: any): Float32Array;
+    /**
+     * Convert Specular Glossiness Textures to Metallic Roughness
+     * See link below for info on the material conversions from PBR Metallic/Roughness and Specular/Glossiness
+     * @link https://github.com/KhronosGroup/glTF/blob/master/extensions/2.0/Khronos/KHR_materials_pbrSpecularGlossiness/examples/convert-between-workflows-.js/babylon.pbrUtilities.js
+     * @param diffuseTexture texture used to store diffuse information
+     * @param specularGlossinessTexture texture used to store specular and glossiness information
+     * @param factors specular glossiness material factors
+     * @param mimeType the mime type to use for the texture
+     * @returns pbr metallic roughness interface or null
+     */
+    _convertSpecularGlossinessTexturesToMetallicRoughnessAsync(diffuseTexture: any, specularGlossinessTexture: any, factors: any, mimeType: any): Promise<{
+        baseColor: Color3;
+        metallic: number;
+        roughness: number;
+    }>;
+    /**
+     * Converts specular glossiness material properties to metallic roughness
+     * @param specularGlossiness interface with specular glossiness material properties
+     * @returns interface with metallic roughness material properties
+     */
+    _convertSpecularGlossinessToMetallicRoughness(specularGlossiness: any): {
+        baseColor: Color3;
+        metallic: number;
+        roughness: number;
+    };
+    /**
+     * Calculates the surface reflectance, independent of lighting conditions
+     * @param color Color source to calculate brightness from
+     * @returns number representing the perceived brightness, or zero if color is undefined
+     */
+    _getPerceivedBrightness(color: any): number;
+    /**
+     * Returns the maximum color component value
+     * @param color
+     * @returns maximum color component value, or zero if color is null or undefined
+     */
+    _getMaxComponent(color: any): number;
+    /**
+     * Convert a PBRMaterial (Metallic/Roughness) to Metallic Roughness factors
+     * @param babylonPBRMaterial BJS PBR Metallic Roughness Material
+     * @param mimeType mime type to use for the textures
+     * @param glTFPbrMetallicRoughness glTF PBR Metallic Roughness interface
+     * @param hasTextureCoords specifies if texture coordinates are present on the submesh to determine if textures should be applied
+     * @returns glTF PBR Metallic Roughness factors
+     */
+    _convertMetalRoughFactorsToMetallicRoughnessAsync(babylonPBRMaterial: any, mimeType: any, glTFPbrMetallicRoughness: any, hasTextureCoords: any): Promise<{
+        baseColor: any;
+        metallic: any;
+        roughness: any;
+    }>;
+    _getGLTFTextureSampler(texture: any): {
+        wrapS?: undefined;
+        wrapT?: undefined;
+    } | {
+        wrapS: number;
+        wrapT: number;
+    };
+    _getGLTFTextureWrapMode(wrapMode: any): 33071 | 33648 | 10497;
+    _getGLTFTextureWrapModesSampler(texture: any): {
+        wrapS?: undefined;
+        wrapT?: undefined;
+    } | {
+        wrapS: number;
+        wrapT: number;
+    };
+    /**
+     * Convert a PBRMaterial (Specular/Glossiness) to Metallic Roughness factors
+     * @param babylonPBRMaterial BJS PBR Metallic Roughness Material
+     * @param mimeType mime type to use for the textures
+     * @param glTFPbrMetallicRoughness glTF PBR Metallic Roughness interface
+     * @param hasTextureCoords specifies if texture coordinates are present on the submesh to determine if textures should be applied
+     * @returns glTF PBR Metallic Roughness factors
+     */
+    _convertSpecGlossFactorsToMetallicRoughnessAsync(babylonPBRMaterial: any, mimeType: any, glTFPbrMetallicRoughness: any, hasTextureCoords: any): Promise<{
+        baseColor: Color3;
+        metallic: number;
+        roughness: number;
+    }>;
+    /**
+     * Converts a Babylon PBR Base Material to a glTF Material
+     * @param babylonPBRMaterial BJS PBR Base Material
+     * @param mimeType mime type to use for the textures
+     * @param hasTextureCoords specifies if texture coordinates are present on the submesh to determine if textures should be applied
+     */
+    _convertPBRMaterialAsync(babylonPBRMaterial: any, mimeType: any, hasTextureCoords: any): Promise<any>;
+    _setMetallicRoughnessPbrMaterial(metallicRoughness: any, babylonPBRMaterial: any, glTFMaterial: any, glTFPbrMetallicRoughness: any, mimeType: any, hasTextureCoords: any): Promise<any>;
+    _getPixelsFromTexture(babylonTexture: any): any;
+    /**
+     * Extracts a texture from a Babylon texture into file data and glTF data
+     * @param babylonTexture Babylon texture to extract
+     * @param mimeType Mime Type of the babylonTexture
+     * @returns glTF texture info, or null if the texture format is not supported
+     */
+    _exportTextureAsync(babylonTexture: any, mimeType: any): any;
+    _exportTextureInfoAsync(babylonTexture: any, mimeType: any): Promise<any>;
+    /**
+     * Builds a texture from base64 string
+     * @param base64Texture base64 texture string
+     * @param baseTextureName Name to use for the texture
+     * @param mimeType image mime type for the texture
+     * @param texCoordIndex
+     * @param samplerIndex
+     * @returns glTF texture info, or null if the texture format is not supported
+     */
+    _getTextureInfoFromBase64(base64Texture: any, baseTextureName: any, mimeType: any, texCoordIndex: any, samplerIndex: any): {
+        index: number;
+    } | null;
+}
+export namespace _GLTFMaterialExporter {
+    const _DielectricSpecular: Color3;
+    const _MaxSpecularPower: number;
+    const _Epsilon: number;
+}
+import { RawTexture } from "@babylonjs/core/Materials/Textures/rawTexture.js";
+import { Color3 } from "@babylonjs/core/Maths/math.color.js";

package/dist/types/node_modules/@babylonjs/serializers/glTF/2.0/glTFSerializer.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Class for generating glTF data from a Babylon scene.
+ */
+export class GLTF2Export {
+    /**
+     * Exports the geometry of the scene to .gltf file format asynchronously
+     * @param scene Babylon scene with scene hierarchy information
+     * @param filePrefix File prefix to use when generating the glTF file
+     * @param options Exporter options
+     * @returns Returns an object with a .gltf file and associates texture names
+     * as keys and their data and paths as values
+     */
+    static GLTFAsync(scene: any, filePrefix: any, options: any): any;
+    static _PreExportAsync(scene: any, options: any): Promise<any>;
+    static _PostExportAsync(scene: any, glTFData: any, options: any): Promise<any>;
+    /**
+     * Exports the geometry of the scene to .glb file format asychronously
+     * @param scene Babylon scene with scene hierarchy information
+     * @param filePrefix File prefix to use when generating glb file
+     * @param options Exporter options
+     * @returns Returns an object with a .glb filename as key and data as value
+     */
+    static GLBAsync(scene: any, filePrefix: any, options: any): Promise<any>;
+}

package/dist/types/node_modules/@babylonjs/serializers/glTF/2.0/glTFUtilities.d.ts

@@ -0,0 +1,104 @@
+/**
+ * @internal
+ */
+export class _GLTFUtilities {
+    /**
+     * Creates a buffer view based on the supplied arguments
+     * @param bufferIndex index value of the specified buffer
+     * @param byteOffset byte offset value
+     * @param byteLength byte length of the bufferView
+     * @param byteStride byte distance between conequential elements
+     * @param name name of the buffer view
+     * @returns bufferView for glTF
+     */
+    static _CreateBufferView(bufferIndex: any, byteOffset: any, byteLength: any, byteStride: any, name: any): {
+        buffer: any;
+        byteLength: any;
+    };
+    /**
+     * Creates an accessor based on the supplied arguments
+     * @param bufferviewIndex The index of the bufferview referenced by this accessor
+     * @param name The name of the accessor
+     * @param type The type of the accessor
+     * @param componentType The datatype of components in the attribute
+     * @param count The number of attributes referenced by this accessor
+     * @param byteOffset The offset relative to the start of the bufferView in bytes
+     * @param min Minimum value of each component in this attribute
+     * @param max Maximum value of each component in this attribute
+     * @returns accessor for glTF
+     */
+    static _CreateAccessor(bufferviewIndex: any, name: any, type: any, componentType: any, count: any, byteOffset: any, min: any, max: any): {
+        name: any;
+        bufferView: any;
+        componentType: any;
+        count: any;
+        type: any;
+    };
+    /**
+     * Calculates the minimum and maximum values of an array of position floats
+     * @param positions Positions array of a mesh
+     * @param vertexStart Starting vertex offset to calculate min and max values
+     * @param vertexCount Number of vertices to check for min and max values
+     * @param convertToRightHandedSystem
+     * @returns min number array and max number array
+     */
+    static _CalculateMinMaxPositions(positions: any, vertexStart: any, vertexCount: any, convertToRightHandedSystem: any): {
+        min: number[];
+        max: number[];
+    };
+    /**
+     * Converts a new right-handed Vector3
+     * @param vector vector3 array
+     * @returns right-handed Vector3
+     */
+    static _GetRightHandedPositionVector3(vector: any): Vector3;
+    /**
+     * Converts a Vector3 to right-handed
+     * @param vector Vector3 to convert to right-handed
+     */
+    static _GetRightHandedPositionVector3FromRef(vector: any): void;
+    /**
+     * Converts a three element number array to right-handed
+     * @param vector number array to convert to right-handed
+     */
+    static _GetRightHandedPositionArray3FromRef(vector: any): void;
+    /**
+     * Converts a new right-handed Vector3
+     * @param vector vector3 array
+     * @returns right-handed Vector3
+     */
+    static _GetRightHandedNormalVector3(vector: any): Vector3;
+    /**
+     * Converts a Vector3 to right-handed
+     * @param vector Vector3 to convert to right-handed
+     */
+    static _GetRightHandedNormalVector3FromRef(vector: any): void;
+    /**
+     * Converts a three element number array to right-handed
+     * @param vector number array to convert to right-handed
+     */
+    static _GetRightHandedNormalArray3FromRef(vector: any): void;
+    /**
+     * Converts a Vector4 to right-handed
+     * @param vector Vector4 to convert to right-handed
+     */
+    static _GetRightHandedVector4FromRef(vector: any): void;
+    /**
+     * Converts a Vector4 to right-handed
+     * @param vector Vector4 to convert to right-handed
+     */
+    static _GetRightHandedArray4FromRef(vector: any): void;
+    /**
+     * Converts a Quaternion to right-handed
+     * @param quaternion Source quaternion to convert to right-handed
+     */
+    static _GetRightHandedQuaternionFromRef(quaternion: any): void;
+    /**
+     * Converts a Quaternion to right-handed
+     * @param quaternion Source quaternion to convert to right-handed
+     */
+    static _GetRightHandedQuaternionArrayFromRef(quaternion: any): void;
+    static _NormalizeTangentFromRef(tangent: any): void;
+    static _GetDataAccessorElementCount(accessorType: any): 1 | 4 | 2 | 16 | 3 | 9 | undefined;
+}
+import { Vector3 } from "@babylonjs/core/Maths/math.vector.js";

package/dist/types/node_modules/@babylonjs/serializers/glTF/2.0/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./glTFAnimation.js";
+export * from "./glTFData.js";
+export * from "./glTFExporter.js";
+export * from "./glTFExporterExtension.js";
+export * from "./glTFMaterialExporter.js";
+export * from "./glTFSerializer.js";
+export * from "./glTFUtilities.js";
+export * from "./Extensions/index.js";

package/dist/types/node_modules/@babylonjs/serializers/glTF/2.0/shaders/textureTransform.fragment.d.ts

@@ -0,0 +1,7 @@
+export namespace textureTransformPixelShader {
+    export { name };
+    export { shader };
+}
+declare const name: "textureTransformPixelShader";
+declare const shader: "precision highp float;varying vec2 vUV;uniform sampler2D textureSampler;uniform mat4 textureTransformMat;void main(void) {\n#define CUSTOM_FRAGMENT_MAIN_BEGIN\nvec2 uvTransformed=(textureTransformMat*vec4(vUV.xy,1,1)).xy;gl_FragColor=texture2D(textureSampler,uvTransformed);\n#define CUSTOM_FRAGMENT_MAIN_END\n}";
+export {};

package/dist/types/node_modules/@babylonjs/serializers/glTF/glTFFileExporter.d.ts

@@ -0,0 +1,2 @@
+/** @internal */
+export const __IGLTFExporterExtension: number;

package/dist/types/node_modules/@babylonjs/serializers/glTF/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./glTFFileExporter.js";
+export * from "./2.0/index.js";

package/dist/types/node_modules/@babylonjs/serializers/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./OBJ/index.js";
+export * from "./glTF/index.js";
+export * from "./stl/index.js";

package/dist/types/node_modules/@babylonjs/serializers/legacy/legacy-glTF2Serializer.d.ts

@@ -0,0 +1,2 @@
+export * from "../glTF/glTFFileExporter.js";
+export * from "../glTF/2.0/index.js";

package/dist/types/node_modules/@babylonjs/serializers/legacy/legacy-objSerializer.d.ts

@@ -0,0 +1 @@
+export * from "../OBJ/index.js";

package/dist/types/node_modules/@babylonjs/serializers/legacy/legacy-stlSerializer.d.ts

@@ -0,0 +1 @@
+export * from "../stl/index.js";

package/dist/types/node_modules/@babylonjs/serializers/legacy/legacy.d.ts

@@ -0,0 +1,3 @@
+export * from "./legacy-glTF2Serializer.js";
+export * from "./legacy-objSerializer.js";
+export * from "./legacy-stlSerializer.js";

package/dist/types/node_modules/@babylonjs/serializers/stl/index.d.ts

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

package/dist/types/node_modules/@babylonjs/serializers/stl/stlSerializer.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Class for generating STL data from a Babylon scene.
+ */
+export class STLExport {
+    /**
+     * Exports the geometry of a Mesh array in .STL file format (ASCII)
+     * @param meshes list defines the mesh to serialize
+     * @param download triggers the automatic download of the file.
+     * @param fileName changes the downloads fileName.
+     * @param binary changes the STL to a binary type.
+     * @param isLittleEndian toggle for binary type exporter.
+     * @param doNotBakeTransform toggle if meshes transforms should be baked or not.
+     * @returns the STL as UTF8 string
+     */
+    static CreateSTL(meshes: any, download?: boolean, fileName?: string, binary?: boolean, isLittleEndian?: boolean, doNotBakeTransform?: boolean): string | DataView;
+}

package/dist/types/src/api/classes/animationInterface.d.ts

@@ -0,0 +1,8 @@
+/**
+ * An Interface defining the basic functionality of an animation.
+ */
+export interface AnimationInterface {
+    play(): Promise<AnimationInterface>;
+    pause(): AnimationInterface;
+    kill(): AnimationInterface;
+}

package/dist/types/src/api/classes/dottedPath.d.ts

@@ -0,0 +1,79 @@
+export declare class DottedPath {
+    static DELIMITER: string;
+    static SAFE_CHAR: string;
+    parts: string[];
+    /**
+     * Magic factory function that creates a DottedPath based on the argument type.
+     */
+    static create(dottedPath?: DottedPathArgument): DottedPath;
+    /**
+     * Creates a DottedPath from a string.
+     * Allows patterns with unsafe characters wrapped in apostrophes or quotes.
+     * E.g. "part1.part2.'part.3'.part_4"
+     */
+    static createFromPath(path: string): DottedPath;
+    /**
+     * Creates a DottedPath from a string list.
+     */
+    static createFromParts(parts: string[]): DottedPath;
+    /**
+     * Creates an empty DottedPath.
+     */
+    static createEmpty(): DottedPath;
+    /**
+     * Sanitizes given part: replaces all characters like {@link DottedPath.DELIMITER}
+     * with a "safe" character like {@link DottedPath.SAFE_CHAR}.
+     * (i) Does not trim whitespace.
+     */
+    static sanitizePart(part: string): string;
+    /**
+     * Constructor
+     */
+    private constructor();
+    /**
+     * The path.
+     * (i) Does not return an empty dot for no path.
+     */
+    get path(): string;
+    /**
+     * The first part.
+     */
+    get firstPart(): string | null;
+    /**
+     * The last part.
+     */
+    get lastPart(): string | null;
+    /**
+     * Gets the tokens to each leaf of the DottedPath tree.
+     * E.g. "part1.part2.part_3" will return an array like
+     *      ["part1", "part1.part2", "part1.part2.part_3"]
+     */
+    get leafTokens(): string[];
+    /**
+     * Removes the first part and returns it.
+     */
+    shiftPart(): string | undefined;
+    /**
+     * Adds part to the beginning of parts list.
+     */
+    unshiftPart(part: string, duplicateCheck?: boolean): DottedPath;
+    /**
+     * Adds part to the end of parts list.
+     * (i) Does not add a part if the last char already is the delimiter or if an empty string was passed.
+     */
+    addPart(part: string, duplicateCheck?: boolean): DottedPath;
+    /**
+     * Adds multiple parts to the end of parts list.
+     */
+    addParts(parts: string[], duplicateCheck?: boolean): DottedPath;
+    /**
+     * Removes the last part and returns it.
+     */
+    popPart(): string | undefined;
+    toString(): string;
+    valueOf(): string;
+    /**
+     * Clones the DottedPath.
+     */
+    clone(): DottedPath;
+}

package/dist/types/src/api/classes/element.d.ts

@@ -0,0 +1,153 @@
+import { VariantParameterizable } from './../classes/variantParameterizable';
+import { DottedPath } from './dottedPath';
+import { Variant } from './variant';
+import { HighlightLayer } from '@babylonjs/core/Layers/highlightLayer';
+import { AbstractMesh } from '@babylonjs/core/Meshes/abstractMesh';
+import { Mesh } from '@babylonjs/core/Meshes/mesh';
+import { TransformNode } from '@babylonjs/core/Meshes/transformNode';
+/**
+ * An {@link Element} of a {@link Variant}. Acts as a container for diverse definitions. Lives only in the context of a
+ * {@link Variant}.
+ *
+ * When used in typings, refer to via its alias {@link VariantElement} to prevent name clashes with the web APIs
+ * [Element](https://developer.mozilla.org/en-US/docs/Web/API/Element) class
+ */
+export declare class Element extends VariantParameterizable {
+    readonly variant: Variant;
+    readonly name: string;
+    readonly nodes: TransformNode[];
+    protected readonly _dottedNodes: Map<DottedPath, TransformNode>;
+    protected _highlightLayer?: HighlightLayer;
+    /**
+     * Constructor.
+     */
+    protected constructor(variant: Variant, name: string);
+    /**
+     * Creates an {@link Element} with given name.
+     */
+    static create(variant: Variant, name: string): Promise<Element>;
+    /**
+     * The {@link DottedPath} in the built tree of {@link Element}s.
+     * E.g. "_.top-1.sub-2.sub-sub-3.el-1"
+     */
+    get dottedPath(): DottedPath;
+    /**
+     * The id representing a {@link DottedPath}.
+     */
+    get id(): string;
+    /**
+     * The {@link ElementDefinition} of the {@link Element}.
+     */
+    get definition(): ElementDefinition;
+    /**
+     * The {@link PathDefinitions} of the {@link Element}.
+     */
+    get pathDefinitions(): PathDefinitions;
+    /**
+     * The {@link TraceableDefinitions} of the {@link Element}.
+     */
+    get traceableDefinitions(): TraceableDefinitions;
+    /**
+     * The {@link PaintableDefinition} of the {@link Element}.
+     */
+    get paintableDefinitions(): PaintableDefinitions;
+    /**
+     * The inherited {@link ParameterBag}.
+     * Merges the {@link Variant}'s parameters and those from the {@link Element}.
+     */
+    get inheritedParameters(): ParameterBag;
+    /**
+     * The actual {@link TransformNode}s that make up this {@link Element}.
+     */
+    get nodesFlat(): TransformNode[];
+    /**
+     * The actual {@link Mesh}es that make up this {@link Element}.
+     * Handy for e.g. creating a bounding box around an entire element.
+     */
+    get meshesFlat(): Mesh[];
+    /**
+     * The actual {@link AbstractMesh}es that make up this {@link Element}.
+     * I.e. (real) Meshes as well as InstancedMeshes.
+     */
+    get abstractMeshesFlat(): AbstractMesh[];
+    /**
+     * The meshes of this {@link Element}.
+     */
+    get meshes(): Mesh[];
+    /**
+     * @protected
+     */
+    set highlightLayer(layer: HighlightLayer | undefined);
+    get highlightLayer(): HighlightLayer | undefined;
+    /**
+     * Destroys this {@link Element} and dispose all nodes.
+     */
+    destroy(): Element;
+    /**
+     * Gets a node by its {@link DottedPath}.
+     */
+    getNode(dottedPath: DottedPathArgument): TransformNode;
+    /**
+     * Gets a mesh by its {@link DottedPath}.
+     */
+    getMesh(dottedPath: DottedPathArgument): Promise<Mesh | null>;
+    /**
+     * Gets a {@link PaintableDefinition} by its name.
+     */
+    getPaintableDefinition(name: string): PaintableDefinition;
+    /**
+     * Gets a {@link TraceableDefinition} by its name.
+     */
+    getTraceableDefinition(name: string): TraceableDefinition;
+    /**
+     * Gets the paintable Node by its name.
+     */
+    getPaintableNode(name: string): TransformNode;
+    /**
+     * Gets the traceable Node by its name.
+     */
+    getTraceableNode(name: string): TransformNode;
+    /**
+     * @see {@link VariantParameterizable.commitParameters}
+     * @emit {@link Event.ELEMENT_PARAMETER_COMMITTED}
+     */
+    commitParameters(parameters?: ParameterBag): Promise<VariantParameterizable>;
+    /**
+     * Adds an observer function for camera matrix changes.
+     * The `observer` gets 2 parameters: the `AbstractMesh` and a `ClientRect` object.
+     */
+    addTraceableObserver(traceable: string, observer: CallableFunction, payload?: any): Element;
+    /**
+     * Draws a `ImageBitmap` or `OffscreenCanvas` onto a `paintable` defined via {@link PaintableDefinition}.
+     */
+    drawPaintable(paintable: string, imageSource: CanvasImageSource): Element;
+    /**
+     * Draws a SVG string onto a `paintable` defined via {@link PaintableDefinition}.
+     */
+    drawPaintableFromSvg(paintable: string, svgSource: string): Promise<Element>;
+    /**
+     * Draws an Image from source (URL/URI) onto a `paintable` defined via {@link PaintableDefinition}.
+     */
+    drawPaintableFromImgSrc(paintable: string, imgSource: string): Promise<Element>;
+    /**
+     * Adds observers for loading missing materials where needed
+     */
+    protected addMissingMaterialObservers(): void;
+    /**
+     * Adds the default {@link ParameterObserver}s which are called every time {@link commitParameters} is called.
+     */
+    protected addParameterObservers(): Element;
+    /**
+     * Filter for nodes that are not defined or excluded in the `pathDefinitions`.
+     */
+    protected filterNode(node: TransformNode): boolean;
+    /**
+     * Asserts whether all {@link pathDefinitions} link to a valid `Node` path.
+     * @protected
+     */
+    protected assertPathDefinitions(): void;
+    /**
+     * Handles callback for given light parameter.
+     */
+    private castShadowValueHandler;
+}