@combeenation/3d-viewer 0.0.1-types

package/dist/types/node_modules/@babylonjs/core/Maths/math.frustum.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Represents a camera frustum
+ */
+export class Frustum {
+    /**
+     * Gets the planes representing the frustum
+     * @param transform matrix to be applied to the returned planes
+     * @returns a new array of 6 Frustum planes computed by the given transformation matrix.
+     */
+    static GetPlanes(transform: any): Plane[];
+    /**
+     * Gets the near frustum plane transformed by the transform matrix
+     * @param transform transformation matrix to be applied to the resulting frustum plane
+     * @param frustumPlane the resulting frustum plane
+     */
+    static GetNearPlaneToRef(transform: any, frustumPlane: any): void;
+    /**
+     * Gets the far frustum plane transformed by the transform matrix
+     * @param transform transformation matrix to be applied to the resulting frustum plane
+     * @param frustumPlane the resulting frustum plane
+     */
+    static GetFarPlaneToRef(transform: any, frustumPlane: any): void;
+    /**
+     * Gets the left frustum plane transformed by the transform matrix
+     * @param transform transformation matrix to be applied to the resulting frustum plane
+     * @param frustumPlane the resulting frustum plane
+     */
+    static GetLeftPlaneToRef(transform: any, frustumPlane: any): void;
+    /**
+     * Gets the right frustum plane transformed by the transform matrix
+     * @param transform transformation matrix to be applied to the resulting frustum plane
+     * @param frustumPlane the resulting frustum plane
+     */
+    static GetRightPlaneToRef(transform: any, frustumPlane: any): void;
+    /**
+     * Gets the top frustum plane transformed by the transform matrix
+     * @param transform transformation matrix to be applied to the resulting frustum plane
+     * @param frustumPlane the resulting frustum plane
+     */
+    static GetTopPlaneToRef(transform: any, frustumPlane: any): void;
+    /**
+     * Gets the bottom frustum plane transformed by the transform matrix
+     * @param transform transformation matrix to be applied to the resulting frustum plane
+     * @param frustumPlane the resulting frustum plane
+     */
+    static GetBottomPlaneToRef(transform: any, frustumPlane: any): void;
+    /**
+     * Sets the given array "frustumPlanes" with the 6 Frustum planes computed by the given transformation matrix.
+     * @param transform transformation matrix to be applied to the resulting frustum planes
+     * @param frustumPlanes the resulting frustum planes
+     */
+    static GetPlanesToRef(transform: any, frustumPlanes: any): void;
+}
+import { Plane } from "./math.plane.js";

package/dist/types/node_modules/@babylonjs/core/Maths/math.functions.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Extracts minimum and maximum values from a list of indexed positions
+ * @param positions defines the positions to use
+ * @param indices defines the indices to the positions
+ * @param indexStart defines the start index
+ * @param indexCount defines the end index
+ * @param bias defines bias value to add to the result
+ * @returns minimum and maximum values
+ */
+export function extractMinAndMaxIndexed(positions: any, indices: any, indexStart: any, indexCount: any, bias?: null): {
+    minimum: Vector3;
+    maximum: Vector3;
+};
+/**
+ * Extracts minimum and maximum values from a list of positions
+ * @param positions defines the positions to use
+ * @param start defines the start index in the positions array
+ * @param count defines the number of positions to handle
+ * @param bias defines bias value to add to the result
+ * @param stride defines the stride size to use (distance between two positions in the positions array)
+ * @returns minimum and maximum values
+ */
+export function extractMinAndMax(positions: any, start: any, count: any, bias: null | undefined, stride: any): {
+    minimum: Vector3;
+    maximum: Vector3;
+};
+import { Vector3 } from "./math.vector.js";

