@combeenation/3d-viewer 0.0.1-types

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

@@ -0,0 +1,92 @@
+/**
+ * Creates an extruded shape mesh. The extrusion is a parametric shape. It has no predefined shape. Its final shape will depend on the input parameters.
+ * * The parameter `shape` is a required array of successive Vector3. This array depicts the shape to be extruded in its local space : the shape must be designed in the xOy plane and will be extruded along the Z axis.
+ * * The parameter `path` is a required array of successive Vector3. This is the axis curve the shape is extruded along.
+ * * The parameter `rotation` (float, default 0 radians) is the angle value to rotate the shape each step (each path point), from the former step (so rotation added each step) along the curve.
+ * * The parameter `scale` (float, default 1) is the value to scale the shape.
+ * * The parameter `closeShape` (boolean, default false) closes the shape when true, since v5.0.0.
+ * * The parameter `closePath` (boolean, default false) closes the path when true and no caps, since v5.0.0.
+ * * The parameter `cap` sets the way the extruded shape is capped. Possible values : BABYLON.Mesh.NO_CAP (default), BABYLON.Mesh.CAP_START, BABYLON.Mesh.CAP_END, BABYLON.Mesh.CAP_ALL
+ * * The optional parameter `instance` is an instance of an existing ExtrudedShape object to be updated with the passed `shape`, `path`, `scale` or `rotation` parameters : https://doc.babylonjs.com/how_to/how_to_dynamically_morph_a_mesh#extruded-shape
+ * * Remember you can only change the shape or path point positions, not their number when updating an extruded shape.
+ * * You can also set the mesh side orientation with the values : BABYLON.Mesh.FRONTSIDE (default), BABYLON.Mesh.BACKSIDE or BABYLON.Mesh.DOUBLESIDE
+ * * If you create a double-sided mesh, you can choose what parts of the texture image to crop and stick respectively on the front and the back sides with the parameters `frontUVs` and `backUVs` (Vector4). Detail here : https://doc.babylonjs.com/babylon101/discover_basic_elements#side-orientation
+ * * The optional parameter `invertUV` (boolean, default false) swaps in the geometry the U and V coordinates to apply a texture.
+ * * The mesh can be set to updatable with the boolean parameter `updatable` (default false) if its internal geometry is supposed to change once created.
+ * * The optional parameter `firstNormal` (Vector3) defines the direction of the first normal of the supplied path. Consider using this for any path that is straight, and particular for paths in the xy plane.
+ * * The optional `adjustFrame` (boolean, default false) will cause the internally generated Path3D tangents, normals, and binormals to be adjusted so that a) they are always well-defined, and b) they do not reverse from one path point to the next. This prevents the extruded shape from being flipped and/or rotated with resulting mesh self-intersections. This is primarily useful for straight paths that can reverse direction.
+ * @param name defines the name of the mesh
+ * @param options defines the options used to create the mesh
+ * @param options.shape
+ * @param options.path
+ * @param options.scale
+ * @param options.rotation
+ * @param options.closeShape
+ * @param options.closePath
+ * @param options.cap
+ * @param options.updatable
+ * @param options.sideOrientation
+ * @param options.frontUVs
+ * @param options.backUVs
+ * @param options.instance
+ * @param options.invertUV
+ * @param options.firstNormal
+ * @param options.adjustFrame
+ * @param scene defines the hosting scene
+ * @returns the extruded shape mesh
+ * @see https://doc.babylonjs.com/how_to/parametric_shapes
+ * @see https://doc.babylonjs.com/how_to/parametric_shapes#extruded-shapes
+ */
+export function ExtrudeShape(name: any, options: any, scene?: null): any;
+/**
+ * Creates an custom extruded shape mesh.
+ * The custom extrusion is a parametric shape. It has no predefined shape. Its final shape will depend on the input parameters.
+ * * The parameter `shape` is a required array of successive Vector3. This array depicts the shape to be extruded in its local space : the shape must be designed in the xOy plane and will be extruded along the Z axis.
+ * * The parameter `path` is a required array of successive Vector3. This is the axis curve the shape is extruded along.
+ * * The parameter `rotationFunction` (JS function) is a custom Javascript function called on each path point. This function is passed the position i of the point in the path and the distance of this point from the beginning of the path
+ * * It must returns a float value that will be the rotation in radians applied to the shape on each path point.
+ * * The parameter `scaleFunction` (JS function) is a custom Javascript function called on each path point. This function is passed the position i of the point in the path and the distance of this point from the beginning of the path
+ * * It must returns a float value that will be the scale value applied to the shape on each path point
+ * * The parameter `closeShape` (boolean, default false) closes the shape when true, since v5.0.0.
+ * * The parameter `closePath` (boolean, default false) closes the path when true and no caps, since v5.0.0.
+ * * The parameter `ribbonClosePath` (boolean, default false) forces the extrusion underlying ribbon to close all the paths in its `pathArray` - depreciated in favor of closeShape
+ * * The parameter `ribbonCloseArray` (boolean, default false) forces the extrusion underlying ribbon to close its `pathArray` - depreciated in favor of closePath
+ * * The parameter `cap` sets the way the extruded shape is capped. Possible values : BABYLON.Mesh.NO_CAP (default), BABYLON.Mesh.CAP_START, BABYLON.Mesh.CAP_END, BABYLON.Mesh.CAP_ALL
+ * * The optional parameter `instance` is an instance of an existing ExtrudedShape object to be updated with the passed `shape`, `path`, `scale` or `rotation` parameters : https://doc.babylonjs.com/how_to/how_to_dynamically_morph_a_mesh#extruded-shape
+ * * Remember you can only change the shape or path point positions, not their number when updating an extruded shape
+ * * You can also set the mesh side orientation with the values : BABYLON.Mesh.FRONTSIDE (default), BABYLON.Mesh.BACKSIDE or BABYLON.Mesh.DOUBLESIDE
+ * * If you create a double-sided mesh, you can choose what parts of the texture image to crop and stick respectively on the front and the back sides with the parameters `frontUVs` and `backUVs` (Vector4). Detail here : https://doc.babylonjs.com/babylon101/discover_basic_elements#side-orientation
+ * * The optional parameter `invertUV` (boolean, default false) swaps in the geometry the U and V coordinates to apply a texture
+ * * The mesh can be set to updatable with the boolean parameter `updatable` (default false) if its internal geometry is supposed to change once created
+ * * The optional parameter `firstNormal` (Vector3) defines the direction of the first normal of the supplied path. It should be supplied when the path is in the xy plane, and particularly if these sections are straight, because the underlying Path3D object will pick a normal in the xy plane that causes the extrusion to be collapsed into the plane. This should be used for any path that is straight.
+ * * The optional `adjustFrame` (boolean, default false) will cause the internally generated Path3D tangents, normals, and binormals to be adjusted so that a) they are always well-defined, and b) they do not reverse from one path point to the next. This prevents the extruded shape from being flipped and/or rotated with resulting mesh self-intersections. This is primarily useful for straight paths that can reverse direction.
+ * @param name defines the name of the mesh
+ * @param options defines the options used to create the mesh
+ * @param options.shape
+ * @param options.path
+ * @param options.scaleFunction
+ * @param options.rotationFunction
+ * @param options.ribbonCloseArray
+ * @param options.ribbonClosePath
+ * @param options.closeShape
+ * @param options.closePath
+ * @param options.cap
+ * @param options.updatable
+ * @param options.sideOrientation
+ * @param options.frontUVs
+ * @param options.backUVs
+ * @param options.instance
+ * @param options.invertUV
+ * @param options.firstNormal
+ * @param options.adjustFrame
+ * @param scene defines the hosting scene
+ * @returns the custom extruded shape mesh
+ * @see https://doc.babylonjs.com/how_to/parametric_shapes#custom-extruded-shapes
+ * @see https://doc.babylonjs.com/how_to/parametric_shapes
+ * @see https://doc.babylonjs.com/how_to/parametric_shapes#extruded-shapes
+ */
+export function ExtrudeShapeCustom(name: any, options: any, scene?: null): any;
+export namespace ShapeBuilder {
+    export { ExtrudeShape };
+    export { ExtrudeShapeCustom };
+}

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

