@types/three 0.149.0 → 0.150.1

three/src/core/Raycaster.d.ts

@@ -14,72 +14,132 @@ export interface Face {
 }
 
 export interface Intersection<TIntersected extends Object3D = Object3D> {
+    /** Distance between the origin of the ray and the intersection */
     distance: number;
     distanceToRay?: number | undefined;
+    /** Point of intersection, in world coordinates */
     point: Vector3;
     index?: number | undefined;
+    /** Intersected face */
     face?: Face | null | undefined;
+    /** Index of the intersected face */
     faceIndex?: number | undefined;
+    /** The intersected object */
     object: TIntersected;
     uv?: Vector2 | undefined;
     uv2?: Vector2 | undefined;
+    /** The index number of the instance where the ray intersects the {@link THREE.InstancedMesh | InstancedMesh } */
     instanceId?: number | undefined;
 }
 
 export interface RaycasterParameters {
     Mesh?: any;
     Line?: { threshold: number } | undefined;
+    Line2?: { threshold: number } | undefined;
     LOD?: any;
     Points?: { threshold: number } | undefined;
     Sprite?: any;
 }
 
+/**
+ * This class is designed to assist with {@link https://en.wikipedia.org/wiki/Ray_casting | raycasting}
+ * @remarks
+ * Raycasting is used for mouse picking (working out what objects in the 3d space the mouse is over) amongst other things.
+ * @example
+ * ```typescript
+ * const raycaster = new THREE.Raycaster();
+ * const pointer = new THREE.Vector2();
+ *
+ * function onPointerMove(event) {
+ *     // calculate pointer position in normalized device coordinates (-1 to +1) for both components
+ *     pointer.x = (event.clientX / window.innerWidth) * 2 - 1;
+ *     pointer.y = -(event.clientY / window.innerHeight) * 2 + 1;
+ * }
+ *
+ * function render() {
+ *     // update the picking ray with the camera and pointer position
+ *     raycaster.setFromCamera(pointer, camera);
+ *     // calculate objects intersecting the picking ray
+ *     const intersects = raycaster.intersectObjects(scene.children);
+ *     for (let i = 0; i & lt; intersects.length; i++) {
+ *         intersects[i].object.material.color.set(0xff0000);
+ *     }
+ *     renderer.render(scene, camera);
+ * }
+ * window.addEventListener('pointermove', onPointerMove);
+ * window.requestAnimationFrame(render);
+ * ```
+ * @see Example: {@link https://threejs.org/examples/#webgl_interactive_cubes | Raycasting to a Mesh}
+ * @see Example: {@link https://threejs.org/examples/#webgl_interactive_cubes_ortho | Raycasting to a Mesh in using an OrthographicCamera}
+ * @see Example: {@link https://threejs.org/examples/#webgl_interactive_buffergeometry | Raycasting to a Mesh with BufferGeometry}
+ * @see Example: {@link https://threejs.org/examples/#webgl_instancing_raycast | Raycasting to a InstancedMesh}
+ * @see Example: {@link https://threejs.org/examples/#webgl_interactive_lines | Raycasting to a Line}
+ * @see Example: {@link https://threejs.org/examples/#webgl_interactive_raycasting_points | Raycasting to Points}
+ * @see Example: {@link https://threejs.org/examples/#webgl_geometry_terrain_raycast | Terrain raycasting}
+ * @see Example: {@link https://threejs.org/examples/#webgl_interactive_voxelpainter | Raycasting to paint voxels}
+ * @see Example: {@link https://threejs.org/examples/#webgl_raycaster_texture | Raycast to a Texture}
+ * @see {@link https://threejs.org/docs/index.html#api/en/core/Raycaster | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/core/Raycaster.js | Source}
+ */
 export class Raycaster {
     /**
-     * This creates a new raycaster object.
-     * @param origin The origin vector where the ray casts from.
-     * @param direction The direction vector that gives direction to the ray. Should be normalized.
-     * @param near All results returned are further away than near. Near can't be negative. Default value is 0.
-     * @param far All results returned are closer then far. Far can't be lower then near . Default value is Infinity.
+     * This creates a new {@link Raycaster} object.
+     * @param origin The origin vector where the ray casts from. Default `new Vector3()`
+     * @param direction The direction vector that gives direction to the ray. Should be normalized. Default `new Vector3(0, 0, -1)`
+     * @param near All results returned are further away than near. Near can't be negative. Expects a `Float`. Default `0`
+     * @param far All results returned are closer than far. Far can't be lower than near. Expects a `Float`. Default `Infinity`
      */
     constructor(origin?: Vector3, direction?: Vector3, near?: number, far?: number);
 
-    /** The Ray used for the raycasting. */
+    /**
+     * The {@link THREE.RaycasterRay | Ray} used for the raycasting.
+     */
     ray: Ray;
 
     /**
-     * The near factor of the raycaster. This value indicates which objects can be discarded based on the
-     * distance. This value shouldn't be negative and should be smaller than the far property.
-     * @default 0
+     * The near factor of the raycaster. This value indicates which objects can be discarded based on the distance.
+     * This value shouldn't be negative and should be smaller than the far property.
+     * @remarks Expects a `Float`
+     * @defaultValue `0`
      */
     near: number;
 
     /**
-     * The far factor of the raycaster. This value indicates which objects can be discarded based on the
-     * distance. This value shouldn't be negative and should be larger than the near property.
-     * @default Infinity
+     * The far factor of the raycaster. This value indicates which objects can be discarded based on the distance.
+     * This value shouldn't be negative and should be larger than the near property.
+     * @remarks Expects a `Float`
+     * @defaultValue `Infinity`
      */
     far: number;
 
     /**
-     * The camera to use when raycasting against view-dependent objects such as billboarded objects like Sprites. This field
-     * can be set manually or is set when calling "setFromCamera".
+     * The camera to use when raycasting against view-dependent objects such as billboarded objects like {@link THREE.Sprites | Sprites}.
+     * This field can be set manually or is set when calling  {@link setFromCamera}.
+     * @defaultValue `null`
      */
     camera: Camera;
 
     /**
-     * Used by Raycaster to selectively ignore 3D objects when performing intersection tests.
-     * @default new THREE.Layers()
+     * Used by {@link Raycaster} to selectively ignore 3D objects when performing intersection tests.
+     * The following code example ensures that only 3D objects on layer `1` will be honored by the instance of Raycaster.
+     * ```
+     * raycaster.layers.set( 1 );
+     * object.layers.enable( 1 );
+     * ```
+     * @defaultValue `new THREE.Layers()` - See {@link THREE.Layers | Layers}.
      */
     layers: Layers;
 
     /**
-     * @default { Mesh: {}, Line: { threshold: 1 }, LOD: {}, Points: { threshold: 1 }, Sprite: {} }
+     * An data object where threshold is the precision of the {@link Raycaster} when intersecting objects, in world units.
+     * @defaultValue `{ Mesh: {}, Line: { threshold: 1 }, LOD: {}, Points: { threshold: 1 }, Sprite: {} }`
      */
     params: RaycasterParameters;
 
     /**
-     * Updates the ray with a new origin and direction.
+     * Updates the ray with a new origin and direction
+     * @remarks
+     * Please note that this method only copies the values from the arguments.
      * @param origin The origin vector where the ray casts from.
      * @param direction The normalized direction vector that gives direction to the ray.
      */
@@ -90,13 +150,22 @@ export class Raycaster {
      * @param coords 2D coordinates of the mouse, in normalized device coordinates (NDC)---X and Y components should be between -1 and 1.
      * @param camera camera from which the ray should originate
      */
-    setFromCamera(coords: { x: number; y: number }, camera: Camera): void;
+    setFromCamera(coords: Vector2, camera: Camera): void;
 
     /**
-     * Checks all intersection between the ray and the object with or without the descendants. Intersections are returned sorted by distance, closest first.
+     * Checks all intersection between the ray and the object with or without the descendants
+     * @remarks Intersections are returned sorted by distance, closest first
+     * @remarks {@link Raycaster} delegates to the {@link Object3D.raycast | raycast} method of the passed object, when evaluating whether the ray intersects the object or not
+     * This allows {@link THREE.Mesh | meshes} to respond differently to ray casting than {@link THREE.Line | lines} and {@link THREE.Points | pointclouds}.
+     * **Note** that for meshes, faces must be pointed towards the origin of the {@link Raycaster.ray | ray} in order to be detected;
+     * intersections of the ray passing through the back of a face will not be detected
+     * To raycast against both faces of an object, you'll want to set the {@link Mesh.material | material}'s {@link Material.side | side} property to `THREE.DoubleSide`.
+     * @see {@link intersectObjects | .intersectObjects()}.
      * @param object The object to check for intersection with the ray.
-     * @param recursive If true, it also checks all descendants. Otherwise it only checks intersecton with the object. Default is true.
-     * @param optionalTarget (optional) target to set the result. Otherwise a new Array is instantiated. If set, you must clear this array prior to each call (i.e., array.length = 0;).
+     * @param recursive If true, it also checks all descendants. Otherwise it only checks intersection with the object. Default `true`
+     * @param optionalTarget Target to set the result. Otherwise a new {@link Array | Array} is instantiated.
+     * If set, you must clear this array prior to each call (i.e., array.length = 0;). Default `[]`
+     * @returns An array of intersections is returned.
      */
     intersectObject<TIntersected extends Object3D>(
         object: Object3D,
@@ -105,12 +174,20 @@ export class Raycaster {
     ): Array<Intersection<TIntersected>>;
 
     /**
-     * Checks all intersection between the ray and the objects with or without the descendants.
-     * Intersections are returned sorted by distance, closest first.
-     * Intersections are of the same form as those returned by .intersectObject.
+     * Checks all intersection between the ray and the objects with or without the descendants
+     * @remarks Intersections are returned sorted by distance, closest first
+     * @remarks Intersections are of the same form as those returned by {@link intersectObject | .intersectObject()}.
+     * @remarks {@link Raycaster} delegates to the {@link Object3D.raycast | raycast} method of the passed object, when evaluating whether the ray intersects the object or not
+     * This allows {@link THREE.Mesh | meshes} to respond differently to ray casting than {@link THREE.Line | lines} and {@link THREE.Points | pointclouds}.
+     * **Note** that for meshes, faces must be pointed towards the origin of the {@link Raycaster.ray | ray} in order to be detected;
+     * intersections of the ray passing through the back of a face will not be detected
+     * To raycast against both faces of an object, you'll want to set the {@link Mesh.material | material}'s {@link Material.side | side} property to `THREE.DoubleSide`.
+     * @see {@link intersectObject | .intersectObject()}.
      * @param objects The objects to check for intersection with the ray.
-     * @param recursive If true, it also checks all descendants of the objects. Otherwise it only checks intersecton with the objects. Default is true.
-     * @param optionalTarget (optional) target to set the result. Otherwise a new Array is instantiated. If set, you must clear this array prior to each call (i.e., array.length = 0;).
+     * @param recursive If true, it also checks all descendants of the objects. Otherwise it only checks intersection with the objects. Default `true`
+     * @param optionalTarget Target to set the result. Otherwise a new {@link Array | Array} is instantiated.
+     * If set, you must clear this array prior to each call (i.e., array.length = 0;). Default `[]`
+     * @returns An array of intersections is returned.
      */
     intersectObjects<TIntersected extends Object3D>(
         objects: Object3D[],

three/src/core/Uniform.d.ts

@@ -1,21 +1,38 @@
+/**
+ * Uniforms are global GLSL variables.
+ * They are passed to shader programs.
+ * @example
+ * When declaring a uniform of a {@link THREE.ShaderMaterial | ShaderMaterial}, it is declared by value or by object.
+ * ```typescript
+ * uniforms: {
+ *     time: {
+ *         value: 1.0
+ *     },
+ *     resolution: new Uniform(new Vector2())
+ * };
+ * ```
+ * @see Example: {@link https://threejs.org/examples/#webgl_nodes_materials_instance_uniform | WebGL2 / nodes / materials / instance / uniform}
+ * @see Example: {@link https://threejs.org/examples/#webgpu_instance_uniform| WebGPU / instance / uniform}
+ * @see {@link https://threejs.org/docs/index.html#api/en/core/Uniform | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/core/Uniform.js | Source}
+ */
 export class Uniform<T = any> {
-    constructor(value: T);
     /**
-     * @deprecated
+     * Create a new instance of {@link THREE.Uniform | Uniform}
+     * @param value An object containing the value to set up the uniform. It's type must be one of the Uniform Types described above.
      */
-    constructor(type: string, value: T);
+    constructor(value: T);
+
     /**
-     * @deprecated
+     * Current value of the uniform.
      */
-    type: string;
     value: T;
-    /**
-     * @deprecated Use {@link Object3D#onBeforeRender object.onBeforeRender()} instead.
-     */
-    dynamic: boolean;
 
     /**
-     * @deprecated Use {@link Object3D#onBeforeRender object.onBeforeRender()} instead.
+     * Returns a clone of this uniform.
+     * @remarks
+     * If the uniform's {@link value} property is an {@link Object | Object} with a `clone()` method, this is used,
+     * otherwise the value is copied by assignment Array values are **shared** between cloned {@link THREE.UniformUniform | Uniform}s.
      */
-    onUpdate(callback: () => void): Uniform<T>;
+    clone(): Uniform<T>;
 }

three/src/core/UniformsGroup.d.ts

@@ -1,15 +1,21 @@
 import { EventDispatcher } from './EventDispatcher';
 import { Uniform } from './Uniform';
-
 import { Usage } from '../constants';
 
+/**
+ * @see Example: {@link https://threejs.org/examples/#webgl2_ubo | WebGL2 / UBO}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/core/UniformsGroup.js | Source}
+ */
 export class UniformsGroup extends EventDispatcher {
-    isUniformsGroup: true;
+    constructor();
+
+    readonly isUniformsGroup: true;
+
     id: number;
+
     usage: Usage;
-    uniforms: Uniform[];
 
-    constructor();
+    uniforms: Uniform[];
 
     add(uniform: Uniform): this;
 

three/src/extras/Earcut.d.ts

@@ -1,4 +1,3 @@
-import { Triangle } from '../Three';
-export namespace Earcut {
-    function triangulate(data: number[], holeIndices: number[], dim: number): Triangle[];
-}
+export const Earcut: {
+    triangulate(data: number[], holeIndices?: number[], dim?: number): number[];
+};

three/src/geometries/BoxGeometry.d.ts

@@ -1,13 +1,29 @@
 import { BufferGeometry } from '../core/BufferGeometry';
 
+/**
+ * {@link BoxGeometry} is a geometry class for a rectangular cuboid with a given 'width', 'height', and 'depth'
+ * @remarks On creation, the cuboid is centred on the origin, with each edge parallel to one of the axes.
+ * @example
+ * ```typescript
+ * const geometry = new THREE.BoxGeometry(1, 1, 1);
+ * const material = new THREE.MeshBasicMaterial({
+ *     color: 0x00ff00
+ * });
+ * const cube = new THREE.Mesh(geometry, material);
+ * scene.add(cube);
+ * ```
+ * @see {@link https://threejs.org/docs/index.html#api/en/geometries/BoxGeometry | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/geometries/BoxGeometry.js | Source}
+ */
 export class BoxGeometry 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 [depth=1] — Depth of the sides on the Z 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.
-     * @param [depthSegments=1] — Number of segmented faces along the depth of the sides.
+     * Create a new instance of {@link BoxGeometry}
+     * @param width Width; that is, the length of the edges parallel to the X axis. Optional; Expects a `Float`. Default `1`
+     * @param height Height; that is, the length of the edges parallel to the Y axis. Optional; Expects a `Float`. Default `1`
+     * @param depth Depth; that is, the length of the edges parallel to the Z axis. Optional; Expects a `Float`. Default `1`
+     * @param widthSegments Number of segmented rectangular faces along the width of the sides. Optional; Expects a `Integer`. Default `1`
+     * @param heightSegments Number of segmented rectangular faces along the height of the sides. Optional; Expects a `Integer`. Default `1`
+     * @param depthSegments Number of segmented rectangular faces along the depth of the sides. Optional; Expects a `Integer`. Default `1`
      */
     constructor(
         width?: number,
@@ -19,18 +35,25 @@ export class BoxGeometry extends BufferGeometry {
     );
 
     /**
-     * @default 'BoxGeometry'
+     * A Read-only _string_ to check if `this` object type.
+     * @remarks Sub-classes will update this value.
+     * @defaultValue `BoxGeometry`
      */
-    type: string;
+    override readonly type: string | 'BoxGeometry';
 
-    parameters: {
-        width: number;
-        height: number;
-        depth: number;
-        widthSegments: number;
-        heightSegments: number;
-        depthSegments: 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 depth: number;
+        readonly widthSegments: number;
+        readonly heightSegments: number;
+        readonly depthSegments: number;
     };
 
-    static fromJSON(data: any): BoxGeometry;
+    /** @internal */
+    static fromJSON(data: {}): BoxGeometry;
 }

three/src/geometries/CapsuleGeometry.d.ts

@@ -1,25 +1,48 @@
 import { BufferGeometry } from '../core/BufferGeometry';
 
+/**
+ * {@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 {
     /**
-     * @param [radius=1] — Radius of the capsule.
-     * @param [length=1] — Length of the middle section.
-     * @param [capSegments=4] — Number of curve segments used to build the caps.
-     * @param [radialSegments=8] — Number of segmented faces around the circumference of the capsule.
+     * 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 capSubdivisions 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);
 
     /**
-     * @default 'CapsuleGeometry'
+     * A Read-only _string_ to check if `this` object type.
+     * @remarks Sub-classes will update this value.
+     * @defaultValue `CapsuleGeometry`
      */
-    type: string;
+    override readonly type: string | 'CapsuleGeometry';
 
-    parameters: {
-        radius: number;
-        length: number;
-        capSegments: number;
-        radialSegments: 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 length: number;
+        readonly capSegments: number;
+        readonly radialSegments: number;
     };
 
-    static fromJSON(data: any): CapsuleGeometry;
+    /** @internal */
+    static fromJSON(data: {}): CapsuleGeometry;
 }

three/src/geometries/CircleGeometry.d.ts

@@ -1,25 +1,51 @@
 import { BufferGeometry } from '../core/BufferGeometry';
 
+/**
+ * {@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 {
     /**
-     * @param radius - Radius of the circle, default = 1.
-     * @param segments - Number of segments (triangles), minimum = 3, default = 32.
-     * @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. The default is 2*Pi, which makes for a complete circle.
+     * 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);
 
     /**
-     * @default 'CircleGeometry'
+     * A Read-only _string_ to check if `this` object type.
+     * @remarks Sub-classes will update this value.
+     * @defaultValue `CircleGeometry`
      */
-    type: string;
+    override readonly type: string | 'CircleGeometry';
 
-    parameters: {
-        radius: number;
-        segments: 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 segments: number;
+        readonly thetaStart: number;
+        readonly thetaLength: number;
     };
 
-    static fromJSON(data: any): CircleGeometry;
+    /** @internal */
+    static fromJSON(data: {}): CircleGeometry;
 }

three/src/geometries/ConeGeometry.d.ts

@@ -1,14 +1,29 @@
 import { CylinderGeometry } from './CylinderGeometry';
 
+/**
+ * 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 {
     /**
-     * @param radius - Radius of the cone base. Default is 1.
-     * @param height - Height of the cone. Default is 1.
-     * @param radialSegments - Number of segmented faces around the circumference of the cone. Default is 32
-     * @param heightSegments - Number of rows of faces along the height of the cone. Default is 1.
-     * @param openEnded - A Boolean indicating whether the base of the cone is open or capped. Default is 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. The default is 2*Pi, which makes for a complete cone.
+     * 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,
@@ -21,9 +36,29 @@ export class ConeGeometry extends CylinderGeometry {
     );
 
     /**
-     * @default 'ConeGeometry'
+     * A Read-only _string_ to check if `this` object type.
+     * @remarks Sub-classes will update this value.
+     * @defaultValue `ConeGeometry`
      */
-    type: string;
+    override readonly type: string | 'ConeGeometry';
 
-    static fromJSON(data: any): 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;
 }

three/src/geometries/CylinderGeometry.d.ts

@@ -1,15 +1,30 @@
 import { BufferGeometry } from '../core/BufferGeometry';
 
+/**
+ * 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 {
     /**
-     * @param radiusTop - Radius of the cylinder at the top. Default is 1.
-     * @param radiusBottom - Radius of the cylinder at the bottom. Default is 1.
-     * @param height - Height of the cylinder. Default is 1.
-     * @param radialSegments - Number of segmented faces around the circumference of the cylinder. Default is 32
-     * @param heightSegments - Number of rows of faces along the height of the cylinder. Default is 1.
-     * @param openEnded - A Boolean indicating whether the ends of the cylinder are open or capped. Default is 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. The default is 2*Pi, which makes for a complete cylinder.
+     * 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,
@@ -23,20 +38,27 @@ export class CylinderGeometry extends BufferGeometry {
     );
 
     /**
-     * @default 'CylinderGeometry'
+     * A Read-only _string_ to check if `this` object type.
+     * @remarks Sub-classes will update this value.
+     * @defaultValue `CylinderGeometry`
      */
-    type: string;
+    override readonly type: string | 'CylinderGeometry';
 
-    parameters: {
-        radiusTop: number;
-        radiusBottom: number;
-        height: number;
-        radialSegments: number;
-        heightSegments: number;
-        openEnded: boolean;
-        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 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;
 }