@combeenation/3d-viewer 0.0.1-types

package/dist/types/node_modules/@babylonjs/core/Meshes/buffer.d.ts

@@ -0,0 +1 @@
+export { VertexBuffer, Buffer } from "../Buffers/buffer.js";

package/dist/types/node_modules/@babylonjs/core/Meshes/csg.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Class for building Constructive Solid Geometry
+ */
+export class CSG {
+    /**
+     * Convert the Mesh to CSG
+     * @param mesh The Mesh to convert to CSG
+     * @param absolute If true, the final (local) matrix transformation is set to the identity and not to that of `mesh`. It can help when dealing with right-handed meshes (default: false)
+     * @returns A new CSG from the Mesh
+     */
+    static FromMesh(mesh: any, absolute?: boolean): CSG;
+    /**
+     * Construct a CSG solid from a list of `CSG.Polygon` instances.
+     * @param polygons Polygons used to construct a CSG solid
+     */
+    static _FromPolygons(polygons: any): CSG;
+    _polygons: any[];
+    /**
+     * Clones, or makes a deep copy, of the CSG
+     * @returns A new CSG
+     */
+    clone(): CSG;
+    /**
+     * Unions this CSG with another CSG
+     * @param csg The CSG to union against this CSG
+     * @returns The unioned CSG
+     */
+    union(csg: any): CSG;
+    /**
+     * Unions this CSG with another CSG in place
+     * @param csg The CSG to union against this CSG
+     */
+    unionInPlace(csg: any): void;
+    /**
+     * Subtracts this CSG with another CSG
+     * @param csg The CSG to subtract against this CSG
+     * @returns A new CSG
+     */
+    subtract(csg: any): CSG;
+    /**
+     * Subtracts this CSG with another CSG in place
+     * @param csg The CSG to subtract against this CSG
+     */
+    subtractInPlace(csg: any): void;
+    /**
+     * Intersect this CSG with another CSG
+     * @param csg The CSG to intersect against this CSG
+     * @returns A new CSG
+     */
+    intersect(csg: any): CSG;
+    /**
+     * Intersects this CSG with another CSG in place
+     * @param csg The CSG to intersect against this CSG
+     */
+    intersectInPlace(csg: any): void;
+    /**
+     * Return a new CSG solid with solid and empty space switched. This solid is
+     * not modified.
+     * @returns A new CSG solid with solid and empty space switched
+     */
+    inverse(): CSG;
+    /**
+     * Inverses the CSG in place
+     */
+    inverseInPlace(): void;
+    /**
+     * This is used to keep meshes transformations so they can be restored
+     * when we build back a Babylon Mesh
+     * NB : All CSG operations are performed in world coordinates
+     * @param csg The CSG to copy the transform attributes from
+     * @returns This CSG
+     */
+    copyTransformAttributes(csg: any): CSG;
+    matrix: any;
+    position: any;
+    rotation: any;
+    scaling: any;
+    rotationQuaternion: any;
+    /**
+     * Build Raw mesh from CSG
+     * Coordinates here are in world space
+     * @param name The name of the mesh geometry
+     * @param scene The Scene
+     * @param keepSubMeshes Specifies if the submeshes should be kept
+     * @returns A new Mesh
+     */
+    buildMeshGeometry(name: any, scene: any, keepSubMeshes: any): Mesh;
+    /**
+     * Build Mesh from CSG taking material and transforms into account
+     * @param name The name of the Mesh
+     * @param material The material of the Mesh
+     * @param scene The Scene
+     * @param keepSubMeshes Specifies if submeshes should be kept
+     * @returns The new Mesh
+     */
+    toMesh(name: any, material: null | undefined, scene: any, keepSubMeshes: any): Mesh;
+}
+import { Mesh } from "../Meshes/mesh.js";

