@needle-tools/three 0.169.12 → 0.169.13

package/types/src/geometries/CapsuleGeometry.d.ts

@@ -0,0 +1,48 @@
+import { BufferGeometry } from "../core/BufferGeometry.js";
+
+/**
+ * {@link CapsuleGeometry} is a geometry class for a capsule with given radii and height
+ * @remarks It is constructed using a lathe.
+ * @example
+ * ```typescript
+ * const geometry = new THREE.CapsuleGeometry(1, 1, 4, 8);
+ * const material = new THREE.MeshBasicMaterial({
+ *     color: 0x00ff00
+ * });
+ * const capsule = new THREE.Mesh(geometry, material);
+ * scene.add(capsule);
+ * ```
+ * @see {@link https://threejs.org/docs/index.html#api/en/geometries/CapsuleGeometry | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/geometries/CapsuleGeometry.js | Source}
+ */
+export class CapsuleGeometry extends BufferGeometry {
+    /**
+     * Create a new instance of {@link CapsuleGeometry}
+     * @param radius Radius of the capsule. Expects a `Float`. Default `1`
+     * @param length Length of the middle section. Expects a `Float`. Default `1`
+     * @param capSegments Number of curve segments used to build the caps. Expects a `Integer`. Default `4`
+     * @param radialSegments Number of segmented faces around the circumference of the capsule. Expects a `Integer`. Default `8`
+     */
+    constructor(radius?: number, length?: number, capSegments?: number, radialSegments?: number);
+
+    /**
+     * A Read-only _string_ to check if `this` object type.
+     * @remarks Sub-classes will update this value.
+     * @defaultValue `CapsuleGeometry`
+     */
+    override readonly type: string | "CapsuleGeometry";
+
+    /**
+     * An object with a property for each of the constructor parameters.
+     * @remarks Any modification after instantiation does not change the geometry.
+     */
+    readonly parameters: {
+        readonly radius: number;
+        readonly length: number;
+        readonly capSegments: number;
+        readonly radialSegments: number;
+    };
+
+    /** @internal */
+    static fromJSON(data: {}): CapsuleGeometry;
+}

package/types/src/geometries/CircleGeometry.d.ts

@@ -0,0 +1,51 @@
+import { BufferGeometry } from "../core/BufferGeometry.js";
+
+/**
+ * {@link CircleGeometry} is a simple shape of Euclidean geometry
+ * @remarks
+ * It is constructed from a number of triangular segments that are oriented around a central point and extend as far out as a given radius
+ * It is built counter-clockwise from a start angle and a given central angle
+ * It can also be used to create regular polygons, where the number of segments determines the number of sides.
+ * @example
+ * ```typescript
+ * const geometry = new THREE.CircleGeometry(5, 32);
+ * const material = new THREE.MeshBasicMaterial({
+ *     color: 0xffff00
+ * });
+ * const circle = new THREE.Mesh(geometry, material);
+ * scene.add(circle);
+ * ```
+ * @see {@link https://threejs.org/docs/index.html#api/en/geometries/CircleGeometry | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/geometries/CircleGeometry.js | Source}
+ */
+export class CircleGeometry extends BufferGeometry {
+    /**
+     * Create a new instance of {@link CircleGeometry}
+     * @param radius Radius of the circle. Expects a `Float`. Default `1`
+     * @param segments Number of segments (triangles). Expects a `Integer`. Minimum `3`. Default `32`
+     * @param thetaStart Start angle for first segment. Expects a `Float`. Default `0`, _(three o'clock position)_.
+     * @param thetaLength The central angle, often called theta, of the circular sector. Expects a `Float`. Default `Math.PI * 2`, _which makes for a complete circle_.
+     */
+    constructor(radius?: number, segments?: number, thetaStart?: number, thetaLength?: number);
+
+    /**
+     * A Read-only _string_ to check if `this` object type.
+     * @remarks Sub-classes will update this value.
+     * @defaultValue `CircleGeometry`
+     */
+    override readonly type: string | "CircleGeometry";
+
+    /**
+     * An object with a property for each of the constructor parameters.
+     * @remarks Any modification after instantiation does not change the geometry.
+     */
+    readonly parameters: {
+        readonly radius: number;
+        readonly segments: number;
+        readonly thetaStart: number;
+        readonly thetaLength: number;
+    };
+
+    /** @internal */
+    static fromJSON(data: {}): CircleGeometry;
+}

