@types/three 0.150.2 → 0.152.0

three/src/extras/core/Shape.d.ts

@@ -2,27 +2,77 @@ import { Vector2 } from './../../math/Vector2';
 import { Path } from './Path';
 
 /**
- * Defines a 2d shape plane using paths.
+ * Defines an arbitrary 2d {@link Shape} plane using paths with optional holes
+ * @remarks
+ * It can be used with {@link THREE.ExtrudeGeometry | ExtrudeGeometry}, {@link THREE.ShapeGeometry | ShapeGeometry}, to get points, or to get triangulated faces.
+ * @example
+ * ```typescript
+ * const heartShape = new THREE.Shape();
+ * heartShape.moveTo(25, 25);
+ * heartShape.bezierCurveTo(25, 25, 20, 0, 0, 0);
+ * heartShape.bezierCurveTo(-30, 0, -30, 35, -30, 35);
+ * heartShape.bezierCurveTo(-30, 55, -10, 77, 25, 95);
+ * heartShape.bezierCurveTo(60, 77, 80, 55, 80, 35);
+ * heartShape.bezierCurveTo(80, 35, 80, 0, 50, 0);
+ * heartShape.bezierCurveTo(35, 0, 25, 25, 25, 25);
+ * const extrudeSettings = {
+ *     depth: 8,
+ *     bevelEnabled: true,
+ *     bevelSegments: 2,
+ *     steps: 2,
+ *     bevelSize: 1,
+ *     bevelThickness: 1
+ * };
+ * const geometry = new THREE.ExtrudeGeometry(heartShape, extrudeSettings);
+ * const mesh = new THREE.Mesh(geometry, new THREE.MeshPhongMaterial());
+ * ```
+ * @see Example: {@link https://threejs.org/examples/#webgl_geometry_shapes | geometry / shapes }
+ * @see Example: {@link https://threejs.org/examples/#webgl_geometry_extrude_shapes | geometry / extrude / shapes }
+ * @see Example: {@link https://threejs.org/examples/#webgl_geometry_extrude_shapes2 | geometry / extrude / shapes2 }
+ * @see {@link https://threejs.org/docs/index.html#api/en/extras/core/Shape | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/extras/core/Shape.js | Source}
  */
 export class Shape extends Path {
+    /**
+     * Creates a {@link Shape} from the points
+     * @remarks
+     * The first point defines the offset, then successive points are added to the {@link CurvePath.curves | curves} array as {@link THREE.LineCurve | LineCurves}.
+     * If no points are specified, an empty {@link Shape} is created and the {@link .currentPoint} is set to the origin.
+     * @param points Array of {@link Vector2 | Vector2s}.
+     */
     constructor(points?: Vector2[]);
 
     /**
-     * @default 'Shape'
+     * A Read-only _string_ to check if `this` object type.
+     * @remarks Sub-classes will update this value.
+     * @defaultValue `Shape`
      */
-    type: string;
+    override readonly type: string | 'Shape';
 
+    /**
+     * {@link http://en.wikipedia.org/wiki/Universally_unique_identifier | UUID} of this object instance.
+     * @remarks This gets automatically assigned and shouldn't be edited.
+     */
     uuid: string;
 
     /**
-     * @default []
+     * An array of {@link Path | paths} that define the holes in the shape.
+     * @defaultValue `[]`
      */
     holes: Path[];
 
-    getPointsHoles(divisions: number): Vector2[][];
-
+    /**
+     * Call {@link THREE.Curve.getPoints | getPoints} on the {@link Shape} and the {@link holes} array
+     * @param divisions The fineness of the result. Expects a `Integer`
+     */
     extractPoints(divisions: number): {
         shape: Vector2[];
         holes: Vector2[][];
     };
+
+    /**
+     * Get an array of {@link Vector2 | Vector2's} that represent the holes in the shape.
+     * @param divisions The fineness of the result. Expects a `Integer`
+     */
+    getPointsHoles(divisions: number): Vector2[][];
 }