@@ -0,0 +1,60 @@
+/**
+ * Creates the VertexData for an ellipsoid, defaults to a sphere
+ * @param options an object used to set the following optional parameters for the box, required but can be empty
+ * * segments sets the number of horizontal strips optional, default 32
+ * * diameter sets the axes dimensions, diameterX, diameterY and diameterZ to the value of diameter, optional default 1
+ * * diameterX sets the diameterX (x direction) of the ellipsoid, overwrites the diameterX set by diameter, optional, default diameter
+ * * diameterY sets the diameterY (y direction) of the ellipsoid, overwrites the diameterY set by diameter, optional, default diameter
+ * * diameterZ sets the diameterZ (z direction) of the ellipsoid, overwrites the diameterZ set by diameter, optional, default diameter
+ * * arc a number from 0 to 1, to create an unclosed ellipsoid based on the fraction of the circumference (latitude) given by the arc value, optional, default 1
+ * * slice a number from 0 to 1, to create an unclosed ellipsoid based on the fraction of the height (latitude) given by the arc value, optional, default 1
+ * * sideOrientation optional and takes the values : Mesh.FRONTSIDE (default), Mesh.BACKSIDE or Mesh.DOUBLESIDE
+ * * frontUvs only usable when you create a double-sided mesh, used to choose what parts of the texture image to crop and apply on the front side, optional, default vector4 (0, 0, 1, 1)
+ * * backUVs only usable when you create a double-sided mesh, used to choose what parts of the texture image to crop and apply on the back side, optional, default vector4 (0, 0, 1, 1)
+ * @param options.segments
+ * @param options.diameter
+ * @param options.diameterX
+ * @param options.diameterY
+ * @param options.diameterZ
+ * @param options.arc
+ * @param options.slice
+ * @param options.sideOrientation
+ * @param options.frontUVs
+ * @param options.backUVs
+ * @param options.dedupTopBottomIndices
+ * @returns the VertexData of the ellipsoid
+ */
+export function CreateSphereVertexData(options: any): VertexData;
+/**
+ * Creates a sphere mesh
+ * * The parameter `diameter` sets the diameter size (float) of the sphere (default 1)
+ * * You can set some different sphere dimensions, for instance to build an ellipsoid, by using the parameters `diameterX`, `diameterY` and `diameterZ` (all by default have the same value of `diameter`)
+ * * The parameter `segments` sets the sphere number of horizontal stripes (positive integer, default 32)
+ * * You can create an unclosed sphere with the parameter `arc` (positive float, default 1), valued between 0 and 1, what is the ratio of the circumference (latitude) : 2 x PI x ratio
+ * * You can create an unclosed sphere on its height with the parameter `slice` (positive float, default1), valued between 0 and 1, what is the height ratio (longitude)
+ * * You can also set the mesh side orientation with the values : BABYLON.Mesh.FRONTSIDE (default), BABYLON.Mesh.BACKSIDE or BABYLON.Mesh.DOUBLESIDE
+ * * If you create a double-sided mesh, you can choose what parts of the texture image to crop and stick respectively on the front and the back sides with the parameters `frontUVs` and `backUVs` (Vector4). Detail here : https://doc.babylonjs.com/babylon101/discover_basic_elements#side-orientation
+ * * The mesh can be set to updatable with the boolean parameter `updatable` (default false) if its internal geometry is supposed to change once created
+ * @param name defines the name of the mesh
+ * @param options defines the options used to create the mesh
+ * @param options.segments
+ * @param options.diameter
+ * @param options.diameterX
+ * @param options.diameterY
+ * @param options.diameterZ
+ * @param options.arc
+ * @param options.slice
+ * @param options.sideOrientation
+ * @param options.frontUVs
+ * @param options.backUVs
+ * @param options.updatable
+ * @param scene defines the hosting scene
+ * @returns the sphere mesh
+ * @see https://doc.babylonjs.com/how_to/set_shapes#sphere
+ */
+export function CreateSphere(name: any, options?: {}, scene?: null): Mesh;
+export namespace SphereBuilder {
+    export { CreateSphere };
+}
+import { VertexData } from "../mesh.vertexData.js";
+import { Mesh } from "../mesh.js";

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

