@types/three 0.149.0 → 0.150.1

three/src/geometries/DodecahedronGeometry.d.ts

@@ -1,16 +1,25 @@
 import { PolyhedronGeometry } from './PolyhedronGeometry';
 
+/**
+ * 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 {
     /**
-     * @param [radius=1]
-     * @param [detail=0]
+     * 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);
 
     /**
-     * @default 'DodecahedronGeometry'
+     * A Read-only _string_ to check if `this` object type.
+     * @remarks Sub-classes will update this value.
+     * @defaultValue `DodecahedronGeometry`
      */
-    type: string;
+    override readonly type: string | 'DodecahedronGeometry';
 
-    static fromJSON(data: any): DodecahedronGeometry;
+    /** @internal */
+    static fromJSON(data: {}): DodecahedronGeometry;
 }

three/src/geometries/EdgesGeometry.d.ts

@@ -1,19 +1,41 @@
 import { BufferGeometry } from '../core/BufferGeometry';
 
+/**
+ * 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 {
     /**
-     * @param geometry
-     * @param [thresholdAngle=1]
+     * 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, thresholdAngle?: number);
+    constructor(geometry?: TBufferGeometry | null, thresholdAngle?: number);
 
     /**
-     * @default 'EdgesGeometry'
+     * A Read-only _string_ to check if `this` object type.
+     * @remarks Sub-classes will update this value.
+     * @defaultValue `EdgesGeometry`
      */
-    type: string;
+    override readonly type: string | 'EdgesGeometry';
 
-    parameters: {
-        geometry: TBufferGeometry;
-        thresholdAngle: number;
+    /**
+     * 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;
     };
 }

three/src/geometries/ExtrudeGeometry.d.ts

@@ -6,35 +6,67 @@ import { BufferGeometry } from './../core/BufferGeometry';
 
 export interface ExtrudeGeometryOptions {
     /**
-     * @default 12
+     * Number of points on the curves.
+     * Expects a `Integer`.
+     * @defaultValue `12`
      */
     curveSegments?: number | undefined;
+
     /**
-     * @default 1
+     * Number of points used for subdividing segments along the depth of the extruded spline.
+     * @defaultValue `1`
      */
     steps?: number | undefined;
+
     /**
-     * @default 100
+     * Depth to extrude the shape.
+     * @defaultValue `1`
      */
     depth?: number | undefined;
+
     /**
-     * @default true
+     * Turn on bevel. Applying beveling to the shape.
+     * @defaultValue `true`
      */
     bevelEnabled?: boolean | undefined;
+
     /**
-     * @default 6
+     * 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;
+
     /**
-     * @default 0
+     * Distance from the shape outline that the bevel starts.
+     * Expects a `Float`.
+     * @defaultValue `0`
      */
     bevelOffset?: number | undefined;
+
     /**
-     * @default 3
+     * 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;
 }
 
@@ -56,16 +88,65 @@ export interface UVGenerator {
     ): 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);
 
     /**
-     * @default 'ExtrudeGeometry'
+     * 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.
      */
-    type: string;
+    readonly parameters: {
+        readonly shapes: Shape | Shape[];
+        readonly options: ExtrudeGeometryOptions;
+    };
 
-    addShapeList(shapes: Shape[], options?: any): void;
-    addShape(shape: Shape, options?: any): void;
+    addShape(shape: Shape): void;
 
-    static fromJSON(data: any): ExtrudeGeometry;
+    /** @internal */
+    static fromJSON(data: {}, shapes: unknown): ExtrudeGeometry;
 }

three/src/geometries/IcosahedronGeometry.d.ts

@@ -1,16 +1,26 @@
 import { PolyhedronGeometry } from './PolyhedronGeometry';
 
+/**
+ * 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 {
     /**
-     * @param [radius=1]
-     * @param [detail=0]
+     * 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);
 
     /**
-     * @default 'IcosahedronGeometry'
+     * A Read-only _string_ to check if `this` object type.
+     * @remarks Sub-classes will update this value.
+     * @defaultValue `IcosahedronGeometry`
      */