three/src/extras/core/ShapePath.d.ts

@@ -1,34 +1,99 @@
 import { Vector2 } from './../../math/Vector2';
 import { Shape } from './Shape';
 import { Color } from '../../math/Color';
+import { Path } from './Path';
 
+/**
+ * This class is used to convert a series of shapes to an array of {@link THREE.Path | Path's},
+ * for example an SVG shape to a path (see the example below).
+ * @see Example: {@link https://threejs.org/examples/#webgl_geometry_extrude_shapes2 | geometry / extrude / shapes2}
+ *  @see {@link https://threejs.org/docs/index.html#api/en/extras/core/ShapePath | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/extras/core/ShapePath.js | Source}
+ */
 export class ShapePath {
+    /**
+     * Creates a new {@link ShapePath}
+     * @remarks
+     * Unlike a {@link THREE.Path | Path}, no points are passed in as the {@link ShapePath} is designed to be generated after creation.
+     */
     constructor();
 
     /**
-     * @default 'ShapePath'
+     * A Read-only _string_ to check if `this` object type.
+     * @remarks Sub-classes will update this value.
+     * @defaultValue `ShapePath`
      */
-    type: string;
+    readonly type: 'ShapePath';
 
     /**
-     * @default new THREE.Color()
+     * Array of {@link THREE.Path | Path's}s.
+     * @defaultValue `[]`
      */
-    color: Color;
+    subPaths: Path[];
 
     /**
-     * @default []
+     * The current {@link THREE.Path | Path} that is being generated.
+     * @defaultValue `null`
      */
-    subPaths: any[];
+    readonly currentPath: Path | null;
 
     /**
-     * @default null
+     * {@link THREE.Color | Color} of the shape, by default set to white _(0xffffff)_.
+     * @defaultValue `new THREE.Color()`
      */
-    currentPath: any;
+    color: Color;
 
+    /**
+     * Starts a new {@link THREE.Path | Path} and calls {@link THREE.Path.moveTo | Path.moveTo}( x, y ) on that {@link THREE.Path | Path}
+     * @remarks
+     * Also points {@link ShapePath.currentPath | currentPath} to that {@link THREE.Path | Path}.
+     * @param x Expects a `Float`
+     * @param y Expects a `Float`
+     */
     moveTo(x: number, y: number): this;
+
+    /**
+     * This creates a line from the {@link ShapePath.currentPath | currentPath}'s offset to X and Y and updates the offset to X and Y.
+     * @param x Expects a `Float`
+     * @param y Expects a `Float`
+     */
     lineTo(x: number, y: number): this;
+
+    /**
+     * This creates a quadratic curve from the {@link ShapePath.currentPath | currentPath}'s
+     * offset to _x_ and _y_ with _cpX_ and _cpY_ as control point and updates the {@link ShapePath.currentPath | currentPath}'s offset to _x_ and _y_.
+     * @param cpX Expects a `Float`
+     * @param cpY Expects a `Float`
+     * @param x Expects a `Float`
+     * @param y Expects a `Float`
+     */
     quadraticCurveTo(aCPx: number, aCPy: number, aX: number, aY: number): this;
+
+    /**
+     * This creates a bezier curve from the {@link ShapePath.currentPath | currentPath}'s
+     * offset to _x_ and _y_ with _cp1X_, _cp1Y_ and _cp2X_, _cp2Y_ as control points and
+     * updates the {@link ShapePath.currentPath | currentPath}'s offset to _x_ and _y_.
+     * @param cp1X Expects a `Float`
+     * @param cp1Y Expects a `Float`
+     * @param cp2X Expects a `Float`
+     * @param cp2Y Expects a `Float`
+     * @param x Expects a `Float`
+     * @param y Expects a `Float`
+     */
     bezierCurveTo(aCP1x: number, aCP1y: number, aCP2x: number, aCP2y: number, aX: number, aY: number): this;
+
+    /**
+     * Connects a new {@link THREE.SplineCurve | SplineCurve} onto the {@link ShapePath.currentPath | currentPath}.
+     * @param points An array of {@link THREE.Vector2 | Vector2}s
+     */
     splineThru(pts: Vector2[]): this;
+
+    /**
+     * Converts the {@link ShapePath.subPaths | subPaths} array into an array of Shapes
+     * @remarks
+     * By default solid shapes are defined clockwise (CW) and holes are defined counterclockwise (CCW)
+     * If isCCW is set to true, then those are flipped.
+     * @param isCCW Changes how solids and holes are generated
+     */
     toShapes(isCCW: boolean): Shape[];
 }