package/types/src/geometries/ConeGeometry.d.ts

@@ -0,0 +1,64 @@
+import { CylinderGeometry } from "./CylinderGeometry.js";
+
+/**
+ * A class for generating cone geometries.
+ * @example
+ * ```typescript
+ * const geometry = new THREE.ConeGeometry(5, 20, 32);
+ * const material = new THREE.MeshBasicMaterial({
+ *     color: 0xffff00
+ * });
+ * const cone = new THREE.Mesh(geometry, material);
+ * scene.add(cone);
+ * ```
+ * @see {@link https://threejs.org/docs/index.html#api/en/geometries/ConeGeometry | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/geometries/ConeGeometry.js | Source}
+ */
+export class ConeGeometry extends CylinderGeometry {
+    /**
+     * Create a new instance of {@link ConeGeometry}
+     * @param radius Radius of the cone base. Expects a `Float`. Default `1`
+     * @param height Height of the cone. Expects a `Float`. Default `1`
+     * @param radialSegments Number of segmented faces around the circumference of the cone. Expects a `Integer`. Default `32`
+     * @param heightSegments Number of rows of faces along the height of the cone. Expects a `Integer`. Default `1`
+     * @param openEnded A Boolean indicating whether the base of the cone is open or capped. Default `false`, _meaning capped_.
+     * @param thetaStart Start angle for first segment. Expects a `Float`. Default `0`, _(three o'clock position)_.
+     * @param thetaLength The central angle, often called theta, of the circular sector. Expects a `Float`. Default `Math.PI * 2`, _which makes for a complete cone_.
+     */
+    constructor(
+        radius?: number,
+        height?: number,
+        radialSegments?: number,
+        heightSegments?: number,
+        openEnded?: boolean,
+        thetaStart?: number,
+        thetaLength?: number,
+    );
+
+    /**
+     * A Read-only _string_ to check if `this` object type.
+     * @remarks Sub-classes will update this value.
+     * @defaultValue `ConeGeometry`
+     */
+    override readonly type: string | "ConeGeometry";
+
+    /**
+     * An object with a property for each of the constructor parameters.
+     * @remarks {@link radiusTop} and {@link radiusBottom} are from base {@link THREE.CylinderGeometry} class.
+     * @remarks Any modification after instantiation does not change the geometry.
+     */
+    override readonly parameters: {
+        readonly radius: number;
+        readonly radiusTop: number;
+        readonly radiusBottom: number;
+        readonly height: number;
+        readonly radialSegments: number;
+        readonly heightSegments: number;
+        readonly openEnded: boolean;
+        readonly thetaStart: number;
+        readonly thetaLength: number;
+    };
+
+    /** @internal */
+    static fromJSON(data: {}): ConeGeometry;
+}

package/types/src/geometries/CylinderGeometry.d.ts

@@ -0,0 +1,64 @@
+import { BufferGeometry } from "../core/BufferGeometry.js";
+
+/**
+ * A class for generating cylinder geometries.
+ * @example
+ * ```typescript
+ * const geometry = new THREE.CylinderGeometry(5, 5, 20, 32);
+ * const material = new THREE.MeshBasicMaterial({
+ *     color: 0xffff00
+ * });
+ * const cylinder = new THREE.Mesh(geometry, material);
+ * scene.add(cylinder);
+ * ```
+ * @see {@link https://threejs.org/docs/index.html#api/en/geometries/CylinderGeometry | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/geometries/CylinderGeometry.js | Source}
+ */
+export class CylinderGeometry extends BufferGeometry {
+    /**
+     * Create a new instance of {@link CylinderGeometry}
+     * @param radiusTop Radius of the cylinder at the top. Default `1`
+     * @param radiusBottom Radius of the cylinder at the bottom. Default `1`
+     * @param height Height of the cylinder. Default `1`
+     * @param radialSegments Number of segmented faces around the circumference of the cylinder. Default `32`
+     * @param heightSegments Number of rows of faces along the height of the cylinder. Expects a `Integer`. Default `1`
+     * @param openEnded A Boolean indicating whether the ends of the cylinder are open or capped. Default `false`, _meaning capped_.
+     * @param thetaStart Start angle for first segment. Default `0`, _(three o'clock position)_.
+     * @param thetaLength The central angle, often called theta, of the circular sector. Default `Math.PI * 2`, _which makes for a complete cylinder.
+     */
+    constructor(
+        radiusTop?: number,
+        radiusBottom?: number,
+        height?: number,
+        radialSegments?: number,
+        heightSegments?: number,
+        openEnded?: boolean,
+        thetaStart?: number,
+        thetaLength?: number,
+    );
+
+    /**
+     * A Read-only _string_ to check if `this` object type.
+     * @remarks Sub-classes will update this value.
+     * @defaultValue `CylinderGeometry`
+     */
+    override readonly type: string | "CylinderGeometry";
+
+    /**
+     * An object with a property for each of the constructor parameters.
+     * @remarks Any modification after instantiation does not change the geometry.
+     */
+    readonly parameters: {
+        readonly radiusTop: number;
+        readonly radiusBottom: number;
+        readonly height: number;
+        readonly radialSegments: number;
+        readonly heightSegments: number;
+        readonly openEnded: boolean;
+        readonly thetaStart: number;
+        readonly thetaLength: number;
+    };
+
+    /** @internal */
+    static fromJSON(data: any): CylinderGeometry;
+}