-    type: string;
+    override readonly type: string | 'IcosahedronGeometry';
 
-    static fromJSON(data: any): IcosahedronGeometry;
+    /** @internal */
+    static fromJSON(data: {}): IcosahedronGeometry;
 }

three/src/geometries/LatheGeometry.d.ts

@@ -1,26 +1,55 @@
 import { Vector2 } from './../math/Vector2';
 import { BufferGeometry } from './../core/BufferGeometry';
 
+/**
+ * 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 {
     /**
-     * @param points
-     * @param [segments=12]
-     * @param [phiStart=0]
-     * @param [phiLength=Math.PI * 2]
+     * 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);
 
     /**
-     * @default 'LatheGeometry'
+     * A Read-only _string_ to check if `this` object type.
+     * @remarks Sub-classes will update this value.
+     * @defaultValue `LatheGeometry`
      */
-    type: string;
+    override readonly type: string | 'LatheGeometry';
 
-    parameters: {
-        points: Vector2[];
-        segments: number;
-        phiStart: number;
-        phiLength: number;
+    /**
+     * 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;
     };
 
-    static fromJSON(data: any): LatheGeometry;
+    /** @internal */
+    static fromJSON(data: {}): LatheGeometry;
 }

three/src/geometries/OctahedronGeometry.d.ts

@@ -1,16 +1,25 @@
 import { PolyhedronGeometry } from './PolyhedronGeometry';
 
+/**
+ * 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 {
     /**
-     * @param [radius=1]
-     * @param [detail=0]
+     * 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);
 
     /**
-     * @default 'OctahedronGeometry'
+     * A Read-only _string_ to check if `this` object type.
+     * @remarks Sub-classes will update this value.
+     * @defaultValue `OctahedronGeometry`
      */
-    type: string;
+    override readonly type: string | 'OctahedronGeometry';
 
-    static fromJSON(data: any): OctahedronGeometry;
+    /** @internal */
+    static fromJSON(data: {}): OctahedronGeometry;
 }

three/src/geometries/PlaneGeometry.d.ts

@@ -1,25 +1,48 @@
 import { BufferGeometry } from './../core/BufferGeometry';
 
+/**
+ * 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 {
     /**
-     * @param [width=1] — Width of the sides on the X axis.
-     * @param [height=1] — Height of the sides on the Y axis.
-     * @param [widthSegments=1] — Number of segmented faces along the width of the sides.
-     * @param [heightSegments=1] — Number of segmented faces along the height of the sides.
+     * 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);
 
     /**
-     * @default 'PlaneGeometry'
+     * A Read-only _string_ to check if `this` object type.
+     * @remarks Sub-classes will update this value.
+     * @defaultValue `PlaneGeometry`
      */
-    type: string;
+    override readonly type: string | 'PlaneGeometry';
 
-    parameters: {
-        width: number;
-        height: number;
-        widthSegments: number;
-        heightSegments: number;
+    /**
+     * 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;
     };
 
-    static fromJSON(data: any): PlaneGeometry;
+    /** @internal */
+    static fromJSON(data: {}): PlaneGeometry;
 }

three/src/geometries/PolyhedronGeometry.d.ts

@@ -1,25 +1,54 @@
 import { BufferGeometry } from './../core/BufferGeometry';
 