package/dist/types/node_modules/@babylonjs/core/Maths/math.isovector.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Class representing an isovector a vector containing 2 INTEGER coordinates
+ * x axis is horizontal
+ * y axis is 60 deg counter clockwise from positive y axis
+ * @internal
+ */
+export class _IsoVector {
+    /**
+     * Gets a new IsoVector(0, 0)
+     * @returns a new IsoVector
+     */
+    static Zero(): _IsoVector;
+    /**
+     * Creates a new isovector from the given x and y coordinates
+     * @param x defines the first coordinate, must be an integer
+     * @param y defines the second coordinate, must be an integer
+     */
+    constructor(x?: number, y?: number);
+    x: number;
+    y: number;
+    /**
+     * Gets a new IsoVector copied from the IsoVector
+     * @returns a new IsoVector
+     */
+    clone(): _IsoVector;
+    /**
+     * Rotates one IsoVector 60 degrees counter clockwise about another
+     * Please note that this is an in place operation
+     * @param other an IsoVector a center of rotation
+     * @returns the rotated IsoVector
+     */
+    rotate60About(other: any): _IsoVector;
+    /**
+     * Rotates one IsoVector 60 degrees clockwise about another
+     * Please note that this is an in place operation
+     * @param other an IsoVector as center of rotation
+     * @returns the rotated IsoVector
+     */
+    rotateNeg60About(other: any): _IsoVector;
+    /**
+     * For an equilateral triangle OAB with O at isovector (0, 0) and A at isovector (m, n)
+     * Rotates one IsoVector 120 degrees counter clockwise about the center of the triangle
+     * Please note that this is an in place operation
+     * @param m integer a measure a Primary triangle of order (m, n) m > n
+     * @param n >= 0 integer a measure for a Primary triangle of order (m, n)
+     * @returns the rotated IsoVector
+     */
+    rotate120(m: any, n: any): _IsoVector;
+    /**
+     * For an equilateral triangle OAB with O at isovector (0, 0) and A at isovector (m, n)
+     * Rotates one IsoVector 120 degrees clockwise about the center of the triangle
+     * Please note that this is an in place operation
+     * @param m integer a measure a Primary triangle of order (m, n) m > n
+     * @param n >= 0 integer a measure for a Primary triangle of order (m, n)
+     * @returns the rotated IsoVector
+     */
+    rotateNeg120(m: any, n: any): _IsoVector;
+    /**
+     * Transforms an IsoVector to one in Cartesian 3D space based on an isovector
+     * @param origin an IsoVector
+     * @param isoGridSize
+     * @returns Point as a Vector3
+     */
+    toCartesianOrigin(origin: any, isoGridSize: any): Vector3;
+}
+import { Vector3 } from "./math.vector.js";

package/dist/types/node_modules/@babylonjs/core/Maths/math.like.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/node_modules/@babylonjs/core/Maths/math.path.d.ts