@@ -0,0 +1,73 @@
+/**
+ * Creates the VertexData for a tiled box
+ * @see https://doc.babylonjs.com/divingDeeper/mesh/creation/set/tiled_box
+ * @param options an object used to set the following optional parameters for the tiled box, required but can be empty
+ * * pattern sets the rotation or reflection pattern for the tiles,
+ * * size of the box
+ * * width of the box, overwrites size
+ * * height of the box, overwrites size
+ * * depth of the box, overwrites size
+ * * tileSize sets the size of a tile
+ * * tileWidth sets the tile width and overwrites tileSize
+ * * tileHeight sets the tile width and overwrites tileSize
+ * * faceUV an array of 6 Vector4 elements used to set different images to each box side
+ * * faceColors an array of 6 Color3 elements used to set different colors to each box side
+ * * alignHorizontal places whole tiles aligned to the center, left or right of a row
+ * * alignVertical places whole tiles aligned to the center, left or right of a column
+ * @param options.pattern
+ * @param options.size
+ * @param options.width
+ * @param options.height
+ * @param options.depth
+ * @param options.tileSize
+ * @param options.tileWidth
+ * @param options.tileHeight
+ * @param options.faceUV
+ * @param options.faceColors
+ * @param options.alignHorizontal
+ * @param options.alignVertical
+ * @param options.sideOrientation
+ * * sideOrientation optional and takes the values : Mesh.FRONTSIDE (default), Mesh.BACKSIDE or Mesh.DOUBLESIDE
+ * @returns the VertexData of the TiledBox
+ */
+export function CreateTiledBoxVertexData(options: any): VertexData;
+/**
+ * Creates a tiled box mesh
+ * @see https://doc.babylonjs.com/divingDeeper/mesh/creation/set/tiled_box
+ * @param name defines the name of the mesh
+ * @param options an object used to set the following optional parameters for the tiled box, required but can be empty
+ * * pattern sets the rotation or reflection pattern for the tiles,
+ * * size of the box
+ * * width of the box, overwrites size
+ * * height of the box, overwrites size
+ * * depth of the box, overwrites size
+ * * tileSize sets the size of a tile
+ * * tileWidth sets the tile width and overwrites tileSize
+ * * tileHeight sets the tile width and overwrites tileSize
+ * * faceUV an array of 6 Vector4 elements used to set different images to each box side
+ * * faceColors an array of 6 Color3 elements used to set different colors to each box side
+ * * alignHorizontal places whole tiles aligned to the center, left or right of a row
+ * * alignVertical places whole tiles aligned to the center, left or right of a column
+ * * sideOrientation optional and takes the values : Mesh.FRONTSIDE (default), Mesh.BACKSIDE or Mesh.DOUBLESIDE
+ * @param options.pattern
+ * @param options.width
+ * @param options.height
+ * @param options.depth
+ * @param options.tileSize
+ * @param options.tileWidth
+ * @param options.tileHeight
+ * @param options.alignHorizontal
+ * @param options.alignVertical
+ * @param options.faceUV
+ * @param options.faceColors
+ * @param options.sideOrientation
+ * @param options.updatable
+ * @param scene defines the hosting scene
+ * @returns the box mesh
+ */
+export function CreateTiledBox(name: any, options: any, scene?: null): Mesh;
+export namespace TiledBoxBuilder {
+    export { CreateTiledBox };
+}
+import { VertexData } from "../mesh.vertexData.js";
+import { Mesh } from "../mesh.js";

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