three/src/extras/curves/ArcCurve.d.ts

@@ -1,9 +1,41 @@
 import { EllipseCurve } from './EllipseCurve';
+
+/**
+ * Alias for {@link THREE.EllipseCurve | EllipseCurve}.
+ * @see {@link https://threejs.org/docs/index.html#api/en/extras/curves/ArcCurve | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/extras/curves/ArcCurve.js | Source}
+ */
 export class ArcCurve extends EllipseCurve {
-    constructor(aX: number, aY: number, aRadius: number, aStartAngle: number, aEndAngle: number, aClockwise: boolean);
+    /**
+     * This constructor creates a new {@link ArcCurve}.
+     * @param aX The X center of the ellipse. Expects a `Float`. Default is `0`.
+     * @param aY The Y center of the ellipse. Expects a `Float`. Default is `0`.
+     * @param xRadius The radius of the ellipse in the x direction. Expects a `Float`. Default is `1`.
+     * @param yRadius The radius of the ellipse in the y direction. Expects a `Float`. Default is `1`.
+     * @param aStartAngle The start angle of the curve in radians starting from the positive X axis. Default is `0`.
+     * @param aEndAngle The end angle of the curve in radians starting from the positive X axis. Default is `2 x Math.PI`.
+     * @param aClockwise Whether the ellipse is drawn clockwise. Default is `false`.
+     */
+    constructor(
+        aX?: number,
+        aY?: number,
+        aRadius?: number,
+        aStartAngle?: number,
+        aEndAngle?: number,
+        aClockwise?: boolean,
+    );
+
+    /**
+     * Read-only flag to check if a given object is of type {@link ArcCurve}.
+     * @remarks This is a _constant_ value
+     * @defaultValue `true`
+     */
+    readonly isArcCurve = true;
 
     /**
-     * @default 'ArcCurve'
+     * A Read-only _string_ to check if `this` object type.
+     * @remarks Sub-classes will update this value.
+     * @defaultValue `ArcCurve`
      */
-    type: string;
+    override readonly type: string | 'ArcCurve';
 }

three/src/extras/curves/CatmullRomCurve3.d.ts

@@ -1,30 +1,77 @@
 import { Vector3 } from './../../math/Vector3';
 import { Curve } from './../core/Curve';
 
-// Extras / Curves /////////////////////////////////////////////////////////////////////
-export namespace CurveUtils {
-    function tangentQuadraticBezier(t: number, p0: number, p1: number, p2: number): number;
-    function tangentCubicBezier(t: number, p0: number, p1: number, p2: number, p3: number): number;
-    function tangentSpline(t: number, p0: number, p1: number, p2: number, p3: number): number;
-    function interpolate(p0: number, p1: number, p2: number, p3: number, t: number): number;
-}
+export type CurveType = 'centripetal' | 'chordal' | 'catmullrom';
 