@@ -0,0 +1,398 @@
+/**
+ * Defines potential orientation for back face culling
+ */
+export const Orientation: any;
+/** Class used to represent a Bezier curve */
+export class BezierCurve {
+    /**
+     * Returns the cubic Bezier interpolated value (float) at "t" (float) from the given x1, y1, x2, y2 floats
+     * @param t defines the time
+     * @param x1 defines the left coordinate on X axis
+     * @param y1 defines the left coordinate on Y axis
+     * @param x2 defines the right coordinate on X axis
+     * @param y2 defines the right coordinate on Y axis
+     * @returns the interpolated value
+     */
+    static Interpolate(t: any, x1: any, y1: any, x2: any, y2: any): number;
+}
+/**
+ * Defines angle representation
+ */
+export class Angle {
+    /**
+     * Gets a new Angle object valued with the gradient angle, in radians, of the line joining two points
+     * @param a defines first point as the origin
+     * @param b defines point
+     * @returns a new Angle
+     */
+    static BetweenTwoPoints(a: any, b: any): Angle;
+    /**
+     * Gets a new Angle object from the given float in radians
+     * @param radians defines the angle value in radians
+     * @returns a new Angle
+     */
+    static FromRadians(radians: any): Angle;
+    /**
+     * Gets a new Angle object from the given float in degrees
+     * @param degrees defines the angle value in degrees
+     * @returns a new Angle
+     */
+    static FromDegrees(degrees: any): Angle;
+    /**
+     * Creates an Angle object of "radians" radians (float).
+     * @param radians the angle in radians
+     */
+    constructor(radians: any);
+    _radians: any;
+    /**
+     * Get value in degrees
+     * @returns the Angle value in degrees (float)
+     */
+    degrees(): number;
+    /**
+     * Get value in radians
+     * @returns the Angle value in radians (float)
+     */
+    radians(): any;
+}
+/**
+ * This represents an arc in a 2d space.
+ */
+export class Arc2 {
+    /**
+     * Creates an Arc object from the three given points : start, middle and end.
+     * @param startPoint Defines the start point of the arc
+     * @param midPoint Defines the middle point of the arc
+     * @param endPoint Defines the end point of the arc
+     */
+    constructor(startPoint: any, midPoint: any, endPoint: any);
+    startPoint: any;
+    midPoint: any;
+    endPoint: any;
+    centerPoint: Vector2;
+    radius: number;
+    startAngle: Angle;
+    orientation: any;
+    angle: Angle;
+}
+/**
+ * Represents a 2D path made up of multiple 2D points
+ */
+export class Path2 {
+    /**
+     * Creates a new path starting from an x and y position
+     * @param x starting x value
+     * @param y starting y value
+     * @returns a new Path2 starting at the coordinates (x, y).
+     */
+    static StartingAt(x: any, y: any): Path2;
+    /**
+     * Creates a Path2 object from the starting 2D coordinates x and y.
+     * @param x the starting points x value
+     * @param y the starting points y value
+     */
+    constructor(x: any, y: any);
+    _points: any[];
+    _length: number;
+    /**
+     * If the path start and end point are the same
+     */
+    closed: boolean;
+    /**
+     * Adds a new segment until the given coordinates (x, y) to the current Path2.
+     * @param x the added points x value
+     * @param y the added points y value
+     * @returns the updated Path2.
+     */
+    addLineTo(x: any, y: any): Path2;
+    /**
+     * Adds _numberOfSegments_ segments according to the arc definition (middle point coordinates, end point coordinates, the arc start point being the current Path2 last point) to the current Path2.
+     * @param midX middle point x value
+     * @param midY middle point y value
+     * @param endX end point x value
+     * @param endY end point y value
+     * @param numberOfSegments (default: 36)
+     * @returns the updated Path2.
+     */
+    addArcTo(midX: any, midY: any, endX: any, endY: any, numberOfSegments?: number): Path2;
+    /**
+     * Closes the Path2.
+     * @returns the Path2.
+     */
+    close(): Path2;
+    /**
+     * Gets the sum of the distance between each sequential point in the path
+     * @returns the Path2 total length (float).
+     */
+    length(): number;
+    /**
+     * Gets the points which construct the path
+     * @returns the Path2 internal array of points.
+     */
+    getPoints(): any[];
+    /**
+     * Retreives the point at the distance aways from the starting point
+     * @param normalizedLengthPosition the length along the path to retrieve the point from
+     * @returns a new Vector2 located at a percentage of the Path2 total length on this path.
+     */
+    getPointAtLengthPosition(normalizedLengthPosition: any): Vector2;
+}
+/**
+ * Represents a 3D path made up of multiple 3D points
+ * @see https://doc.babylonjs.com/divingDeeper/mesh/path3D
+ */
+export class Path3D {
+    /**
+     * new Path3D(path, normal, raw)
+     * Creates a Path3D. A Path3D is a logical math object, so not a mesh.
+     * please read the description in the tutorial : https://doc.babylonjs.com/how_to/how_to_use_path3d
+     * @param path an array of Vector3, the curve axis of the Path3D
+     * @param firstNormal (options) Vector3, the first wanted normal to the curve. Ex (0, 1, 0) for a vertical normal.
+     * @param raw (optional, default false) : boolean, if true the returned Path3D isn't normalized. Useful to depict path acceleration or speed.
+     * @param alignTangentsWithPath (optional, default false) : boolean, if true the tangents will be aligned with the path.
+     */
+    constructor(path: any, firstNormal: null | undefined, raw: any, alignTangentsWithPath?: boolean);
+    path: any;
+    _curve: any[];
+    _distances: any[];
+    _tangents: any[];
+    _normals: any[];
+    _binormals: any[];
+    _pointAtData: {
+        id: number;
+        point: Vector3;
+        previousPointArrayIndex: number;
+        position: number;
+        subPosition: number;
+        interpolateReady: boolean;
+        interpolationMatrix: Matrix;
+    };
+    _raw: any;
+    _alignTangentsWithPath: boolean;
+    /**
+     * Returns the Path3D array of successive Vector3 designing its curve.
+     * @returns the Path3D array of successive Vector3 designing its curve.
+     */
+    getCurve(): any[];
+    /**
+     * Returns the Path3D array of successive Vector3 designing its curve.
+     * @returns the Path3D array of successive Vector3 designing its curve.
+     */
+    getPoints(): any[];
+    /**
+     * @returns the computed length (float) of the path.
+     */
+    length(): any;
+    /**
+     * Returns an array populated with tangent vectors on each Path3D curve point.
+     * @returns an array populated with tangent vectors on each Path3D curve point.
+     */
+    getTangents(): any[];
+    /**
+     * Returns an array populated with normal vectors on each Path3D curve point.
+     * @returns an array populated with normal vectors on each Path3D curve point.
+     */
+    getNormals(): any[];
+    /**
+     * Returns an array populated with binormal vectors on each Path3D curve point.
+     * @returns an array populated with binormal vectors on each Path3D curve point.
+     */
+    getBinormals(): any[];
+    /**
+     * Returns an array populated with distances (float) of the i-th point from the first curve point.
+     * @returns an array populated with distances (float) of the i-th point from the first curve point.
+     */
+    getDistances(): any[];
+    /**
+     * Returns an interpolated point along this path
+     * @param position the position of the point along this path, from 0.0 to 1.0
+     * @returns a new Vector3 as the point
+     */
+    getPointAt(position: any): Vector3;
+    /**
+     * Returns the tangent vector of an interpolated Path3D curve point at the specified position along this path.
+     * @param position the position of the point along this path, from 0.0 to 1.0
+     * @param interpolated (optional, default false) : boolean, if true returns an interpolated tangent instead of the tangent of the previous path point.
+     * @returns a tangent vector corresponding to the interpolated Path3D curve point, if not interpolated, the tangent is taken from the precomputed tangents array.
+     */
+    getTangentAt(position: any, interpolated?: boolean): any;
+    /**
+     * Returns the tangent vector of an interpolated Path3D curve point at the specified position along this path.
+     * @param position the position of the point along this path, from 0.0 to 1.0
+     * @param interpolated (optional, default false) : boolean, if true returns an interpolated normal instead of the normal of the previous path point.
+     * @returns a normal vector corresponding to the interpolated Path3D curve point, if not interpolated, the normal is taken from the precomputed normals array.
+     */
+    getNormalAt(position: any, interpolated?: boolean): any;
+    /**
+     * Returns the binormal vector of an interpolated Path3D curve point at the specified position along this path.
+     * @param position the position of the point along this path, from 0.0 to 1.0
+     * @param interpolated (optional, default false) : boolean, if true returns an interpolated binormal instead of the binormal of the previous path point.
+     * @returns a binormal vector corresponding to the interpolated Path3D curve point, if not interpolated, the binormal is taken from the precomputed binormals array.
+     */
+    getBinormalAt(position: any, interpolated?: boolean): any;
+    /**
+     * Returns the distance (float) of an interpolated Path3D curve point at the specified position along this path.
+     * @param position the position of the point along this path, from 0.0 to 1.0
+     * @returns the distance of the interpolated Path3D curve point at the specified position along this path.
+     */
+    getDistanceAt(position: any): number;
+    /**
+     * Returns the array index of the previous point of an interpolated point along this path
+     * @param position the position of the point to interpolate along this path, from 0.0 to 1.0
+     * @returns the array index
+     */
+    getPreviousPointIndexAt(position: any): number;
+    /**
+     * Returns the position of an interpolated point relative to the two path points it lies between, from 0.0 (point A) to 1.0 (point B)
+     * @param position the position of the point to interpolate along this path, from 0.0 to 1.0
+     * @returns the sub position
+     */
+    getSubPositionAt(position: any): number;
+    /**
+     * Returns the position of the closest virtual point on this path to an arbitrary Vector3, from 0.0 to 1.0
+     * @param target the vector of which to get the closest position to
+     * @returns the position of the closest virtual point on this path to the target vector
+     */
+    getClosestPositionTo(target: any): number;
+    /**
+     * Returns a sub path (slice) of this path
+     * @param start the position of the fist path point, from 0.0 to 1.0, or a negative value, which will get wrapped around from the end of the path to 0.0 to 1.0 values
+     * @param end the position of the last path point, from 0.0 to 1.0, or a negative value, which will get wrapped around from the end of the path to 0.0 to 1.0 values
+     * @returns a sub path (slice) of this path
+     */
+    slice(start?: number, end?: number): Path3D;
+    /**
+     * Forces the Path3D tangent, normal, binormal and distance recomputation.
+     * @param path path which all values are copied into the curves points
+     * @param firstNormal which should be projected onto the curve
+     * @param alignTangentsWithPath (optional, default false) : boolean, if true the tangents will be aligned with the path
+     * @returns the same object updated.
+     */
+    update(path: any, firstNormal?: null, alignTangentsWithPath?: boolean): Path3D;
+    _compute(firstNormal: any, alignTangentsWithPath?: boolean): void;
+    _getFirstNonNullVector(index: any): any;
+    _getLastNonNullVector(index: any): any;
+    _normalVector(vt: any, va: any): Vector3;
+    /**
+     * Updates the point at data for an interpolated point along this curve
+     * @param position the position of the point along this curve, from 0.0 to 1.0
+     * @param interpolateTNB
+     * @interpolateTNB whether to compute the interpolated tangent, normal and binormal
+     * @returns the (updated) point at data
+     */
+    _updatePointAtData(position: any, interpolateTNB?: boolean): {
+        id: number;
+        point: Vector3;
+        previousPointArrayIndex: number;
+        position: number;
+        subPosition: number;
+        interpolateReady: boolean;
+        interpolationMatrix: Matrix;
+    };
+    /**
+     * Updates the point at data from the specified parameters
+     * @param position where along the path the interpolated point is, from 0.0 to 1.0
+     * @param subPosition
+     * @param point the interpolated point
+     * @param parentIndex the index of an existing curve point that is on, or else positionally the first behind, the interpolated point
+     * @param interpolateTNB
+     */
+    _setPointAtData(position: any, subPosition: any, point: any, parentIndex: any, interpolateTNB: any): {
+        id: number;
+        point: Vector3;
+        previousPointArrayIndex: number;
+        position: number;
+        subPosition: number;
+        interpolateReady: boolean;
+        interpolationMatrix: Matrix;
+    };
+    /**
+     * Updates the point at interpolation matrix for the tangents, normals and binormals
+     */
+    _updateInterpolationMatrix(): void;
+}
+/**
+ * A Curve3 object is a logical object, so not a mesh, to handle curves in the 3D geometric space.
+ * A Curve3 is designed from a series of successive Vector3.
+ * @see https://doc.babylonjs.com/how_to/how_to_use_curve3
+ */
+export class Curve3 {
+    /**
+     * Returns a Curve3 object along a Quadratic Bezier curve : https://doc.babylonjs.com/how_to/how_to_use_curve3#quadratic-bezier-curve
+     * @param v0 (Vector3) the origin point of the Quadratic Bezier
+     * @param v1 (Vector3) the control point
+     * @param v2 (Vector3) the end point of the Quadratic Bezier
+     * @param nbPoints (integer) the wanted number of points in the curve
+     * @returns the created Curve3
+     */
+    static CreateQuadraticBezier(v0: any, v1: any, v2: any, nbPoints: any): Curve3;
+    /**
+     * Returns a Curve3 object along a Cubic Bezier curve : https://doc.babylonjs.com/how_to/how_to_use_curve3#cubic-bezier-curve
+     * @param v0 (Vector3) the origin point of the Cubic Bezier
+     * @param v1 (Vector3) the first control point
+     * @param v2 (Vector3) the second control point
+     * @param v3 (Vector3) the end point of the Cubic Bezier
+     * @param nbPoints (integer) the wanted number of points in the curve
+     * @returns the created Curve3
+     */
+    static CreateCubicBezier(v0: any, v1: any, v2: any, v3: any, nbPoints: any): Curve3;
+    /**
+     * Returns a Curve3 object along a Hermite Spline curve : https://doc.babylonjs.com/how_to/how_to_use_curve3#hermite-spline
+     * @param p1 (Vector3) the origin point of the Hermite Spline
+     * @param t1 (Vector3) the tangent vector at the origin point
+     * @param p2 (Vector3) the end point of the Hermite Spline
+     * @param t2 (Vector3) the tangent vector at the end point
+     * @param nbPoints (integer) the wanted number of points in the curve
+     * @returns the created Curve3
+     */
+    static CreateHermiteSpline(p1: any, t1: any, p2: any, t2: any, nbPoints: any): Curve3;
+    /**
+     * Returns a Curve3 object along a CatmullRom Spline curve :
+     * @param points (array of Vector3) the points the spline must pass through. At least, four points required
+     * @param nbPoints (integer) the wanted number of points between each curve control points
+     * @param closed (boolean) optional with default false, when true forms a closed loop from the points
+     * @returns the created Curve3
+     */
+    static CreateCatmullRomSpline(points: any, nbPoints: any, closed: any): Curve3;
+    /**
+     * Returns a Curve3 object along an arc through three vector3 points:
+     * The three points should not be colinear. When they are the Curve3 is empty.
+     * @param first (Vector3) the first point the arc must pass through.
+     * @param second (Vector3) the second point the arc must pass through.
+     * @param third (Vector3) the third point the arc must pass through.
+     * @param steps (number) the larger the number of steps the more detailed the arc.
+     * @param closed (boolean) optional with default false, when true forms the chord from the first and third point
+     * @param fullCircle Circle (boolean) optional with default false, when true forms the complete circle through the three points
+     * @returns the created Curve3
+     */
+    static ArcThru3Points(first: any, second: any, third: any, steps?: number, closed?: boolean, fullCircle?: boolean): Curve3;
+    /**
+     * A Curve3 object is a logical object, so not a mesh, to handle curves in the 3D geometric space.
+     * A Curve3 is designed from a series of successive Vector3.
+     * Tuto : https://doc.babylonjs.com/how_to/how_to_use_curve3#curve3-object
+     * @param points points which make up the curve
+     */
+    constructor(points: any);
+    _length: number;
+    _points: any;
+    /**
+     * @returns the Curve3 stored array of successive Vector3
+     */
+    getPoints(): any;
+    /**
+     * @returns the computed length (float) of the curve.
+     */
+    length(): number;
+    /**
+     * Returns a new instance of Curve3 object : var curve = curveA.continue(curveB);
+     * This new Curve3 is built by translating and sticking the curveB at the end of the curveA.
+     * curveA and curveB keep unchanged.
+     * @param curve the curve to continue from this curve
+     * @returns the newly constructed curve
+     */
+    continue(curve: any): Curve3;
+    _computeLength(path: any): number;
+}
+import { Vector2 } from "./math.vector.js";
+import { Vector3 } from "./math.vector.js";
+import { Matrix } from "./math.vector.js";