package/types/src/geometries/DodecahedronGeometry.d.ts

@@ -0,0 +1,25 @@
+import { PolyhedronGeometry } from "./PolyhedronGeometry.js";
+
+/**
+ * A class for generating a dodecahedron geometries.
+ * @see {@link https://threejs.org/docs/index.html#api/en/geometries/DodecahedronGeometry | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/geometries/DodecahedronGeometry.js | Source}
+ */
+export class DodecahedronGeometry extends PolyhedronGeometry {
+    /**
+     * Create a new instance of {@link DodecahedronGeometry}
+     * @param radius Radius of the dodecahedron. Expects a `Float`. Default `1`
+     * @param detail Setting this to a value greater than 0 adds vertices making it no longer a dodecahedron. Expects a `Integer`. Default `0`
+     */
+    constructor(radius?: number, detail?: number);
+
+    /**
+     * A Read-only _string_ to check if `this` object type.
+     * @remarks Sub-classes will update this value.
+     * @defaultValue `DodecahedronGeometry`
+     */
+    override readonly type: string | "DodecahedronGeometry";
+
+    /** @internal */
+    static fromJSON(data: {}): DodecahedronGeometry;
+}

package/types/src/geometries/EdgesGeometry.d.ts

@@ -0,0 +1,41 @@
+import { BufferGeometry } from "../core/BufferGeometry.js";
+
+/**
+ * This can be used as a helper object to view the edges of a {@link THREE.BufferGeometry | geometry}.
+ * @example
+ * ```typescript
+ * const geometry = new THREE.BoxGeometry(100, 100, 100);
+ * const edges = new THREE.EdgesGeometry(geometry);
+ * const line = new THREE.LineSegments(edges, new THREE.LineBasicMaterial({
+ *     color: 0xffffff
+ * }));
+ * scene.add(line);
+ * ```
+ * @see Example: {@link https://threejs.org/examples/#webgl_helpers | helpers}
+ * @see {@link https://threejs.org/docs/index.html#api/en/geometries/EdgesGeometry | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/geometries/EdgesGeometry.js | Source}
+ */
+export class EdgesGeometry<TBufferGeometry extends BufferGeometry = BufferGeometry> extends BufferGeometry {
+    /**
+     * Create a new instance of {@link EdgesGeometry}
+     * @param geometry Any geometry object. Default `null`.
+     * @param thresholdAngle An edge is only rendered if the angle (in degrees) between the face normals of the adjoining faces exceeds this value. Expects a `Integer`. Default `1` _degree_.
+     */
+    constructor(geometry?: TBufferGeometry | null, thresholdAngle?: number);
+
+    /**
+     * A Read-only _string_ to check if `this` object type.
+     * @remarks Sub-classes will update this value.
+     * @defaultValue `EdgesGeometry`
+     */
+    override readonly type: string | "EdgesGeometry";
+
+    /**
+     * An object with a property for each of the constructor parameters.
+     * @remarks Any modification after instantiation does not change the geometry.
+     */
+    readonly parameters: {
+        readonly geometry: TBufferGeometry | null;
+        readonly thresholdAngle: number;
+    };
+}

package/types/src/geometries/ExtrudeGeometry.d.ts