+/**
+ * Create a smooth **3D** spline curve from a series of points using the {@link https://en.wikipedia.org/wiki/Centripetal_Catmull-Rom_spline | Catmull-Rom} algorithm.
+ * @example
+ * ```typescript
+ * //Create a closed wavey loop
+ * const curve = new THREE.CatmullRomCurve3([
+ * new THREE.Vector3(-10, 0, 10),
+ * new THREE.Vector3(-5, 5, 5),
+ * new THREE.Vector3(0, 0, 0),
+ * new THREE.Vector3(5, -5, 5),
+ * new THREE.Vector3(10, 0, 10)]);
+ * const points = curve.getPoints(50);
+ * const geometry = new THREE.BufferGeometry().setFromPoints(points);
+ * const material = new THREE.LineBasicMaterial({
+ *     color: 0xff0000
+ * });
+ * // Create the final object to add to the scene
+ * const curveObject = new THREE.Line(geometry, material);
+ * ```
+ * @see Example: {@link https://threejs.org/examples/#webgl_geometry_extrude_splines | WebGL / geometry / extrude / splines}
+ * @see {@link https://threejs.org/docs/index.html#api/en/extras/curves/CatmullRomCurve3 | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/extras/curves/CatmullRomCurve3.js | Source}
+ */
 export class CatmullRomCurve3 extends Curve<Vector3> {
     /**
-     * @param [points=[]]
-     * @param [closed=false]
-     * @param [curveType='centripetal']
-     * @param [tension=0.5]
+     * This constructor creates a new {@link CatmullRomCurve3}.
+     * @param points An array of {@link THREE.Vector3 | Vector3} points
+     * @param closed Whether the curve is closed. Default `false`
+     * @param curveType Type of the curve. Default `centripetal`
+     * @param tension Tension of the curve. Expects a `Float`. Default `0.5`
+     */
+    constructor(points?: Vector3[], closed?: boolean, curveType?: CurveType, tension?: number);
+
+    /**
+     * Read-only flag to check if a given object is of type {@link CatmullRomCurve3}.
+     * @remarks This is a _constant_ value
+     * @defaultValue `true`
+     */
+    readonly isCatmullRomCurve3 = true;
+
+    /**
+     * A Read-only _string_ to check if `this` object type.
+     * @remarks Sub-classes will update this value.
+     * @defaultValue `CatmullRomCurve3`
      */
-    constructor(points?: Vector3[], closed?: boolean, curveType?: string, tension?: number);
+    override readonly type: string | 'CatmullRomCurve3';
 
     /**
-     * @default 'CatmullRomCurve3'
+     * The curve will loop back onto itself when this is true.
+     * @defaultValue `false`
      */
-    type: string;
+    closed: boolean;
 
     /**
-     * @default []
+     * The array of {@link THREE.Vector3 | Vector3} points that define the curve.
+     * @remarks It needs at least two entries.
+     * @defaultValue `[]`
      */
     points: Vector3[];
+
+    /**
+     * Possible values are `centripetal`, `chordal` and `catmullrom`.
+     * @defaultValue `centripetal`
+     */
+    curveType: CurveType;
+
+    /**
+     * When {@link .curveType} is `catmullrom`, defines catmullrom's tension.
+     * @remarks Expects a `Float`
+     */
+    tension: number;
 }

three/src/extras/curves/CubicBezierCurve.d.ts

@@ -1,31 +1,72 @@
 import { Vector2 } from './../../math/Vector2';
 import { Curve } from './../core/Curve';
 