package/dist/types/node_modules/@babylonjs/core/Maths/math.plane.d.ts

@@ -0,0 +1,107 @@
+/**
+ * Represents a plane by the equation ax + by + cz + d = 0
+ */
+export class Plane {
+    /**
+     * Creates a plane from an  array
+     * @param array the array to create a plane from
+     * @returns a new Plane from the given array.
+     */
+    static FromArray(array: any): Plane;
+    /**
+     * Creates a plane from three points
+     * @param point1 point used to create the plane
+     * @param point2 point used to create the plane
+     * @param point3 point used to create the plane
+     * @returns a new Plane defined by the three given points.
+     */
+    static FromPoints(point1: any, point2: any, point3: any): Plane;
+    /**
+     * Creates a plane from an origin point and a normal
+     * @param origin origin of the plane to be constructed
+     * @param normal normal of the plane to be constructed
+     * @returns a new Plane the normal vector to this plane at the given origin point.
+     * Note : the vector "normal" is updated because normalized.
+     */
+    static FromPositionAndNormal(origin: any, normal: any): Plane;
+    /**
+     * Calculates the distance from a plane and a point
+     * @param origin origin of the plane to be constructed
+     * @param normal normal of the plane to be constructed
+     * @param point point to calculate distance to
+     * @returns the signed distance between the plane defined by the normal vector at the "origin"" point and the given other point.
+     */
+    static SignedDistanceToPlaneFromPositionAndNormal(origin: any, normal: any, point: any): number;
+    /**
+     * Creates a Plane object according to the given floats a, b, c, d and the plane equation : ax + by + cz + d = 0
+     * @param a a component of the plane
+     * @param b b component of the plane
+     * @param c c component of the plane
+     * @param d d component of the plane
+     */
+    constructor(a: any, b: any, c: any, d: any);
+    normal: Vector3;
+    d: any;
+    /**
+     * @returns the plane coordinates as a new array of 4 elements [a, b, c, d].
+     */
+    asArray(): any[];
+    /**
+     * @returns a new plane copied from the current Plane.
+     */
+    clone(): Plane;
+    /**
+     * @returns the string "Plane".
+     */
+    getClassName(): string;
+    /**
+     * @returns the Plane hash code.
+     */
+    getHashCode(): number;
+    /**
+     * Normalize the current Plane in place.
+     * @returns the updated Plane.
+     */
+    normalize(): Plane;
+    /**
+     * Applies a transformation the plane and returns the result
+     * @param transformation the transformation matrix to be applied to the plane
+     * @returns a new Plane as the result of the transformation of the current Plane by the given matrix.
+     */
+    transform(transformation: any): Plane;
+    /**
+     * Compute the dot product between the point and the plane normal
+     * @param point point to calculate the dot product with
+     * @returns the dot product (float) of the point coordinates and the plane normal.
+     */
+    dotCoordinate(point: any): any;
+    /**
+     * Updates the current Plane from the plane defined by the three given points.
+     * @param point1 one of the points used to construct the plane
+     * @param point2 one of the points used to construct the plane
+     * @param point3 one of the points used to construct the plane
+     * @returns the updated Plane.
+     */
+    copyFromPoints(point1: any, point2: any, point3: any): Plane;
+    /**
+     * Checks if the plane is facing a given direction (meaning if the plane's normal is pointing in the opposite direction of the given vector).
+     * Note that for this function to work as expected you should make sure that:
+     *   - direction and the plane normal are normalized
+     *   - epsilon is a number just bigger than -1, something like -0.99 for eg
+     * @param direction the direction to check if the plane is facing
+     * @param epsilon value the dot product is compared against (returns true if dot <= epsilon)
+     * @returns True if the plane is facing the given direction
+     */
+    isFrontFacingTo(direction: any, epsilon: any): boolean;
+    /**
+     * Calculates the distance to a point
+     * @param point point to calculate distance to
+     * @returns the signed distance (float) from the given point to the Plane.
+     */
+    signedDistanceTo(point: any): any;
+}
+export namespace Plane {
+    const _TmpMatrix: Matrix;
+}
+import { Vector3 } from "./math.vector.js";
+import { Matrix } from "./math.vector.js";