@@ -0,0 +1,152 @@
+import { BufferGeometry } from "../core/BufferGeometry.js";
+import { Curve } from "../extras/core/Curve.js";
+import { Shape } from "../extras/core/Shape.js";
+import { Vector2 } from "../math/Vector2.js";
+import { Vector3 } from "../math/Vector3.js";
+
+export interface ExtrudeGeometryOptions {
+    /**
+     * Number of points on the curves.
+     * Expects a `Integer`.
+     * @defaultValue `12`
+     */
+    curveSegments?: number | undefined;
+
+    /**
+     * Number of points used for subdividing segments along the depth of the extruded spline.
+     * @defaultValue `1`
+     */
+    steps?: number | undefined;
+
+    /**
+     * Depth to extrude the shape.
+     * @defaultValue `1`
+     */
+    depth?: number | undefined;
+
+    /**
+     * Turn on bevel. Applying beveling to the shape.
+     * @defaultValue `true`
+     */
+    bevelEnabled?: boolean | undefined;
+
+    /**
+     * How deep into the original shape the bevel goes.
+     * Expects a `Float`.
+     * @defaultValue `0.2`
+     */
+    bevelThickness?: number | undefined;
+
+    /**
+     * Distance from the shape outline that the bevel extends
+     * Expects a `Float`.
+     * @defaultValue `bevelThickness - 0.1`
+     */
+    bevelSize?: number | undefined;
+
+    /**
+     * Distance from the shape outline that the bevel starts.
+     * Expects a `Float`.
+     * @defaultValue `0`
+     */
+    bevelOffset?: number | undefined;
+
+    /**
+     * Number of bevel layers/segments.
+     * Expects a `Integer`.
+     * @defaultValue `3`
+     */
+    bevelSegments?: number | undefined;
+
+    /**
+     * A 3D spline path along which the shape should be extruded.
+     * @remarks Bevels not supported for path extrusion.
+     */
+    extrudePath?: Curve<Vector3> | undefined;
+
+    /**
+     * A object that provides UV generator functions.
+     */
+    UVGenerator?: UVGenerator | undefined;
+}
+
+export interface UVGenerator {
+    generateTopUV(
+        geometry: ExtrudeGeometry,
+        vertices: number[],
+        indexA: number,
+        indexB: number,
+        indexC: number,
+    ): Vector2[];
+    generateSideWallUV(
+        geometry: ExtrudeGeometry,
+        vertices: number[],
+        indexA: number,
+        indexB: number,
+        indexC: number,
+        indexD: number,
+    ): Vector2[];
+}
+
+/**
+ * Creates extruded geometry from a path shape.
+ * @remarks This object extrudes a 2D shape to a 3D geometry.
+ * @remarks When creating a Mesh with this geometry, if you'd like to have a separate material used for its face and its extruded sides, you can use an array of materials
+ * @remarks The first material will be applied to the face; the second material will be applied to the sides.
+ * @example
+ * ```typescript
+ * const length = 12, width = 8;
+ * const shape = new THREE.Shape();
+ * shape.moveTo(0, 0);
+ * shape.lineTo(0, width);
+ * shape.lineTo(length, width);
+ * shape.lineTo(length, 0);
+ * shape.lineTo(0, 0);
+ * const extrudeSettings = {
+ *     steps: 2,
+ *     depth: 16,
+ *     bevelEnabled: true,
+ *     bevelThickness: 1,
+ *     bevelSize: 1,
+ *     bevelOffset: 0,
+ *     bevelSegments: 1
+ * };
+ * const geometry = new THREE.ExtrudeGeometry(shape, extrudeSettings);
+ * const material = new THREE.MeshBasicMaterial({
+ *     color: 0x00ff00
+ * });
+ * const mesh = new THREE.Mesh(geometry, material);
+ * scene.add(mesh);
+ * ```
+ * @see {@link https://threejs.org/docs/index.html#api/en/geometries/ExtrudeGeometry | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/geometries/ExtrudeGeometry.js | Source}
+ */
+export class ExtrudeGeometry extends BufferGeometry {
+    /**
+     * Create a new instance of {@link ExtrudeGeometry}
+     * @param shapes Shape or an array of shapes. Default `new Shape([new Vector2(0.5, 0.5), new Vector2(-0.5, 0.5), new Vector2(-0.5, -0.5), new Vector2(0.5, -0.5)])`.
+     * @param options Object that can contain the following parameters. @see {@link ExtrudeGeometryOptions} for defaults.
+     */
+    constructor(shapes?: Shape | Shape[], options?: ExtrudeGeometryOptions);
+
+    /**
+     * A Read-only _string_ to check if `this` object type.
+     * @remarks Sub-classes will update this value.
+     * @defaultValue `ExtrudeGeometry`
+     */
+    override readonly type: string | "ExtrudeGeometry";
+
+    /**
+     * An object with a property for each of the constructor parameters.
+     * @remarks Any modification after instantiation does not change the geometry.
+     */
+    readonly parameters: {
+        readonly shapes: Shape | Shape[];
+        readonly options: ExtrudeGeometryOptions;
+    };
+
+    addShape(shape: Shape): void;
+
+    /** @internal */
+    static fromJSON(data: {}, shapes: unknown): ExtrudeGeometry;
+}