@@ -0,0 +1,70 @@
+/**
+ * Creates the VertexData for a tiled plane
+ * @see https://doc.babylonjs.com/divingDeeper/mesh/creation/set/tiled_plane
+ * @param options an object used to set the following optional parameters for the tiled plane, required but can be empty
+ * * pattern a limited pattern arrangement depending on the number
+ * * size of the box
+ * * width of the box, overwrites size
+ * * height of the box, overwrites size
+ * * tileSize sets the width, height and depth of the tile to the value of size, optional default 1
+ * * tileWidth sets the width (x direction) of the tile, overwrites the width set by size, optional, default size
+ * * tileHeight sets the height (y direction) of the tile, overwrites the height set by size, optional, default size
+ * * sideOrientation optional and takes the values : Mesh.FRONTSIDE (default), Mesh.BACKSIDE or Mesh.DOUBLESIDE
+ * * alignHorizontal places whole tiles aligned to the center, left or right of a row
+ * * alignVertical places whole tiles aligned to the center, left or right of a column
+ * * frontUvs only usable when you create a double-sided mesh, used to choose what parts of the texture image to crop and apply on the front side, optional, default vector4 (0, 0, 1, 1)
+ * @param options.pattern
+ * @param options.tileSize
+ * @param options.tileWidth
+ * @param options.tileHeight
+ * @param options.size
+ * @param options.width
+ * @param options.height
+ * @param options.alignHorizontal
+ * @param options.alignVertical
+ * @param options.sideOrientation
+ * @param options.frontUVs
+ * @param options.backUVs
+ * * backUVs only usable when you create a double-sided mesh, used to choose what parts of the texture image to crop and apply on the back side, optional, default vector4 (0, 0, 1, 1)
+ * @returns the VertexData of the tiled plane
+ */
+export function CreateTiledPlaneVertexData(options: any): VertexData;
+/**
+ * Creates a tiled plane mesh
+ * @see https://doc.babylonjs.com/divingDeeper/mesh/creation/set/tiled_plane
+ * @param name defines the name of the mesh
+ * @param options an object used to set the following optional parameters for the tiled plane, required but can be empty
+ * * pattern a limited pattern arrangement depending on the number
+ * * size of the box
+ * * width of the box, overwrites size
+ * * height of the box, overwrites size
+ * * tileSize sets the width, height and depth of the tile to the value of size, optional default 1
+ * * tileWidth sets the width (x direction) of the tile, overwrites the width set by size, optional, default size
+ * * tileHeight sets the height (y direction) of the tile, overwrites the height set by size, optional, default size
+ * * sideOrientation optional and takes the values : Mesh.FRONTSIDE (default), Mesh.BACKSIDE or Mesh.DOUBLESIDE
+ * * alignHorizontal places whole tiles aligned to the center, left or right of a row
+ * * alignVertical places whole tiles aligned to the center, left or right of a column
+ * * frontUvs only usable when you create a double-sided mesh, used to choose what parts of the texture image to crop and apply on the front side, optional, default vector4 (0, 0, 1, 1)
+ * * backUVs only usable when you create a double-sided mesh, used to choose what parts of the texture image to crop and apply on the back side, optional, default vector4 (0, 0, 1, 1)
+ * @param options.pattern
+ * @param options.tileSize
+ * @param options.tileWidth
+ * @param options.tileHeight
+ * @param options.size
+ * @param options.width
+ * @param options.height
+ * @param options.alignHorizontal
+ * @param options.alignVertical
+ * @param options.sideOrientation
+ * @param options.frontUVs
+ * @param options.backUVs
+ * @param options.updatable
+ * @param scene defines the hosting scene
+ * @returns the box mesh
+ */
+export function CreateTiledPlane(name: any, options: any, scene?: null): Mesh;
+export namespace TiledPlaneBuilder {
+    export { CreateTiledPlane };
+}
+import { VertexData } from "../mesh.vertexData.js";
+import { Mesh } from "../mesh.js";

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