package/dist/types/node_modules/@babylonjs/core/Meshes/geodesicMesh.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Class representing data for one face OAB of an equilateral icosahedron
+ * When O is the isovector (0, 0), A is isovector (m, n)
+ * @internal
+ */
+export class _PrimaryIsoTriangle {
+    cartesian: any[];
+    vertices: any[];
+    max: any[];
+    min: any[];
+    closestTo: any[];
+    innerFacets: any[];
+    isoVecsABOB: any[];
+    isoVecsOBOA: any[];
+    isoVecsBAOA: any[];
+    vertexTypes: any[];
+    IDATA: PolyhedronData;
+    /**
+     * Creates the PrimaryIsoTriangle Triangle OAB
+     * @param m an integer
+     * @param n an integer
+     */
+    setIndices(): void;
+    vecToidx: {} | undefined;
+    calcCoeffs(): void;
+    coau: number | undefined;
+    cobu: number | undefined;
+    coav: number | undefined;
+    cobv: number | undefined;
+    createInnerFacets(): void;
+    edgeVecsABOB(): void;
+    mapABOBtoOBOA(): void;
+    mapABOBtoBAOA(): void;
+    MapToFace(faceNb: any, geodesicData: any): void;
+    /**Creates a primary triangle
+     * @internal
+     */
+    build(m: any, n: any): _PrimaryIsoTriangle;
+    m: any;
+    n: any;
+    vertByDist: {} | undefined;
+}
+/** Builds Polyhedron Data
+ * @internal
+ */
+export class PolyhedronData {
+    constructor(name: any, category: any, vertex: any, face: any);
+    name: any;
+    category: any;
+    vertex: any;
+    face: any;
+}
+/**
+ * This class Extends the PolyhedronData Class to provide measures for a Geodesic Polyhedron
+ */
+export class GeodesicData extends PolyhedronData {
+    /**Builds the data for a Geodesic Polyhedron from a primary triangle
+     * @param primTri the primary triangle
+     * @internal
+     */
+    static BuildGeodesicData(primTri: any): GeodesicData;
+    /**
+     * @internal
+     */
+    innerToData(face: any, primTri: any): void;
+    /**
+     * @internal
+     */
+    mapABOBtoDATA(faceNb: any, primTri: any): void;
+    /**
+     * @internal
+     */
+    mapOBOAtoDATA(faceNb: any, primTri: any): void;
+    /**
+     * @internal
+     */
+    mapBAOAtoDATA(faceNb: any, primTri: any): void;
+    /**
+     * @internal
+     */
+    orderData(primTri: any): void;
+    sharedNodes: number | undefined;
+    poleNodes: number | undefined;
+    /**
+     * @internal
+     */
+    setOrder(m: any, faces: any): any[];
+    /**
+     * @internal
+     */
+    toGoldbergPolyhedronData(): PolyhedronData;
+    adjacentFaces: any[] | undefined;
+}

package/dist/types/node_modules/@babylonjs/core/Meshes/geometry.d.ts