package/types/src/geometries/Geometries.d.ts

@@ -0,0 +1,21 @@
+export * from "./BoxGeometry.js";
+export * from "./CapsuleGeometry.js";
+export * from "./CircleGeometry.js";
+export * from "./ConeGeometry.js";
+export * from "./CylinderGeometry.js";
+export * from "./DodecahedronGeometry.js";
+export * from "./EdgesGeometry.js";
+export * from "./ExtrudeGeometry.js";
+export * from "./IcosahedronGeometry.js";
+export * from "./LatheGeometry.js";
+export * from "./OctahedronGeometry.js";
+export * from "./PlaneGeometry.js";
+export * from "./PolyhedronGeometry.js";
+export * from "./RingGeometry.js";
+export * from "./ShapeGeometry.js";
+export * from "./SphereGeometry.js";
+export * from "./TetrahedronGeometry.js";
+export * from "./TorusGeometry.js";
+export * from "./TorusKnotGeometry.js";
+export * from "./TubeGeometry.js";
+export * from "./WireframeGeometry.js";

package/types/src/geometries/IcosahedronGeometry.d.ts

@@ -0,0 +1,26 @@
+import { PolyhedronGeometry } from "./PolyhedronGeometry.js";
+
+/**
+ * A class for generating an icosahedron geometry.
+ * @see {@link https://threejs.org/docs/index.html#api/en/geometries/IcosahedronGeometry | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/geometries/IcosahedronGeometry.js | Source}
+ */
+export class IcosahedronGeometry extends PolyhedronGeometry {
+    /**
+     * Create a new instance of {@link IcosahedronGeometry}
+     * @param radius Expects a `Float`. Default `1`
+     * @param detail Setting this to a value greater than 0 adds more vertices making it no longer an icosahedron.
+     *               When detail is greater than 1, it's effectively a sphere. Expects a `Integer`. Default `0`
+     */
+    constructor(radius?: number, detail?: number);
+
+    /**
+     * A Read-only _string_ to check if `this` object type.
+     * @remarks Sub-classes will update this value.
+     * @defaultValue `IcosahedronGeometry`
+     */
+    override readonly type: string | "IcosahedronGeometry";
+
+    /** @internal */
+    static fromJSON(data: {}): IcosahedronGeometry;
+}

package/types/src/geometries/LatheGeometry.d.ts