@@ -0,0 +1,45 @@
+/**
+ * Creates the VertexData for a torus
+ * @param options an object used to set the following optional parameters for the box, required but can be empty
+ * * diameter the diameter of the torus, optional default 1
+ * * thickness the diameter of the tube forming the torus, optional default 0.5
+ * * tessellation the number of prism sides, 3 for a triangular prism, optional, default 24
+ * * sideOrientation optional and takes the values : Mesh.FRONTSIDE (default), Mesh.BACKSIDE or Mesh.DOUBLESIDE
+ * * frontUvs only usable when you create a double-sided mesh, used to choose what parts of the texture image to crop and apply on the front side, optional, default vector4 (0, 0, 1, 1)
+ * * backUVs only usable when you create a double-sided mesh, used to choose what parts of the texture image to crop and apply on the back side, optional, default vector4 (0, 0, 1, 1)
+ * @param options.diameter
+ * @param options.thickness
+ * @param options.tessellation
+ * @param options.sideOrientation
+ * @param options.frontUVs
+ * @param options.backUVs
+ * @returns the VertexData of the torus
+ */
+export function CreateTorusVertexData(options: any): VertexData;
+/**
+ * Creates a torus mesh
+ * * The parameter `diameter` sets the diameter size (float) of the torus (default 1)
+ * * The parameter `thickness` sets the diameter size of the tube of the torus (float, default 0.5)
+ * * The parameter `tessellation` sets the number of torus sides (positive integer, default 16)
+ * * You can also set the mesh side orientation with the values : BABYLON.Mesh.FRONTSIDE (default), BABYLON.Mesh.BACKSIDE or BABYLON.Mesh.DOUBLESIDE
+ * * If you create a double-sided mesh, you can choose what parts of the texture image to crop and stick respectively on the front and the back sides with the parameters `frontUVs` and `backUVs` (Vector4). Detail here : https://doc.babylonjs.com/babylon101/discover_basic_elements#side-orientation
+ * * The mesh can be set to updatable with the boolean parameter `updatable` (default false) if its internal geometry is supposed to change once created.
+ * @param name defines the name of the mesh
+ * @param options defines the options used to create the mesh
+ * @param options.diameter
+ * @param options.thickness
+ * @param options.tessellation
+ * @param options.updatable
+ * @param options.sideOrientation
+ * @param options.frontUVs
+ * @param options.backUVs
+ * @param scene defines the hosting scene
+ * @returns the torus mesh
+ * @see https://doc.babylonjs.com/how_to/set_shapes#torus
+ */
+export function CreateTorus(name: any, options: {} | undefined, scene: any): Mesh;
+export namespace TorusBuilder {
+    export { CreateTorus };
+}
+import { VertexData } from "../mesh.vertexData.js";
+import { Mesh } from "../mesh.js";

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