+/**
+ * Create a smooth **2D** {@link http://en.wikipedia.org/wiki/B%C3%A9zier_curve#mediaviewer/File:Bezier_curve.svg | cubic bezier curve},
+ * defined by a start point, endpoint and two control points.
+ * @example
+ * ```typescript
+ * const curve = new THREE.CubicBezierCurve(
+ * new THREE.Vector2(-10, 0),
+ * new THREE.Vector2(-5, 15),
+ * new THREE.Vector2(20, 15),
+ * new THREE.Vector2(10, 0));
+ * const points = curve.getPoints(50);
+ * const geometry = new THREE.BufferGeometry().setFromPoints(points);
+ * const material = new THREE.LineBasicMaterial({
+ *     color: 0xff0000
+ * });
+ * // Create the final object to add to the scene
+ * const curveObject = new THREE.Line(geometry, material);
+ * ```
+ * @see {@link https://threejs.org/docs/index.html#api/en/extras/curves/CubicBezierCurve | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/extras/curves/CubicBezierCurve.js | Source}
+ */
 export class CubicBezierCurve extends Curve<Vector2> {
-    constructor(v0: Vector2, v1: Vector2, v2: Vector2, v3: Vector2);
+    /**
+     * This constructor creates a new {@link CubicBezierCurve}.
+     * @param v0 The starting point. Default is `new THREE.Vector2()`.
+     * @param v1 The first control point. Default is `new THREE.Vector2()`.
+     * @param v2 The second control point. Default is `new THREE.Vector2()`.
+     * @param v3 The ending point. Default is `new THREE.Vector2()`.
+     */
+    constructor(v0?: Vector2, v1?: Vector2, v2?: Vector2, v3?: Vector2);
+
+    /**
+     * Read-only flag to check if a given object is of type {@link CubicBezierCurve}.
+     * @remarks This is a _constant_ value
+     * @defaultValue `true`
+     */
+    readonly isCubicBezierCurve = true;
 
     /**
-     * @default 'CubicBezierCurve'
+     * A Read-only _string_ to check if `this` object type.
+     * @remarks Sub-classes will update this value.
+     * @defaultValue `CubicBezierCurve`
      */
-    type: string;
+    override readonly type: string | 'CubicBezierCurve';
 
     /**
-     * @default new THREE.Vector2()
+     * The starting point.
+     * @defaultValue `new THREE.Vector2()`
      */
     v0: Vector2;
 
     /**
-     * @default new THREE.Vector2()
+     * The first control point.
+     * @defaultValue `new THREE.Vector2()`
      */
     v1: Vector2;
 
     /**
-     * @default new THREE.Vector2()
+     * The second control point.
+     * @defaultValue `new THREE.Vector2()`
      */
     v2: Vector2;
 
     /**
-     * @default new THREE.Vector2()
+     * The ending point.
+     * @defaultValue `new THREE.Vector2()`
      */
     v3: Vector2;
 }

three/src/extras/curves/CubicBezierCurve3.d.ts

@@ -1,31 +1,72 @@
 import { Vector3 } from './../../math/Vector3';
 import { Curve } from './../core/Curve';
 