@@ -0,0 +1,55 @@
+import { BufferGeometry } from "../core/BufferGeometry.js";
+import { Vector2 } from "../math/Vector2.js";
+
+/**
+ * Creates meshes with axial symmetry like vases
+ * @remarks
+ * The lathe rotates around the Y axis.
+ * @example
+ * ```typescript
+ * const points = [];
+ * for (let i = 0; i & lt; 10; i++) {
+ *     points.push(new THREE.Vector2(Math.sin(i * 0.2) * 10 + 5, (i - 5) * 2));
+ * }
+ * const geometry = new THREE.LatheGeometry(points);
+ * const material = new THREE.MeshBasicMaterial({
+ *     color: 0xffff00
+ * });
+ * const lathe = new THREE.Mesh(geometry, material);
+ * scene.add(lathe);
+ * ```
+ * @see {@link https://threejs.org/docs/index.html#api/en/geometries/LatheGeometry | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/geometries/LatheGeometry.js | Source}
+ */
+export class LatheGeometry extends BufferGeometry {
+    /**
+     * This creates a {@link LatheGeometry} based on the parameters.
+     * @param points Array of Vector2s. The x-coordinate of each point must be greater than zero.
+     *               Default `[new Vector2(0, -0.5), new Vector2(0.5, 0), new Vector2(0, 0.5)]` _which creates a simple diamond shape_.
+     * @param segments The number of circumference segments to generate. Expects a `Integer`. Default `12`.
+     * @param phiStart The starting angle in radians. Expects a `Float`. Default `0`.
+     * @param phiLength The radian (0 to 2*PI) range of the lathed section 2*PI is a closed lathe, less than 2PI is a portion. Expects a `Float`. Default `Math.PI * 2`.
+     */
+    constructor(points?: Vector2[], segments?: number, phiStart?: number, phiLength?: number);
+
+    /**
+     * A Read-only _string_ to check if `this` object type.
+     * @remarks Sub-classes will update this value.
+     * @defaultValue `LatheGeometry`
+     */
+    override readonly type: string | "LatheGeometry";
+
+    /**
+     * An object with a property for each of the constructor parameters.
+     * @remarks Any modification after instantiation does not change the geometry.
+     */
+    readonly parameters: {
+        readonly points: Vector2[];
+        readonly segments: number;
+        readonly phiStart: number;
+        readonly phiLength: number;
+    };
+
+    /** @internal */
+    static fromJSON(data: {}): LatheGeometry;
+}

package/types/src/geometries/OctahedronGeometry.d.ts

@@ -0,0 +1,25 @@
+import { PolyhedronGeometry } from "./PolyhedronGeometry.js";
+
+/**
+ * A class for generating an octahedron geometry.
+ * @see {@link https://threejs.org/docs/index.html#api/en/geometries/OctahedronGeometry | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/geometries/OctahedronGeometry.js | Source}
+ */
+export class OctahedronGeometry extends PolyhedronGeometry {
+    /**
+     * Create a new instance of {@link OctahedronGeometry}
+     * @param radius Radius of the octahedron. Expects a `Float`. Default `1`
+     * @param detail Setting this to a value greater than zero add vertices making it no longer an octahedron. Expects a `Integer`. Default `0`
+     */
+    constructor(radius?: number, detail?: number);
+
+    /**
+     * A Read-only _string_ to check if `this` object type.
+     * @remarks Sub-classes will update this value.
+     * @defaultValue `OctahedronGeometry`
+     */
+    override readonly type: string | "OctahedronGeometry";
+
+    /** @internal */
+    static fromJSON(data: {}): OctahedronGeometry;
+}

package/types/src/geometries/PlaneGeometry.d.ts

@@ -0,0 +1,48 @@
+import { BufferGeometry } from "../core/BufferGeometry.js";
+
+/**
+ * A class for generating plane geometries.
+ * @example
+ * ```typescript
+ * const geometry = new THREE.PlaneGeometry(1, 1);
+ * const material = new THREE.MeshBasicMaterial({
+ *     color: 0xffff00,
+ *     side: THREE.DoubleSide
+ * });
+ * const plane = new THREE.Mesh(geometry, material);
+ * scene.add(plane);
+ * ```
+ * @see {@link https://threejs.org/docs/index.html#api/en/geometries/PlaneGeometry | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/geometries/PlaneGeometry.js | Source}
+ */
+export class PlaneGeometry extends BufferGeometry {
+    /**
+     * Create a new instance of {@link PlaneGeometry}
+     * @param width Width along the X axis. Expects a `Float`. Default `1`
+     * @param height Height along the Y axis. Expects a `Float`. Default `1`
+     * @param widthSegments Number of segmented faces along the width of the sides. Expects a `Integer`. Default `1`
+     * @param heightSegments Number of segmented faces along the height of the sides. Expects a `Integer`. Default `1`
+     */
+    constructor(width?: number, height?: number, widthSegments?: number, heightSegments?: number);
+
+    /**
+     * A Read-only _string_ to check if `this` object type.
+     * @remarks Sub-classes will update this value.
+     * @defaultValue `PlaneGeometry`
+     */
+    override readonly type: string | "PlaneGeometry";
+
+    /**
+     * An object with a property for each of the constructor parameters.
+     * @remarks Any modification after instantiation does not change the geometry.
+     */
+    readonly parameters: {
+        readonly width: number;
+        readonly height: number;
+        readonly widthSegments: number;
+        readonly heightSegments: number;
+    };
+
+    /** @internal */
+    static fromJSON(data: {}): PlaneGeometry;
+}