@@ -0,0 +1,55 @@
+/**
+ * Creates the VertexData for a TorusKnot
+ * @param options an object used to set the following optional parameters for the TorusKnot, required but can be empty
+ * * radius the radius of the torus knot, optional, default 2
+ * * tube the thickness of the tube, optional, default 0.5
+ * * radialSegments the number of sides on each tube segments, optional, default 32
+ * * tubularSegments the number of tubes to decompose the knot into, optional, default 32
+ * * p the number of windings around the z axis, optional,  default 2
+ * * q the number of windings around the x axis, optional,  default 3
+ * * sideOrientation optional and takes the values : Mesh.FRONTSIDE (default), Mesh.BACKSIDE or Mesh.DOUBLESIDE
+ * * frontUvs only usable when you create a double-sided mesh, used to choose what parts of the texture image to crop and apply on the front side, optional, default vector4 (0, 0, 1, 1)
+ * * backUVs only usable when you create a double-sided mesh, used to choose what parts of the texture image to crop and apply on the back side, optional, default vector4 (0, 0, 1, 1)
+ * @param options.radius
+ * @param options.tube
+ * @param options.radialSegments
+ * @param options.tubularSegments
+ * @param options.p
+ * @param options.q
+ * @param options.sideOrientation
+ * @param options.frontUVs
+ * @param options.backUVs
+ * @returns the VertexData of the Torus Knot
+ */
+export function CreateTorusKnotVertexData(options: any): VertexData;
+/**
+ * Creates a torus knot mesh
+ * * The parameter `radius` sets the global radius size (float) of the torus knot (default 2)
+ * * The parameter `radialSegments` sets the number of sides on each tube segments (positive integer, default 32)
+ * * The parameter `tubularSegments` sets the number of tubes to decompose the knot into (positive integer, default 32)
+ * * The parameters `p` and `q` are the number of windings on each axis (positive integers, default 2 and 3)
+ * * You can also set the mesh side orientation with the values : BABYLON.Mesh.FRONTSIDE (default), BABYLON.Mesh.BACKSIDE or BABYLON.Mesh.DOUBLESIDE
+ * * If you create a double-sided mesh, you can choose what parts of the texture image to crop and stick respectively on the front and the back sides with the parameters `frontUVs` and `backUVs` (Vector4). Detail here : https://doc.babylonjs.com/babylon101/discover_basic_elements#side-orientation
+ * * The mesh can be set to updatable with the boolean parameter `updatable` (default false) if its internal geometry is supposed to change once created.
+ * @param name defines the name of the mesh
+ * @param options defines the options used to create the mesh
+ * @param options.radius
+ * @param options.tube
+ * @param options.radialSegments
+ * @param options.tubularSegments
+ * @param options.p
+ * @param options.q
+ * @param options.updatable
+ * @param options.sideOrientation
+ * @param options.frontUVs
+ * @param options.backUVs
+ * @param scene defines the hosting scene
+ * @returns the torus knot mesh
+ * @see  https://doc.babylonjs.com/how_to/set_shapes#torus-knot
+ */
+export function CreateTorusKnot(name: any, options: {} | undefined, scene: any): Mesh;
+export namespace TorusKnotBuilder {
+    export { CreateTorusKnot };
+}
+import { VertexData } from "../mesh.vertexData.js";
+import { Mesh } from "../mesh.js";

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