@@ -0,0 +1,327 @@
+/**
+ * Class used to store geometry data (vertex buffers + index buffer)
+ */
+export class Geometry {
+    /**
+     * Static function used to attach a new empty geometry to a mesh
+     * @param mesh defines the mesh to attach the geometry to
+     * @returns the new Geometry
+     */
+    static CreateGeometryForMesh(mesh: any): Geometry;
+    /**
+     * Extracts a clone of a mesh geometry
+     * @param mesh defines the source mesh
+     * @param id defines the unique ID of the new geometry object
+     * @returns the new geometry object
+     */
+    static ExtractFromMesh(mesh: any, id: any): any;
+    /**
+     * You should now use Tools.RandomId(), this method is still here for legacy reasons.
+     * Implementation from http://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid-in-javascript/2117523#answer-2117523
+     * Be aware Math.random() could cause collisions, but:
+     * "All but 6 of the 128 bits of the ID are randomly generated, which means that for any two ids, there's a 1 in 2^^122 (or 5.3x10^^36) chance they'll collide"
+     * @returns a string containing a new GUID
+     */
+    static RandomId(): string;
+    static _GetGeometryByLoadedUniqueId(uniqueId: any, scene: any): any;
+    /**
+     * @internal
+     */
+    static _ImportGeometry(parsedGeometry: any, mesh: any): void;
+    static _CleanMatricesWeights(parsedGeometry: any, mesh: any): void;
+    /**
+     * Create a new geometry from persisted data (Using .babylon file format)
+     * @param parsedVertexData defines the persisted data
+     * @param scene defines the hosting scene
+     * @param rootUrl defines the root url to use to load assets (like delayed data)
+     * @returns the new geometry object
+     */
+    static Parse(parsedVertexData: any, scene: any, rootUrl: any): Geometry;
+    /**
+     * Creates a new geometry
+     * @param id defines the unique ID
+     * @param scene defines the hosting scene
+     * @param vertexData defines the VertexData used to get geometry data
+     * @param updatable defines if geometry must be updatable (false by default)
+     * @param mesh defines the mesh that will be associated with the geometry
+     */
+    constructor(id: any, scene: any, vertexData: any, updatable?: boolean, mesh?: null);
+    /**
+     * Gets the delay loading state of the geometry (none by default which means not delayed)
+     */
+    delayLoadState: number;
+    _totalVertices: number;
+    _isDisposed: boolean;
+    _indexBufferIsUpdatable: boolean;
+    _positionsCache: any[];
+    /** @internal */
+    _parentContainer: any;
+    /**
+     * If set to true (false by default), the bounding info applied to the meshes sharing this geometry will be the bounding info defined at the class level
+     * and won't be computed based on the vertex positions (which is what we get when useBoundingInfoFromGeometry = false)
+     */
+    useBoundingInfoFromGeometry: boolean;
+    _scene: any;
+    id: any;
+    uniqueId: any;
+    _engine: any;
+    _meshes: any[] | undefined;
+    _vertexBuffers: {} | undefined;
+    _indices: any[] | undefined;
+    _updatable: boolean | undefined;
+    _vertexArrayObjects: {} | undefined;
+    /**
+     *  Gets or sets the Bias Vector to apply on the bounding elements (box/sphere), the max extend is computed as v += v * bias.x + bias.y, the min is computed as v -= v * bias.x + bias.y
+     */
+    set boundingBias(arg: any);
+    /**
+     *  Gets or sets the Bias Vector to apply on the bounding elements (box/sphere), the max extend is computed as v += v * bias.x + bias.y, the min is computed as v -= v * bias.x + bias.y
+     */
+    get boundingBias(): any;
+    _boundingBias: any;
+    /** Get the list of meshes using this geometry */
+    get meshes(): any[] | undefined;
+    /**
+     * Gets the current extend of the geometry
+     */
+    get extend(): {
+        minimum: Vector3;
+        maximum: Vector3;
+    } | {
+        minimum: any;
+        maximum: any;
+    } | undefined;
+    /**
+     * Gets the hosting scene
+     * @returns the hosting Scene
+     */
+    getScene(): any;
+    /**
+     * Gets the hosting engine
+     * @returns the hosting Engine
+     */
+    getEngine(): any;
+    /**
+     * Defines if the geometry is ready to use
+     * @returns true if the geometry is ready to be used
+     */
+    isReady(): boolean;
+    /**
+     * Gets a value indicating that the geometry should not be serialized
+     */
+    get doNotSerialize(): boolean;
+    /** @internal */
+    _rebuild(): void;
+    _indexBuffer: any;
+    /**
+     * Affects all geometry data in one call
+     * @param vertexData defines the geometry data
+     * @param updatable defines if the geometry must be flagged as updatable (false as default)
+     */
+    setAllVerticesData(vertexData: any, updatable: any): void;
+    /**
+     * Set specific vertex data
+     * @param kind defines the data kind (Position, normal, etc...)
+     * @param data defines the vertex data to use
+     * @param updatable defines if the vertex must be flagged as updatable (false as default)
+     * @param stride defines the stride to use (0 by default). This value is deduced from the kind value if not specified
+     */
+    setVerticesData(kind: any, data: any, updatable: boolean | undefined, stride: any): void;
+    /**
+     * Removes a specific vertex data
+     * @param kind defines the data kind (Position, normal, etc...)
+     */
+    removeVerticesData(kind: any): void;
+    /**
+     * Affect a vertex buffer to the geometry. the vertexBuffer.getKind() function is used to determine where to store the data
+     * @param buffer defines the vertex buffer to use
+     * @param totalVertices defines the total number of vertices for position kind (could be null)
+     * @param disposeExistingBuffer disposes the existing buffer, if any (default: true)
+     */
+    setVerticesBuffer(buffer: any, totalVertices?: null, disposeExistingBuffer?: boolean): void;
+    /**
+     * Update a specific vertex buffer
+     * This function will directly update the underlying DataBuffer according to the passed numeric array or Float32Array
+     * It will do nothing if the buffer is not updatable
+     * @param kind defines the data kind (Position, normal, etc...)
+     * @param data defines the data to use
+     * @param offset defines the offset in the target buffer where to store the data
+     * @param useBytes set to true if the offset is in bytes
+     */
+    updateVerticesDataDirectly(kind: any, data: any, offset: any, useBytes?: boolean): void;
+    /**
+     * Update a specific vertex buffer
+     * This function will create a new buffer if the current one is not updatable
+     * @param kind defines the data kind (Position, normal, etc...)
+     * @param data defines the data to use
+     * @param updateExtends defines if the geometry extends must be recomputed (false by default)
+     */
+    updateVerticesData(kind: any, data: any, updateExtends?: boolean): void;
+    _updateBoundingInfo(updateExtends: any, data: any): void;
+    /**
+     * @internal
+     */
+    _bind(effect: any, indexToBind: any, overrideVertexBuffers: any, overrideVertexArrayObjects: any): void;
+    /**
+     * Gets total number of vertices
+     * @returns the total number of vertices
+     */
+    getTotalVertices(): number;
+    /**
+     * Gets a specific vertex data attached to this geometry. Float data is constructed if the vertex buffer data cannot be returned directly.
+     * @param kind defines the data kind (Position, normal, etc...)
+     * @param copyWhenShared defines if the returned array must be cloned upon returning it if the current geometry is shared between multiple meshes
+     * @param forceCopy defines a boolean indicating that the returned array must be cloned upon returning it
+     * @returns a float array containing vertex data
+     */
+    getVerticesData(kind: any, copyWhenShared: any, forceCopy: any): any;
+    /**
+     * Returns a boolean defining if the vertex data for the requested `kind` is updatable
+     * @param kind defines the data kind (Position, normal, etc...)
+     * @returns true if the vertex buffer with the specified kind is updatable
+     */
+    isVertexBufferUpdatable(kind: any): any;
+    /**
+     * Gets a specific vertex buffer
+     * @param kind defines the data kind (Position, normal, etc...)
+     * @returns a VertexBuffer
+     */
+    getVertexBuffer(kind: any): any;
+    /**
+     * Returns all vertex buffers
+     * @returns an object holding all vertex buffers indexed by kind
+     */
+    getVertexBuffers(): {} | null | undefined;
+    /**
+     * Gets a boolean indicating if specific vertex buffer is present
+     * @param kind defines the data kind (Position, normal, etc...)
+     * @returns true if data is present
+     */
+    isVerticesDataPresent(kind: any): boolean;
+    /**
+     * Gets a list of all attached data kinds (Position, normal, etc...)
+     * @returns a list of string containing all kinds
+     */
+    getVerticesDataKinds(): string[];
+    /**
+     * Update index buffer
+     * @param indices defines the indices to store in the index buffer
+     * @param offset defines the offset in the target buffer where to store the data
+     * @param gpuMemoryOnly defines a boolean indicating that only the GPU memory must be updated leaving the CPU version of the indices unchanged (false by default)
+     */
+    updateIndices(indices: any, offset: any, gpuMemoryOnly?: boolean): void;
+    /**
+     * Creates a new index buffer
+     * @param indices defines the indices to store in the index buffer
+     * @param totalVertices defines the total number of vertices (could be null)
+     * @param updatable defines if the index buffer must be flagged as updatable (false by default)
+     */
+    setIndices(indices: any, totalVertices?: null, updatable?: boolean): void;
+    /**
+     * Return the total number of indices
+     * @returns the total number of indices
+     */
+    getTotalIndices(): number;
+    /**
+     * Gets the index buffer array
+     * @param copyWhenShared defines if the returned array must be cloned upon returning it if the current geometry is shared between multiple meshes
+     * @param forceCopy defines a boolean indicating that the returned array must be cloned upon returning it
+     * @returns the index buffer array
+     */
+    getIndices(copyWhenShared: any, forceCopy: any): any[] | null | undefined;
+    /**
+     * Gets the index buffer
+     * @returns the index buffer
+     */
+    getIndexBuffer(): any;
+    /**
+     * @internal
+     */
+    _releaseVertexArrayObject(effect?: null): void;
+    /**
+     * Release the associated resources for a specific mesh
+     * @param mesh defines the source mesh
+     * @param shouldDispose defines if the geometry must be disposed if there is no more mesh pointing to it
+     */
+    releaseForMesh(mesh: any, shouldDispose: any): void;
+    /**
+     * Apply current geometry to a given mesh
+     * @param mesh defines the mesh to apply geometry to
+     */
+    applyToMesh(mesh: any): void;
+    _updateExtend(data?: null): void;
+    _extend: {
+        minimum: Vector3;
+        maximum: Vector3;
+    } | {
+        minimum: any;
+        maximum: any;
+    } | undefined;
+    _applyToMesh(mesh: any): void;
+    _notifyUpdate(kind: any): void;
+    /**
+     * Load the geometry if it was flagged as delay loaded
+     * @param scene defines the hosting scene
+     * @param onLoaded defines a callback called when the geometry is loaded
+     */
+    load(scene: any, onLoaded: any): void;
+    _queueLoad(scene: any, onLoaded: any): void;
+    _delayInfo: any[] | undefined;
+    /**
+     * Invert the geometry to move from a right handed system to a left handed one.
+     */
+    toLeftHanded(): void;
+    /** @internal */
+    _resetPointsArrayCache(): void;
+    _positions: any[] | null | undefined;
+    /** @internal */
+    _generatePointsArray(): boolean;
+    /**
+     * Gets a value indicating if the geometry is disposed
+     * @returns true if the geometry was disposed
+     */
+    isDisposed(): boolean;
+    _disposeVertexArrayObjects(): void;
+    /**
+     * Free all associated resources
+     */
+    dispose(): void;
+    delayLoadingFile: any;
+    _delayLoadingFunction: any;
+    _boundingInfo: any;
+    /**
+     * Clone the current geometry into a new geometry
+     * @param id defines the unique ID of the new geometry
+     * @returns a new geometry object
+     */
+    copy(id: any): Geometry;
+    /**
+     * Serialize the current geometry info (and not the vertices data) into a JSON object
+     * @returns a JSON representation of the current geometry data (without the vertices data)
+     */
+    serialize(): {
+        id: any;
+        uniqueId: any;
+        updatable: boolean | undefined;
+        tags: any;
+    };
+    _toNumberArray(origin: any): any[];
+    /**
+     * Release any memory retained by the cached data on the Geometry.
+     *
+     * Call this function to reduce memory footprint of the mesh.
+     * Vertex buffers will not store CPU data anymore (this will prevent picking, collisions or physics to work correctly)
+     */
+    clearCachedData(): void;
+    /**
+     * Serialize all vertices data into a JSON object
+     * @returns a JSON representation of the current geometry data
+     */
+    serializeVerticeData(): {
+        id: any;
+        uniqueId: any;
+        updatable: boolean | undefined;
+        tags: any;
+    };
+}
+import { Vector3 } from "../Maths/math.vector.js";