+/**
+ * A polyhedron is a solid in three dimensions with flat faces
+ * @remarks
+ * This class will take an array of vertices, project them onto a sphere, and then divide them up to the desired level of detail
+ * This class is used by {@link THREE.DodecahedronGeometry | DodecahedronGeometry}, {@link THREE.IcosahedronGeometry | IcosahedronGeometry},
+ * {@link THREE.OctahedronGeometry | OctahedronGeometry}, and {@link THREE.TetrahedronGeometry | TetrahedronGeometry} to generate their respective geometries.
+ * @example
+ * ```typescript
+ * const verticesOfCube = [-1, -1, -1, 1, -1, -1, 1, 1, -1, -1, 1, -1, -1, -1, 1, 1, -1, 1, 1, 1, 1, -1, 1, 1, ];
+ * const indicesOfFaces = [
+ * 2, 1, 0, 0, 3, 2,
+ * 0, 4, 7, 7, 3, 0,
+ * 0, 1, 5, 5, 4, 0,
+ * 1, 2, 6, 6, 5, 1,
+ * 2, 3, 7, 7, 6, 2,
+ * 4, 5, 6, 6, 7, 4];
+ * const geometry = new THREE.PolyhedronGeometry(verticesOfCube, indicesOfFaces, 6, 2);
+ * ```
+ * @see {@link https://threejs.org/docs/index.html#api/en/geometries/PolyhedronGeometry | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/geometries/PolyhedronGeometry.js | Source}
+ */
 export class PolyhedronGeometry extends BufferGeometry {
     /**
-     * @param vertices
-     * @param indices
-     * @param [radius=1]
-     * @param [detail=0]
+     * Create a new instance of {@link PolyhedronGeometry}
+     * @param vertices Array of points of the form [1,1,1, -1,-1,-1, ... ]. Default `[]`.
+     * @param indices Array of indices that make up the faces of the form [0,1,2, 2,3,0, ... ]. Default `[]`.
+     * @param radius [page:The radius of the final shape Expects a `Float`. Default `1`
+     * @param detail [page:How many levels to subdivide the geometry. The more detail, the smoother the shape. Expects a `Integer`. Default `0`
      */
     constructor(vertices?: number[], indices?: number[], radius?: number, detail?: number);
 
     /**
-     * @default 'PolyhedronGeometry'
+     * A Read-only _string_ to check if `this` object type.
+     * @remarks Sub-classes will update this value.
+     * @defaultValue `PolyhedronGeometry`
      */
-    type: string;
+    override readonly type: string | 'PolyhedronGeometry';
 
-    parameters: {
-        vertices: number[];
-        indices: number[];
-        radius: number;
-        detail: number;
+    /**
+     * An object with a property for each of the constructor parameters.
+     * @remarks Any modification after instantiation does not change the geometry.
+     */
+    readonly parameters: {
+        readonly vertices: number[];
+        readonly indices: number[];
+        readonly radius: number;
+        readonly detail: number;
     };
 
-    static fromJSON(data: any): PolyhedronGeometry;
+    /** @internal */
+    static fromJSON(data: {}): PolyhedronGeometry;
 }

three/src/geometries/RingGeometry.d.ts

@@ -1,13 +1,29 @@
 import { BufferGeometry } from './../core/BufferGeometry';
 
+/**
+ * A class for generating a two-dimensional ring geometry.
+ * @example
+ * ```typescript
+ * const geometry = new THREE.RingGeometry(1, 5, 32);
+ * const material = new THREE.MeshBasicMaterial({
+ *     color: 0xffff00,
+ *     side: THREE.DoubleSide
+ * });
+ * const mesh = new THREE.Mesh(geometry, material);
+ * scene.add(mesh);
+ * ```
+ * @see {@link https://threejs.org/docs/index.html#api/en/geometries/RingGeometry | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/geometries/RingGeometry.js | Source}
+ */
 export class RingGeometry extends BufferGeometry {
     /**
-     * @param innerRadius - Default is 0.5.
-     * @param outerRadius - Default is 1.
-     * @param thetaSegments - Number of segments. A higher number means the ring will be more round. Minimum is 3. Default is 32.
-     * @param phiSegments - Minimum is 1. Default is 1.
-     * @param thetaStart - Starting angle. Default is 0.
-     * @param thetaLength - Central angle. Default is Math.PI * 2.
+     * Create a new instance of {@link RingGeometry}
+     * @param innerRadius Expects a `Float`. Default `0.5`.
+     * @param outerRadius Expects a `Float`. Default `1`.
+     * @param thetaSegments Number of segments. A higher number means the ring will be more round. Minimum is 3. Expects a `Integer`. Default `32`.
+     * @param phiSegments Minimum is 1. Expects a `Integer`. Default `1`.
+     * @param thetaStart Starting angle. Expects a `Float`. Default `0`.
+     * @param thetaLength Central angle. Expects a `Float`. Default `Math.PI * 2`.
      */
     constructor(
         innerRadius?: number,
@@ -19,18 +35,25 @@ export class RingGeometry extends BufferGeometry {
     );
 
     /**
-     * @default 'RingGeometry'
+     * A Read-only _string_ to check if `this` object type.
+     * @remarks Sub-classes will update this value.
+     * @defaultValue `RingGeometry`
      */
-    type: string;
+    override readonly type: string | 'RingGeometry';
 
-    parameters: {
-        innerRadius: number;
-        outerRadius: number;
-        thetaSegments: number;
-        phiSegments: number;
-        thetaStart: number;
-        thetaLength: number;
+    /**
+     * An object with a property for each of the constructor parameters.
+     * @remarks Any modification after instantiation does not change the geometry.
+     */
+    readonly parameters: {
+        readonly innerRadius: number;
+        readonly outerRadius: number;
+        readonly thetaSegments: number;
+        readonly phiSegments: number;
+        readonly thetaStart: number;
+        readonly thetaLength: number;
     };
 
-    static fromJSON(data: any): RingGeometry;
+    /** @internal */
+    static fromJSON(data: {}): RingGeometry;
 }

three/src/geometries/ShapeGeometry.d.ts

@@ -1,13 +1,53 @@
 import { Shape } from './../extras/core/Shape';
 import { BufferGeometry } from './../core/BufferGeometry';
 
+/**
+ * Creates an one-sided polygonal geometry from one or more path shapes.
+ * @example
+ * ```typescript
+ * const x = 0, y = 0;
+ * const heartShape = new THREE.Shape();
+ * heartShape.moveTo(x + 5, y + 5);
+ * heartShape.bezierCurveTo(x + 5, y + 5, x + 4, y, x, y);
+ * heartShape.bezierCurveTo(x - 6, y, x - 6, y + 7, x - 6, y + 7);
+ * heartShape.bezierCurveTo(x - 6, y + 11, x - 3, y + 15.4, x + 5, y + 19);
+ * heartShape.bezierCurveTo(x + 12, y + 15.4, x + 16, y + 11, x + 16, y + 7);
+ * heartShape.bezierCurveTo(x + 16, y + 7, x + 16, y, x + 10, y);
+ * heartShape.bezierCurveTo(x + 7, y, x + 5, y + 5, x + 5, y + 5);
+ * const geometry = new THREE.ShapeGeometry(heartShape);
+ * 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/ShapeGeometry | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/geometries/ShapeGeometry.js | Source}
+ */
 export class ShapeGeometry extends BufferGeometry {
     /**
-     * @default 'ShapShapeGeometryeBufferGeometry'
+     * Create a new instance of {@link ShapeGeometry}
+     * @param shapes Array of shapes or a single {@link THREE.Shape | Shape}. Default `new Shape([new Vector2(0, 0.5), new Vector2(-0.5, -0.5), new Vector2(0.5, -0.5)])`, _a single triangle shape_.
+     * @param curveSegments Number of segments per shape. Expects a `Integer`. Default `12`
      */
-    type: string;
-
     constructor(shapes?: Shape | Shape[], curveSegments?: number);
 
-    static fromJSON(data: any): ShapeGeometry;
+    /**
+     * A Read-only _string_ to check if `this` object type.
+     * @remarks Sub-classes will update this value.
+     * @defaultValue `ShapeGeometry`
+     */
+    override readonly type: string | 'ShapeGeometry';
+
+    /**
+     * 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 curveSegments: number;
+    };
+
+    /** @internal */
+    static fromJSON(data: {}): ShapeGeometry;
 }