@@ -0,0 +1,38 @@
+/**
+ * Creates a tube mesh.
+ * The tube is a parametric shape. It has no predefined shape. Its final shape will depend on the input parameters
+ * * The parameter `path` is a required array of successive Vector3. It is the curve used as the axis of the tube
+ * * The parameter `radius` (positive float, default 1) sets the tube radius size
+ * * The parameter `tessellation` (positive float, default 64) is the number of sides on the tubular surface
+ * * The parameter `radiusFunction` (javascript function, default null) is a vanilla javascript function. If it is not null, it overrides the parameter `radius`
+ * * This function is called on each point of the tube path and is passed the index `i` of the i-th point and the distance of this point from the first point of the path. It must return a radius value (positive float)
+ * * The parameter `arc` (positive float, maximum 1, default 1) is the ratio to apply to the tube circumference : 2 x PI x arc
+ * * The parameter `cap` sets the way the extruded shape is capped. Possible values : BABYLON.Mesh.NO_CAP (default), BABYLON.Mesh.CAP_START, BABYLON.Mesh.CAP_END, BABYLON.Mesh.CAP_ALL
+ * * The optional parameter `instance` is an instance of an existing Tube object to be updated with the passed `pathArray` parameter. The `path`Array HAS to have the SAME number of points as the previous one: https://doc.babylonjs.com/how_to/how_to_dynamically_morph_a_mesh#tube
+ * * You can also set the mesh side orientation with the values : BABYLON.Mesh.FRONTSIDE (default), BABYLON.Mesh.BACKSIDE or BABYLON.Mesh.DOUBLESIDE
+ * * If you create a double-sided mesh, you can choose what parts of the texture image to crop and stick respectively on the front and the back sides with the parameters `frontUVs` and `backUVs` (Vector4). Detail here : https://doc.babylonjs.com/babylon101/discover_basic_elements#side-orientation
+ * * The optional parameter `invertUV` (boolean, default false) swaps in the geometry the U and V coordinates to apply a texture
+ * * The mesh can be set to updatable with the boolean parameter `updatable` (default false) if its internal geometry is supposed to change once created. The NUMBER of points CAN'T CHANGE, only their positions.
+ * @param name defines the name of the mesh
+ * @param options defines the options used to create the mesh
+ * @param options.path
+ * @param options.radius
+ * @param options.tessellation
+ * @param options.radiusFunction
+ * @param options.cap
+ * @param options.arc
+ * @param options.updatable
+ * @param options.sideOrientation
+ * @param options.frontUVs
+ * @param options.backUVs
+ * @param options.instance
+ * @param options.invertUV
+ * @param scene defines the hosting scene
+ * @returns the tube mesh
+ * @see https://doc.babylonjs.com/how_to/parametric_shapes
+ * @see https://doc.babylonjs.com/how_to/set_shapes#tube
+ */
+export function CreateTube(name: any, options: any, scene?: null): any;
+export namespace TubeBuilder {
+    export { CreateTube };
+}

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