+/**
+ * Create a smooth **3D** {@link http://en.wikipedia.org/wiki/B%C3%A9zier_curve#mediaviewer/File:Bezier_curve.svg | cubic bezier curve},
+ * defined by a start point, endpoint and two control points.
+ * @example
+ * ```typescript
+ * const curve = new THREE.CubicBezierCurve(
+ * new THREE.Vector2(-10, 0),
+ * new THREE.Vector2(-5, 15),
+ * new THREE.Vector2(20, 15),
+ * new THREE.Vector2(10, 0));
+ * const points = curve.getPoints(50);
+ * const geometry = new THREE.BufferGeometry().setFromPoints(points);
+ * const material = new THREE.LineBasicMaterial({
+ *     color: 0xff0000
+ * });
+ * // Create the final object to add to the scene
+ * const curveObject = new THREE.Line(geometry, material);
+ * ```
+ * @see {@link https://threejs.org/docs/index.html#api/en/extras/curves/CubicBezierCurve | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/extras/curves/CubicBezierCurve.js | Source}
+ */
 export class CubicBezierCurve3 extends Curve<Vector3> {
-    constructor(v0: Vector3, v1: Vector3, v2: Vector3, v3: Vector3);
+    /**
+     * This constructor creates a new {@link CubicBezierCurve3}.
+     * @param v0 The starting point. Default is `new THREE.Vector3()`.
+     * @param v1 The first control point. Default is `new THREE.Vector3()`.
+     * @param v2 The second control point. Default is `new THREE.Vector3()`.
+     * @param v3 The ending point. Default is `new THREE.Vector3()`.
+     */
+    constructor(v0?: Vector3, v1?: Vector3, v2?: Vector3, v3?: Vector3);
+
+    /**
+     * Read-only flag to check if a given object is of type {@link CubicBezierCurve3}.
+     * @remarks This is a _constant_ value
+     * @defaultValue `true`
+     */
+    readonly isCubicBezierCurve3 = true;
 
     /**
-     * @default 'CubicBezierCurve3'
+     * A Read-only _string_ to check if `this` object type.
+     * @remarks Sub-classes will update this value.
+     * @defaultValue `CubicBezierCurve3`
      */
-    type: string;
+    override readonly type: string | 'CubicBezierCurve3';
 
     /**
-     * @default new THREE.Vector3()
+     * The starting point.
+     * @defaultValue `new THREE.Vector3()`.
      */
     v0: Vector3;
 
     /**
-     * @default new THREE.Vector3()
+     * The first control point.
+     * @defaultValue `new THREE.Vector3()`.
      */
     v1: Vector3;
 
     /**
-     * @default new THREE.Vector3()
+     * The second control point.
+     * @defaultValue `new THREE.Vector3()`.
      */
     v2: Vector3;
 
     /**
-     * @default new THREE.Vector3()
+     * The ending point.
+     * @defaultValue `new THREE.Vector3()`.
      */
     v3: Vector3;
 }

three/src/extras/curves/EllipseCurve.d.ts

@@ -1,60 +1,115 @@
 import { Curve } from './../core/Curve';
 import { Vector2 } from '../../math/Vector2';
 
