@types/three 0.150.0 → 0.150.1

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;
 }

three/src/geometries/SphereGeometry.d.ts

@@ -1,20 +1,35 @@
 import { BufferGeometry } from './../core/BufferGeometry';
 
+/**
+ * A class for generating sphere geometries.
+ * @example
+ * ```typescript
+ * const geometry = new THREE.SphereGeometry(15, 32, 16);
+ * const material = new THREE.MeshBasicMaterial({
+ *     color: 0xffff00
+ * });
+ * const sphere = new THREE.Mesh(geometry, material);
+ * scene.add(sphere);
+ * ```
+ * @see {@link https://threejs.org/docs/index.html#api/en/geometries/SphereGeometry | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/geometries/SphereGeometry.js | Source}
+ */
 export class SphereGeometry extends BufferGeometry {
     /**
+     * Create a new instance of {@link SphereGeometry}
+     * @remarks
      * The geometry is created by sweeping and calculating vertexes
-     * around the Y axis (horizontal sweep) and the Z axis (vertical sweep).
+     * around the **Y** axis (horizontal sweep) and the **Z** axis (vertical sweep)
      * Thus, incomplete spheres (akin to `'sphere slices'`) can be created
-     * through the use of different values of phiStart, phiLength, thetaStart and thetaLength,
+     * through the use of different values of {@link phiStart}, {@link phiLength}, {@link thetaStart} and {@link thetaLength},
      * in order to define the points in which we start (or end) calculating those vertices.
-     *
-     * @param [radius=50] - sphere radius. Default is 50.
-     * @param [widthSegments=8] - number of horizontal segments. Minimum value is 3, and the default is 32.
-     * @param [heightSegments=6] - number of vertical segments. Minimum value is 2, and the default is 16.
-     * @param [phiStart=0] - specify horizontal starting angle. Default is 0.
-     * @param [phiLength=Math.PI * 2] - specify horizontal sweep angle size. Default is Math.PI * 2.
-     * @param [thetaStart=0] - specify vertical starting angle. Default is 0.
-     * @param [thetaLength=Math.PI * 2] - specify vertical sweep angle size. Default is Math.PI.
+     * @param radius Sphere radius. Expects a `Float`. Default `1`
+     * @param widthSegments Number of horizontal segments. Minimum value is 3, and the Expects a `Integer`. Default `32`
+     * @param heightSegments Number of vertical segments. Minimum value is 2, and the Expects a `Integer`. Default `16`
+     * @param phiStart Specify horizontal starting angle. Expects a `Float`. Default `0`
+     * @param phiLength Specify horizontal sweep angle size. Expects a `Float`. Default `Math.PI * 2`
+     * @param thetaStart Specify vertical starting angle. Expects a `Float`. Default `0`
+     * @param thetaLength Specify vertical sweep angle size. Expects a `Float`. Default `Math.PI`
      */
     constructor(
         radius?: number,
@@ -27,19 +42,26 @@ export class SphereGeometry extends BufferGeometry {
     );
 
     /**
-     * @default 'SphereGeometry'
+     * A Read-only _string_ to check if `this` object type.
+     * @remarks Sub-classes will update this value.
+     * @defaultValue `SphereGeometry`
      */
-    type: string;
+    override readonly type: string | 'SphereGeometry';
 
-    parameters: {
-        radius: number;
-        widthSegments: number;
-        heightSegments: number;
-        phiStart: number;
-        phiLength: 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 radius: number;
+        readonly widthSegments: number;
+        readonly heightSegments: number;
+        readonly phiStart: number;
+        readonly phiLength: number;
+        readonly thetaStart: number;
+        readonly thetaLength: number;
     };
 
-    static fromJSON(data: any): SphereGeometry;
+    /** @internal */
+    static fromJSON(data: {}): SphereGeometry;
 }

three/src/geometries/TetrahedronGeometry.d.ts

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

three/src/geometries/TorusGeometry.d.ts

@@ -1,27 +1,49 @@
 import { BufferGeometry } from './../core/BufferGeometry';
 
+/**
+ * A class for generating torus geometries.
+ * @example
+ * ```typescript
+ * const geometry = new THREE.TorusGeometry(10, 3, 16, 100);
+ * const material = new THREE.MeshBasicMaterial({
+ *     color: 0xffff00
+ * });
+ * const torus = new THREE.Mesh(geometry, material);
+ * scene.add(torus);
+ * ```
+ * @see {@link https://threejs.org/docs/index.html#api/en/geometries/TorusGeometry | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/geometries/TorusGeometry.js | Source}
+ */
 export class TorusGeometry extends BufferGeometry {
     /**
-     * @param radius - Radius of the torus, from the center of the torus to the center of the tube. Default is 1.
-     * @param tube - Radius of the tube. Default is 0.4.
-     * @param radialSegments - Default is 12
-     * @param tubularSegments - Default is 48.
-     * @param arc - Central angle. Default is Math.PI * 2.
+     * Create a new instance of {@link TorusGeometry}
+     * @param radius Radius of the torus, from the center of the torus to the center of the tube. Expects a `Float`. Default `1`.
+     * @param tube Radius of the tube. Expects a `Float`. Default `0.4`.
+     * @param radialSegments Expects a `Integer`.Default is `12`.
+     * @param tubularSegments Expects a `Integer`. Default `48`.
+     * @param arc Central angle. Expects a `Float`. Default `Math.PI * 2`
      */
     constructor(radius?: number, tube?: number, radialSegments?: number, tubularSegments?: number, arc?: number);
 
     /**
-     * @default 'TorusGeometry'
+     * A Read-only _string_ to check if `this` object type.
+     * @remarks Sub-classes will update this value.
+     * @defaultValue `TorusGeometry`
      */
-    type: string;
+    override readonly type: string | 'TorusGeometry';
 
-    parameters: {
-        radius: number;
-        tube: number;
-        radialSegments: number;
-        tubularSegments: number;
-        arc: 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 radius: number;
+        readonly tube: number;
+        readonly radialSegments: number;
+        readonly tubularSegments: number;
+        readonly arc: number;
     };
 
+    /** @internal */
     static fromJSON(data: any): TorusGeometry;
 }

three/src/geometries/TorusKnotGeometry.d.ts

@@ -1,13 +1,29 @@
 import { BufferGeometry } from './../core/BufferGeometry';
 
+/**
+ * Creates a torus knot, the particular shape of which is defined by a pair of coprime integers, p and q
+ * If p and q are not coprime, the result will be a torus link.
+ * @example
+ * ```typescript
+ * const geometry = new THREE.TorusKnotGeometry(10, 3, 100, 16);
+ * const material = new THREE.MeshBasicMaterial({
+ *     color: 0xffff00
+ * });
+ * const torusKnot = new THREE.Mesh(geometry, material);
+ * scene.add(torusKnot);
+ * ```
+ * @see {@link https://threejs.org/docs/index.html#api/en/geometries/TorusKnotGeometry | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/geometries/TorusKnotGeometry.js | Source}
+ */
 export class TorusKnotGeometry extends BufferGeometry {
     /**
-     * @param [radius=1]
-     * @param [tube=0.4]
-     * @param [radialSegments=64]
-     * @param [tubularSegments=8]
-     * @param [p=2]
-     * @param [q=3]
+     * Create a new instance of {@link TorusKnotGeometry}
+     * @param radius Radius of the torus.. Default `1`.
+     * @param tube Expects a `Float`. Default `0.4`.
+     * @param tubularSegments Expects a `Integer`. Default `64`.
+     * @param radialSegments Expects a `Integer`. Default `8`.
+     * @param p This value determines, how many times the geometry winds around its axis of rotational symmetry. Expects a `Integer`. Default `2`.
+     * @param q This value determines, how many times the geometry winds around a circle in the interior of the torus. Expects a `Integer`. Default `3`.
      */
     constructor(
         radius?: number,
@@ -19,18 +35,25 @@ export class TorusKnotGeometry extends BufferGeometry {
     );
 
     /**
-     * @default 'TorusKnotGeometry'
+     * A Read-only _string_ to check if `this` object type.
+     * @remarks Sub-classes will update this value.
+     * @defaultValue `TorusKnotGeometry`
      */
-    type: string;
+    override readonly type: string | 'TorusKnotGeometry';
 
-    parameters: {
-        radius: number;
-        tube: number;
-        tubularSegments: number;
-        radialSegments: number;
-        p: number;
-        q: 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 radius: number;
+        readonly tube: number;
+        readonly tubularSegments: number;
+        readonly radialSegments: number;
+        readonly p: number;
+        readonly q: number;
     };
 
-    static fromJSON(data: any): TorusKnotGeometry;
+    /** @internal */
+    static fromJSON(data: {}): TorusKnotGeometry;
 }