@@ -0,0 +1,82 @@
+/**
+ * Draco compression (https://google.github.io/draco/)
+ *
+ * This class wraps the Draco module.
+ *
+ * **Encoder**
+ *
+ * The encoder is not currently implemented.
+ *
+ * **Decoder**
+ *
+ * By default, the configuration points to a copy of the Draco decoder files for glTF from the babylon.js preview cdn https://preview.babylonjs.com/draco_wasm_wrapper_gltf.js.
+ *
+ * To update the configuration, use the following code:
+ * ```javascript
+ *     DracoCompression.Configuration = {
+ *         decoder: {
+ *             wasmUrl: "<url to the WebAssembly library>",
+ *             wasmBinaryUrl: "<url to the WebAssembly binary>",
+ *             fallbackUrl: "<url to the fallback JavaScript library>",
+ *         }
+ *     };
+ * ```
+ *
+ * Draco has two versions, one for WebAssembly and one for JavaScript. The decoder configuration can be set to only support WebAssembly or only support the JavaScript version.
+ * Decoding will automatically fallback to the JavaScript version if WebAssembly version is not configured or if WebAssembly is not supported by the browser.
+ * Use `DracoCompression.DecoderAvailable` to determine if the decoder configuration is available for the current context.
+ *
+ * To decode Draco compressed data, get the default DracoCompression object and call decodeMeshAsync:
+ * ```javascript
+ *     var vertexData = await DracoCompression.Default.decodeMeshAsync(data);
+ * ```
+ *
+ * @see https://playground.babylonjs.com/#DMZIBD#0
+ */
+export class DracoCompression {
+    /**
+     * Returns true if the decoder configuration is available.
+     */
+    static get DecoderAvailable(): boolean;
+    static GetDefaultNumWorkers(): number;
+    /**
+     * Default instance for the draco compression object.
+     */
+    static get Default(): any;
+    /**
+     * Constructor
+     * @param numWorkers The number of workers for async operations. Specify `0` to disable web workers and run synchronously in the current context.
+     */
+    constructor(numWorkers?: number);
+    _workerPoolPromise: Promise<AutoReleaseWorkerPool> | undefined;
+    _decoderModulePromise: Promise<any> | undefined;
+    /**
+     * Stop all async operations and release resources.
+     */
+    dispose(): void;
+    /**
+     * Returns a promise that resolves when ready. Call this manually to ensure draco compression is ready before use.
+     * @returns a promise that resolves when ready
+     */
+    whenReadyAsync(): Promise<void>;
+    /**
+     * Decode Draco compressed mesh data to vertex data.
+     * @param data The ArrayBuffer or ArrayBufferView for the Draco compression data
+     * @param attributes A map of attributes from vertex buffer kinds to Draco unique ids
+     * @param dividers a list of optional dividers for normalization
+     * @returns A promise that resolves with the decoded vertex data
+     */
+    decodeMeshAsync(data: any, attributes: any, dividers: any): Promise<any>;
+}
+export namespace DracoCompression {
+    namespace Configuration {
+        namespace decoder {
+            const wasmUrl: string;
+            const wasmBinaryUrl: string;
+            const fallbackUrl: string;
+        }
+    }
+    const DefaultNumWorkers: number;
+    const _Default: any;
+}
+import { AutoReleaseWorkerPool } from "../../Misc/workerPool.js";

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

@@ -0,0 +1,2 @@
+export * from "./dracoCompression.js";
+export * from "./meshoptCompression.js";

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

@@ -0,0 +1,52 @@
+/**
+ * Meshopt compression (https://github.com/zeux/meshoptimizer)
+ *
+ * This class wraps the meshopt library from https://github.com/zeux/meshoptimizer/tree/master/js.
+ *
+ * **Encoder**
+ *
+ * The encoder is not currently implemented.
+ *
+ * **Decoder**
+ *
+ * By default, the configuration points to a copy of the meshopt files on the Babylon.js preview CDN (e.g. https://preview.babylonjs.com/meshopt_decoder.js).
+ *
+ * To update the configuration, use the following code:
+ * ```javascript
+ *     MeshoptCompression.Configuration = {
+ *         decoder: {
+ *             url: "<url to the meshopt decoder library>"
+ *         }
+ *     };
+ * ```
+ */
+export class MeshoptCompression {
+    /**
+     * Default instance for the meshoptimizer object.
+     */
+    static get Default(): any;
+    _decoderModulePromise: Promise<any>;
+    /**
+     * Stop all async operations and release resources.
+     */
+    dispose(): void;
+    /**
+     * Decode meshopt data.
+     * @see https://github.com/zeux/meshoptimizer/tree/master/js#decoder
+     * @param source The input data.
+     * @param count The number of elements.
+     * @param stride The stride in bytes.
+     * @param mode The compression mode.
+     * @param filter The compression filter.
+     * @returns a Promise<Uint8Array> that resolves to the decoded data
+     */
+    decodeGltfBufferAsync(source: any, count: any, stride: any, mode: any, filter: any): Promise<Uint8Array>;
+}
+export namespace MeshoptCompression {
+    namespace Configuration {
+        namespace decoder {
+            const url: string;
+        }
+    }
+    const _Default: any;
+}

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

@@ -0,0 +1,6 @@
+/** @internal */
+export class WebGLDataBuffer extends DataBuffer {
+    constructor(resource: any);
+    _buffer: any;
+}
+import { DataBuffer } from "../../Buffers/dataBuffer.js";

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

@@ -0,0 +1,6 @@
+/** @internal */
+export class WebGPUDataBuffer extends DataBuffer {
+    constructor(resource: any);
+    _buffer: any;
+}
+import { DataBuffer } from "../../Buffers/dataBuffer.js";