+/**
+ * Creates a 2d curve in the shape of an ellipse
+ * @remarks
+ * Setting the {@link xRadius} equal to the {@link yRadius} will result in a circle.
+ * @example
+ * ```typescript
+ * const curve = new THREE.EllipseCurve(
+ *   0,  0,  // ax, aY
+ *   10, 10, // xRadius, yRadius
+ *   0,  2 * Math.PI, // aStartAngle, aEndAngle
+ *   false,  // aClockwise
+ *   0       // aRotation
+ *   );
+ * const points = curve.getPoints(50);
+ * const geometry = new THREE.BufferGeometry().setFromPoints(points);
+ * const material = new THREE.LineBasicMaterial({ color: 0xff0000 });
+ * // Create the final object to add to the scene
+ * const ellipse = new THREE.Line(geometry, material);
+ * ```
+ * @see {@link https://threejs.org/docs/index.html#api/en/extras/curves/EllipseCurve | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/extras/curves/EllipseCurve.js | Source}
+ */
 export class EllipseCurve extends Curve<Vector2> {
+    /**
+     * This constructor creates a new {@link EllipseCurve}.
+     * @param aX The X center of the ellipse. Expects a `Float`. Default is `0`.
+     * @param aY The Y center of the ellipse. Expects a `Float`. Default is `0`.
+     * @param xRadius The radius of the ellipse in the x direction. Expects a `Float`. Default is `1`.
+     * @param yRadius The radius of the ellipse in the y direction. Expects a `Float`. Default is `1`.
+     * @param aStartAngle The start angle of the curve in radians starting from the positive X axis. Default is `0`.
+     * @param aEndAngle The end angle of the curve in radians starting from the positive X axis. Default is `2 x Math.PI`.
+     * @param aClockwise Whether the ellipse is drawn clockwise. Default is `false`.
+     * @param aRotation The rotation angle of the ellipse in radians, counterclockwise from the positive X axis. Default is `0`.
+     */
     constructor(
-        aX: number,
-        aY: number,
-        xRadius: number,
-        yRadius: number,
-        aStartAngle: number,
-        aEndAngle: number,
-        aClockwise: boolean,
-        aRotation: number,
+        aX?: number,
+        aY?: number,
+        xRadius?: number,
+        yRadius?: number,
+        aStartAngle?: number,
+        aEndAngle?: number,
+        aClockwise?: boolean,
+        aRotation?: number,
     );
 
     /**
-     * @default 'EllipseCurve'
+     * Read-only flag to check if a given object is of type {@link EllipseCurve}.
+     * @remarks This is a _constant_ value
+     * @defaultValue `true`
+     */
+    readonly isEllipseCurve = true;
+
+    /**
+     * A Read-only _string_ to check if `this` object type.
+     * @remarks Sub-classes will update this value.
+     * @defaultValue `EllipseCurve`
      */
-    type: string;
+    override readonly type: string | 'EllipseCurve';
 
     /**
-     * @default 0
+     * The X center of the ellipse.
+     * @remarks Expects a `Float`
+     * @defaultValue `0`
      */
     aX: number;
 
     /**
-     * @default 0
+     * The Y center of the ellipse.
+     * @remarks Expects a `Float`
+     * @defaultValue `0`
      */
     aY: number;
 
     /**
-     * @default 1
+     * The radius of the ellipse in the x direction.
+     * @defaultValue `1`
      */
     xRadius: number;
 
     /**
-     * @default 1
+     * The radius of the ellipse in the y direction.
+     * @defaultValue `1`
      */
     yRadius: number;
 
     /**
-     * @default 0
+     * The start angle of the curve in radians starting from the middle right side.
+     * @remarks Expects a `Float`
+     * @defaultValue `0`
      */
     aStartAngle: number;
 
     /**
-     * @default 2 * Math.PI
+     * The end angle of the curve in radians starting from the middle right side.
+     * @remarks Expects a `Float`
+     * @defaultValue `2 * Math.PI`
      */
     aEndAngle: number;
 
     /**
-     * @default false
+     * Whether the ellipse is drawn clockwise.
+     * @defaultValue `false``
      */
     aClockwise: boolean;
 
     /**
-     * @default 0
+     * The rotation angle of the ellipse in radians, counterclockwise from the positive X axis (optional).
+     * @remarks Expects a `Float`
+     * @defaultValue `0`
      */
     aRotation: number;
 }

three/src/extras/curves/LineCurve.d.ts

@@ -1,21 +1,42 @@
 import { Vector2 } from './../../math/Vector2';
 import { Curve } from './../core/Curve';
 
+/**
+ * A curve representing a **2D** line segment.
+ * @see {@link https://threejs.org/docs/index.html#api/en/extras/curves/LineCurve | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/extras/curves/LineCurve.js | Source}
+ */
 export class LineCurve extends Curve<Vector2> {
-    constructor(v1: Vector2, v2: Vector2);
+    /**
+     * This constructor creates a new {@link LineCurve}.
+     * @param v1 The start point. Default is `new THREE.Vector2()`.
+     * @param v2 The end point. Default is `new THREE.Vector2()`.
+     */
+    constructor(v1?: Vector2, v2?: Vector2);
+
+    /**
+     * Read-only flag to check if a given object is of type {@link LineCurve}.
+     * @remarks This is a _constant_ value
+     * @defaultValue `true`
+     */
+    readonly isLineCurve = true;
 
     /**
-     * @default 'LineCurve'
+     * A Read-only _string_ to check if `this` object type.
+     * @remarks Sub-classes will update this value.
+     * @defaultValue `LineCurve`
      */
-    type: string;
+    override readonly type: string | 'LineCurve';
 
     /**
-     * @default new THREE.Vector2()
+     * The start point.
+     * @defaultValue `new THREE.Vector2()`
      */
     v1: Vector2;
 
     /**
-     * @default new THREE.Vector2()
+     * The end point
+     * @defaultValue `new THREE.Vector2()`
      */
     v2: Vector2;
 }