package/dist/types/node_modules/@babylonjs/core/Meshes/goldbergMesh.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Mesh for a Goldberg Polyhedron which is made from 12 pentagonal and the rest hexagonal faces
+ * @see https://en.wikipedia.org/wiki/Goldberg_polyhedron
+ */
+export class GoldbergMesh extends Mesh {
+    /**
+     * Parses a serialized goldberg mesh
+     * @param parsedMesh the serialized mesh
+     * @param scene the scene to create the goldberg mesh in
+     * @returns the created goldberg mesh
+     */
+    static Parse(parsedMesh: any, scene: any): GoldbergMesh;
+    constructor(...args: any[]);
+    /**
+     * Defines the specific Goldberg data used in this mesh construction.
+     */
+    goldbergData: {
+        faceColors: never[];
+        faceCenters: never[];
+        faceZaxis: never[];
+        faceXaxis: never[];
+        faceYaxis: never[];
+        nbSharedFaces: number;
+        nbUnsharedFaces: number;
+        nbFaces: number;
+        nbFacesAtPole: number;
+        adjacentFaces: never[];
+    };
+    /**
+     * Gets the related Goldberg face from pole infos
+     * @param poleOrShared Defines the pole index or the shared face index if the fromPole parameter is passed in
+     * @param fromPole Defines an optional pole index to find the related info from
+     * @returns the goldberg face number
+     */
+    relatedGoldbergFace(poleOrShared: any, fromPole: any): any;
+    _changeGoldbergFaceColors(colorRange: any): any[];
+    /**
+     * Set new goldberg face colors
+     * @param colorRange the new color to apply to the mesh
+     */
+    setGoldbergFaceColors(colorRange: any): void;
+    /**
+     * Updates new goldberg face colors
+     * @param colorRange the new color to apply to the mesh
+     */
+    updateGoldbergFaceColors(colorRange: any): void;
+    _changeGoldbergFaceUVs(uvRange: any): import("@babylonjs/core").Nullable<import("@babylonjs/core").FloatArray>;
+    /**
+     * set new goldberg face UVs
+     * @param uvRange the new UVs to apply to the mesh
+     */
+    setGoldbergFaceUVs(uvRange: any): void;
+    /**
+     * Updates new goldberg face UVs
+     * @param uvRange the new UVs to apply to the mesh
+     */
+    updateGoldbergFaceUVs(uvRange: any): void;
+    /**
+     * Places a mesh on a particular face of the goldberg polygon
+     * @param mesh Defines the mesh to position
+     * @param face Defines the face to position onto
+     * @param position Defines the position relative to the face we are positioning the mesh onto
+     */
+    placeOnGoldbergFaceAt(mesh: any, face: any, position: any): void;
+}
+import { Mesh } from "../Meshes/mesh.js";

package/dist/types/node_modules/@babylonjs/core/Meshes/groundMesh.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Mesh representing the ground
+ */
+export class GroundMesh extends Mesh {
+    /**
+     * Parses a serialized ground mesh
+     * @param parsedMesh the serialized mesh
+     * @param scene the scene to create the ground mesh in
+     * @returns the created ground mesh
+     */
+    static Parse(parsedMesh: any, scene: any): GroundMesh;
+    constructor(name: any, scene: any);
+    /** If octree should be generated */
+    generateOctree: boolean;
+    /**
+     * The minimum of x and y subdivisions
+     */
+    get subdivisions(): number;
+    /**
+     * X subdivisions
+     */
+    get subdivisionsX(): any;
+    /**
+     * Y subdivisions
+     */
+    get subdivisionsY(): any;
+    /**
+     * This function will divide the mesh into submeshes and update an octree to help to select the right submeshes
+     * for rendering, picking and collision computations. Please note that you must have a decent number of submeshes
+     * to get performance improvements when using an octree.
+     * @param chunksCount the number of submeshes the mesh will be divided into
+     * @param octreeBlocksSize the maximum size of the octree blocks (Default: 32)
+     */
+    optimize(chunksCount: any, octreeBlocksSize?: number): void;
+    _subdivisionsX: any;
+    _subdivisionsY: any;
+    /**
+     * Returns a height (y) value in the World system :
+     * the ground altitude at the coordinates (x, z) expressed in the World system.
+     * @param x x coordinate
+     * @param z z coordinate
+     * @returns the ground y position if (x, z) are outside the ground surface.
+     */
+    getHeightAtCoordinates(x: any, z: any): number;
+    /**
+     * Returns a normalized vector (Vector3) orthogonal to the ground
+     * at the ground coordinates (x, z) expressed in the World system.
+     * @param x x coordinate
+     * @param z z coordinate
+     * @returns Vector3(0.0, 1.0, 0.0) if (x, z) are outside the ground surface.
+     */
+    getNormalAtCoordinates(x: any, z: any): Vector3;
+    /**
+     * Updates the Vector3 passed a reference with a normalized vector orthogonal to the ground
+     * at the ground coordinates (x, z) expressed in the World system.
+     * Doesn't update the reference Vector3 if (x, z) are outside the ground surface.
+     * @param x x coordinate
+     * @param z z coordinate
+     * @param ref vector to store the result
+     * @returns the GroundMesh.
+     */
+    getNormalAtCoordinatesToRef(x: any, z: any, ref: any): GroundMesh;
+    /**
+     * Force the heights to be recomputed for getHeightAtCoordinates() or getNormalAtCoordinates()
+     * if the ground has been updated.
+     * This can be used in the render loop.
+     * @returns the GroundMesh.
+     */
+    updateCoordinateHeights(): GroundMesh;
+    _getFacetAt(x: any, z: any): any;
+    _initHeightQuads(): GroundMesh;
+    _heightQuads: any[] | undefined;
+    _computeHeightQuads(): GroundMesh;
+}
+import { Mesh } from "../Meshes/mesh.js";
+import { Vector3 } from "../Maths/math.vector.js";

package/dist/types/node_modules/@babylonjs/core/Meshes/index.d.ts

@@ -0,0 +1,24 @@
+export * from "./abstractMesh.js";
+export * from "./Compression/index.js";
+export * from "./csg.js";
+export * from "./geometry.js";
+export * from "./groundMesh.js";
+export * from "./goldbergMesh.js";
+export * from "./trailMesh.js";
+export * from "./instancedMesh.js";
+export * from "./linesMesh.js";
+export * from "./mesh.js";
+export * from "./mesh.vertexData.js";
+export * from "./meshBuilder.js";
+export * from "./meshSimplification.js";
+export * from "./meshSimplificationSceneComponent.js";
+export * from "./polygonMesh.js";
+export * from "./geodesicMesh.js";
+export * from "./subMesh.js";
+export * from "./subMesh.project.js";
+export * from "./meshLODLevel.js";
+export * from "./transformNode.js";
+export * from "./Builders/index.js";
+export * from "./WebGL/webGLDataBuffer.js";
+export * from "./WebGPU/webgpuDataBuffer.js";
+export * from "./thinInstanceMesh.js";