@types/three 0.181.0 → 0.183.0

three/src/lights/RectAreaLight.d.ts

@@ -2,81 +2,61 @@ import { ColorRepresentation } from "../math/Color.js";
 import { Light } from "./Light.js";
 
 /**
- * {@link RectAreaLight} emits light uniformly across the face a rectangular plane
- * @remarks
- * This light type can be used to simulate light sources such as bright windows or strip lighting.
+ * This class emits light uniformly across the face a rectangular plane.
+ * This light type can be used to simulate light sources such as bright
+ * windows or strip lighting.
+ *
  * Important Notes:
- *  - There is no shadow support.
- *  - Only {@link MeshStandardMaterial | MeshStandardMaterial} and {@link MeshPhysicalMaterial | MeshPhysicalMaterial} are supported.
- *  - You have to include {@link https://threejs.org/examples/jsm/lights/RectAreaLightUniformsLib.js | RectAreaLightUniformsLib} into your scene and call `init()`.
- * @example
- * ```typescript
- * const width = 10;
- * const height = 10;
- * const intensity = 1;
- * const rectLight = new THREE.RectAreaLight(0xffffff, intensity, width, height);
- * rectLight.position.set(5, 5, 0);
- * rectLight.lookAt(0, 0, 0);
- * scene.add(rectLight)
- * const rectLightHelper = new RectAreaLightHelper(rectLight);
- * rectLight.add(rectLightHelper);
+ *
+ * - There is no shadow support.
+ * - Only PBR materials are supported.
+ * - You have to include `RectAreaLightUniformsLib` (`WebGLRenderer`) or `RectAreaLightTexturesLib` (`WebGPURenderer`)
+ * into your app and init the uniforms/textures.
+ *
+ * ```js
+ * RectAreaLightUniformsLib.init(); // only relevant for WebGLRenderer
+ * THREE.RectAreaLightNode.setLTC( RectAreaLightTexturesLib.init() ); //  only relevant for WebGPURenderer
+ *
+ * const intensity = 1; const width = 10; const height = 10;
+ * const rectLight = new THREE.RectAreaLight( 0xffffff, intensity, width, height );
+ * rectLight.position.set( 5, 5, 0 );
+ * rectLight.lookAt( 0, 0, 0 );
+ * scene.add( rectLight )
  * ```
- * @see Example: {@link https://threejs.org/examples/#webgl_lights_rectarealight | WebGL / {@link RectAreaLight} }
- * @see {@link https://threejs.org/docs/index.html#api/en/lights/RectAreaLight | Official Documentation}
- * @see {@link https://github.com/mrdoob/three.js/blob/master/src/lights/RectAreaLight.js | Source}
  */
-export class RectAreaLight extends Light<undefined> {
+export class RectAreaLight extends Light {
     /**
-     * Creates a new {@link RectAreaLight}.
-     * @param color Hexadecimal color of the light. Default `0xffffff` _(white)_.
-     * @param intensity The light's intensity, or brightness. Expects a `Float`. Default `1`
-     * @param width Width of the light. Expects a `Float`. Default `10`
-     * @param height Height of the light. Expects a `Float`. Default `10`
+     * Constructs a new area light.
+     *
+     * @param {(number|Color|string)} [color=0xffffff] - The light's color.
+     * @param {number} [intensity=1] - The light's strength/intensity.
+     * @param {number} [width=10] - The width of the light.
+     * @param {number} [height=10] - The height of the light.
      */
     constructor(color?: ColorRepresentation, intensity?: number, width?: number, height?: number);
-
     /**
-     * Read-only flag to check if a given object is of type {@link RectAreaLight}.
-     * @remarks This is a _constant_ value
-     * @defaultValue `true`
+     * This flag can be used for type testing.
+     *
+     * @default true
      */
-    readonly isRectAreaLight: true;
-
-    /**
-     * A Read-only _string_ to check if `this` object type.
-     * @remarks Sub-classes will update this value.
-     * @defaultValue `RectAreaLight`
-     */
-    override readonly type: string | "RectAreaLight";
-
+    readonly isRectAreaLight: boolean;
     /**
      * The width of the light.
-     * @remarks Expects a `Float`
-     * @defaultValue `10`
+     *
+     * @default 10
      */
     width: number;
-
     /**
      * The height of the light.
-     * @remarks Expects a `Float`
-     * @defaultValue `10`
+     *
+     * @default 10
      */
     height: number;
-
-    /**
-     * The light's intensity.
-     * @remarks Changing the intensity will also change the light's power.
-     * When **{@link WebGLRenderer.useLegacyLights | legacy lighting mode} is disabled** — intensity is the luminance (brightness) of the light measured in nits (cd/m^2).
-     * @remarks Expects a `Float`
-     * @defaultValue `1`
-     */
-    intensity: number;
-
+    set power(power: number);
     /**
-     * The light's power.
-     * @remarks Changing the power will also change the light's intensity.
-     * When **{@link WebGLRenderer.useLegacyLights | legacy lighting mode} is disabled** — power is the luminous power of the light measured in lumens (lm).
-     * @remarks Expects a `Float`
+     * The light's power. Power is the luminous power of the light measured in lumens (lm).
+     * Changing the power will also change the light's intensity.
      */
-    power: number;
+    get power(): number;
+    copy(source: RectAreaLight): this;
 }

three/src/lights/SpotLight.d.ts

@@ -1,40 +1,52 @@
-import { Object3D } from "../core/Object3D.js";
+import { JSONMeta, Object3D } from "../core/Object3D.js";
 import { ColorRepresentation } from "../math/Color.js";
-import { Vector3 } from "../math/Vector3.js";
 import { Texture } from "../textures/Texture.js";
-import { Light } from "./Light.js";
+import { Light, LightJSON } from "./Light.js";
+import { LightShadowJSON } from "./LightShadow.js";
 import { SpotLightShadow } from "./SpotLightShadow.js";
 
+export interface SpotLightJSON extends LightJSON {
+    distance: number;
+    angle: number;
+    decay: number;
+    penumbra: number;
+
+    target: string;
+    map?: string | undefined;
+
+    shadow: LightShadowJSON;
+}
+
 /**
- * This light gets emitted from a single point in one direction, along a cone that increases in size the further from the light it gets.
- * @example
- * ```typescript
- * // white {@link SpotLight} shining from the side, modulated by a texture, casting a shadow
- * const {@link SpotLight} = new THREE.SpotLight(0xffffff);
- * spotLight.position.set(100, 1000, 100);
- * spotLight.map = new THREE.TextureLoader().load(url);
+ * This light gets emitted from a single point in one direction, along a cone
+ * that increases in size the further from the light it gets.
+ *
+ * This light can cast shadows - see the {@link SpotLightShadow} for details.
+ *
+ * ```js
+ * // white spotlight shining from the side, modulated by a texture
+ * const spotLight = new THREE.SpotLight( 0xffffff );
+ * spotLight.position.set( 100, 1000, 100 );
+ * spotLight.map = new THREE.TextureLoader().load( url );
+ *
  * spotLight.castShadow = true;
  * spotLight.shadow.mapSize.width = 1024;
  * spotLight.shadow.mapSize.height = 1024;
  * spotLight.shadow.camera.near = 500;
  * spotLight.shadow.camera.far = 4000;
- * spotLight.shadow.camera.fov = 30;
- * scene.add(spotLight);
+ * spotLight.shadow.camera.fov = 30;s
  * ```
- * @see Example: {@link https://threejs.org/examples/#webgl_lights_spotlight | lights / {@link SpotLight} }
- * @see Example: {@link https://threejs.org/examples/#webgl_lights_spotlights | lights / spotlights }
- * @see {@link https://threejs.org/docs/index.html#api/en/lights/SpotLight | Official Documentation}
- * @see {@link https://github.com/mrdoob/three.js/blob/master/src/lights/SpotLight.js | Source}
  */
-export class SpotLight extends Light<SpotLightShadow> {
+export class SpotLight extends Light {
     /**
-     * Creates a new SpotLight.
-     * @param color Hexadecimal color of the light. Default `0xffffff` _(white)_.
-     * @param intensity Numeric value of the light's strength/intensity. Expects a `Float`. Default `1`.
-     * @param distance Maximum range of the light. Default is 0 (no limit). Expects a `Float`.
-     * @param angle Maximum angle of light dispersion from its direction whose upper bound is Math.PI/2.
-     * @param penumbra Percent of the {@link SpotLight} cone that is attenuated due to penumbra. Takes values between zero and 1. Expects a `Float`. Default `0`.
-     * @param decay The amount the light dims along the distance of the light. Expects a `Float`. Default `2`.
+     * Constructs a new spot light.
+     *
+     * @param {(number|Color|string)} [color=0xffffff] - The light's color.
+     * @param {number} [intensity=1] - The light's strength/intensity measured in candela (cd).
+     * @param {number} [distance=0] - Maximum range of the light. `0` means no limit.
+     * @param {number} [angle=Math.PI/3] - Maximum angle of light dispersion from its direction whose upper bound is `Math.PI/2`.
+     * @param {number} [penumbra=0] - Percent of the spotlight cone that is attenuated due to penumbra. Value range is `[0,1]`.
+     * @param {number} [decay=2] - The amount the light dims along the distance of the light.
      */
     constructor(
         color?: ColorRepresentation,
@@ -44,121 +56,70 @@ export class SpotLight extends Light<SpotLightShadow> {
         penumbra?: number,
         decay?: number,
     );
-
-    /**
-     * Read-only flag to check if a given object is of type {@link SpotLight}.
-     * @remarks This is a _constant_ value
-     * @defaultValue `true`
-     */
-    readonly isSpotLight: true;
-
     /**
-     * A Read-only _string_ to check if `this` object type.
-     * @remarks Sub-classes will update this value.
-     * @defaultValue `SpotLight`
+     * This flag can be used for type testing.
+     *
+     * @default true
      */
-    override readonly type: string | "SpotLight";
-
+    readonly isSpotLight: boolean;
     /**
-     * This is set equal to {@link THREE.Object3D.DEFAULT_UP | Object3D.DEFAULT_UP} (0, 1, 0), so that the light shines from the top down.
-     * @defaultValue `{@link Object3D.DEFAULT_UP}`
-     */
-    readonly position: Vector3;
-
-    /**
-     * The {@link SpotLight} points from its {@link SpotLight.position | position} to target.position.
-     * @remarks
-     * **Note**: For the target's position to be changed to anything other than the default,
-     * it must be added to the {@link Scene | scene} using
+     * The spot light points from its position to the
+     * target's position.
      *
-     * ```typescript
-     * scene.add( light.target );
-     * ```
+     * For the target's position to be changed to anything other
+     * than the default, it must be added to the scene.
      *
-     * This is so that the target's {@link Object3D.matrixWorld | matrixWorld} gets automatically updated each frame.
-     * It is also possible to set the target to be another object in the scene (anything with a {@link THREE.Object3D.position | position} property), like so:
-     * ```typescript
-     * const targetObject = new THREE.Object3D();
-     * scene.add(targetObject);
-     * light.target = targetObject;
-     * ```
-     * The {@link SpotLight} will now track the target object.
-     * @defaultValue `new THREE.Object3D()` _The default position of the target is *(0, 0, 0)*._
+     * It is also possible to set the target to be another 3D object
+     * in the scene. The light will now track the target object.
      */
     target: Object3D;
-
-    /**
-     * If set to `true` light will cast dynamic shadows.
-     * @remarks  **Warning**: This is expensive and requires tweaking to get shadows looking right. the {@link THREE.SpotLightShadow | SpotLightShadow} for details.
-     * @defaultValue `false`
-     */
-    override castShadow: boolean;
-
     /**
-     * The light's intensity.
-     * @remarks Changing the intensity will also change the light's power.
-     * When **{@link WebGLRenderer.useLegacyLights | legacy lighting mode} is disabled** — intensity is the luminous intensity of the light measured in candela (cd).
-     * @remarks Expects a `Float`
-     * @defaultValue `1`
-     */
-    intensity: number;
-
-    /**
-     * When **Default mode** — When distance is zero, light does not attenuate. When distance is non-zero,
-     * light will attenuate linearly from maximum intensity at the light's position down to zero at this distance from the light.
+     * Maximum range of the light. `0` means no limit.
      *
-     * When **{@link WebGLRenderer.useLegacyLights | legacy lighting mode} is disabled** — When distance is zero,
-     * light will attenuate according to inverse-square law to infinite distance.
-     * When distance is non-zero, light will attenuate according to inverse-square law until near the distance cutoff,
-     * where it will then attenuate quickly and smoothly to `0`. Inherently, cutoffs are not physically correct.
-     * @remarks Expects a `Float`
-     * @defaultValue `0.0`
+     * @default 0
      */
     distance: number;
-
     /**
-     * Maximum extent of the spotlight, in radians, from its direction.
-     * @remarks Should be no more than `Math.PI/2`.
-     * @remarks Expects a `Float`
-     * @defaultValue `Math.PI / 3`
+     * Maximum angle of light dispersion from its direction whose upper bound is `Math.PI/2`.
+     *
+     * @default Math.PI/3
      */
     angle: number;
-
     /**
-     * The amount the light dims along the distance of the light.
-     * In context of physically-correct rendering the default value should not be changed.
-     * @remarks Expects a `Float`
-     * @defaultValue `2`
+     * Percent of the spotlight cone that is attenuated due to penumbra.
+     * Value range is `[0,1]`.
+     *
+     * @default 0
      */
-    decay: number;
-
+    penumbra: number;
     /**
-     * A {@link THREE.SpotLightShadow | SpotLightShadow} used to calculate shadows for this light.
-     * @defaultValue `new THREE.SpotLightShadow()`
+     * The amount the light dims along the distance of the light. In context of
+     * physically-correct rendering the default value should not be changed.
+     *
+     * @default 2
      */
-    shadow: SpotLightShadow;
-
+    decay: number;
     /**
-     * The light's power.
-     * @remarks Changing the power will also change the light's intensity.
-     * When **{@link WebGLRenderer.useLegacyLights | legacy lighting mode} is disabled** —  power is the luminous power of the light measured in lumens (lm).
-     * @remarks Expects a `Float`
+     * A texture used to modulate the color of the light. The spot light
+     * color is mixed with the RGB value of this texture, with a ratio
+     * corresponding to its alpha value. The cookie-like masking effect is
+     * reproduced using pixel values (0, 0, 0, 1-cookie_value).
+     *
+     * *Warning*: This property is disabled if {@link Object3D#castShadow} is set to `false`.
+     *
+     * @default null
      */
-    power: number;
-
+    map: Texture | null;
     /**
-     * Percent of the {@link SpotLight} cone that is attenuated due to penumbra.
-     * @remarks Takes values between zero and 1.
-     * @remarks Expects a `Float`
-     * @defaultValue `0.0`
+     * This property holds the light's shadow configuration.
      */
-    penumbra: number;
-
+    shadow: SpotLightShadow;
+    set power(power: number);
     /**
-     * A {@link THREE.Texture | Texture} used to modulate the color of the light.
-     * The spot light color is mixed with the _RGB_ value of this texture, with a ratio corresponding to its alpha value.
-     * The cookie-like masking effect is reproduced using pixel values (0, 0, 0, 1-cookie_value).
-     * @remarks **Warning**: {@link SpotLight.map} is disabled if {@link SpotLight.castShadow} is `false`.
+     * The light's power. Power is the luminous power of the light measured in lumens (lm).
+     *  Changing the power will also change the light's intensity.
      */
-    map: Texture | null;
+    get power(): number;
+    copy(source: SpotLight, recursive?: boolean): this;
+    toJSON(meta?: JSONMeta): SpotLightJSON;
 }

three/src/lights/SpotLightShadow.d.ts

@@ -2,73 +2,31 @@ import { PerspectiveCamera } from "../cameras/PerspectiveCamera.js";
 import { LightShadow } from "./LightShadow.js";
 
 /**
- * This is used internally by {@link SpotLight | SpotLights} for calculating shadows.
- * @example
- * ```typescript
- * //Create a WebGLRenderer and turn on shadows in the renderer
- * const renderer = new THREE.WebGLRenderer();
- * renderer.shadowMap.enabled = true;
- * renderer.shadowMap.type = THREE.PCFSoftShadowMap; // default THREE.PCFShadowMap
- * //Create a SpotLight and turn on shadows for the light
- * const light = new THREE.SpotLight(0xffffff);
- * light.castShadow = true; // default false
- * scene.add(light);
- * //Set up shadow properties for the light
- * light.shadow.mapSize.width = 512; // default
- * light.shadow.mapSize.height = 512; // default
- * light.shadow.camera.near = 0.5; // default
- * light.shadow.camera.far = 500; // default
- * light.shadow.focus = 1; // default
- * //Create a sphere that cast shadows (but does not receive them)
- * const sphereGeometry = new THREE.SphereGeometry(5, 32, 32);
- * const sphereMaterial = new THREE.MeshStandardMaterial({
- *     color: 0xff0000
- * });
- * const sphere = new THREE.Mesh(sphereGeometry, sphereMaterial);
- * sphere.castShadow = true; //default is false
- * sphere.receiveShadow = false; //default
- * scene.add(sphere);
- * //Create a plane that receives shadows (but does not cast them)
- * const planeGeometry = new THREE.PlaneGeometry(20, 20, 32, 32);
- * const planeMaterial = new THREE.MeshStandardMaterial({
- *     color: 0x00ff00
- * })
- * const plane = new THREE.Mesh(planeGeometry, planeMaterial);
- * plane.receiveShadow = true;
- * scene.add(plane);
- * //Create a helper for the shadow camera (optional)
- * const helper = new THREE.CameraHelper(light.shadow.camera);
- * scene.add(helper);
- * ```
- * @see {@link https://threejs.org/docs/index.html#api/en/lights/shadows/SpotLightShadow | Official Documentation}
- * @see {@link https://github.com/mrdoob/three.js/blob/master/src/lights/SpotLightShadow.js | Source}
+ * Represents the shadow configuration of directional lights.
  */
 export class SpotLightShadow extends LightShadow<PerspectiveCamera> {
     /**
-     * Read-only flag to check if a given object is of type {@link SpotLightShadow}.
-     * @remarks This is a _constant_ value
-     * @defaultValue `true`
+     * Constructs a new spot light shadow.
      */
-    readonly isSpotLightShadow: true;
-
+    constructor();
     /**
-     * The light's view of the world.
-     * @remarks This is used to generate a depth map of the scene; objects behind other objects from the light's perspective will be in shadow.
-     * @remarks
-     * The {@link THREE.PerspectiveCamera.fov | fov} will track the {@link THREE.SpotLight.angle | angle} property
-     * of the owning {@link SpotLight | SpotLight} via the {@link SpotLightShadow.update | update} method.
-     * Similarly, the {@link THREE.PerspectiveCamera.aspect | aspect} property will track the aspect of the {@link LightShadow.mapSize | mapSize}.
-     * If the {@link SpotLight.distance | distance} property of the light is set, the {@link THREE.PerspectiveCamera.far | far} clipping plane will track that, otherwise it defaults to `500`.
-     * @defaultValue is a {@link THREE.PerspectiveCamera | PerspectiveCamera} with {@link THREE.PerspectiveCamera.near | near} clipping plane at `0.5`.
+     * This flag can be used for type testing.
+     *
+     * @default true
      */
-    camera: PerspectiveCamera;
-
+    readonly isSpotLightShadow: boolean;
     /**
-     * Used to focus the shadow camera.
-     * @remarks The camera's field of view is set as a percentage of the spotlight's field-of-view. Range is `[0, 1]`. 0`.
-     * @defaultValue `1`
+     * Used to focus the shadow camera. The camera's field of view is set as a
+     * percentage of the spotlight's field-of-view. Range is `[0, 1]`.
+     *
+     * @default 1
      */
     focus: number;
-
+    /**
+     * Texture aspect ratio.
+     *
+     * @default 1
+     */
     aspect: number;
+    copy(source: SpotLightShadow): this;
 }

three/src/lights/webgpu/IESSpotLight.d.ts

@@ -1,6 +1,18 @@
 import { Texture } from "../../textures/Texture.js";
 import { SpotLight } from "../SpotLight.js";
 
-export default class IESSpotLight extends SpotLight {
+/**
+ * A IES version of {@link SpotLight}. Can only be used with {@link WebGPURenderer}.
+ */
+declare class IESSpotLight extends SpotLight {
+    /**
+     * The IES map. It's a lookup table that stores normalized attenuation factors
+     * (0.0 to 1.0) that represent the light's intensity at a specific angle.
+     *
+     * @default null
+     */
     iesMap: Texture | null;
+    copy(source: IESSpotLight, recursive?: boolean): this;
 }
+
+export default IESSpotLight;

three/src/lights/webgpu/ProjectorLight.d.ts

@@ -1,17 +1,16 @@
-import { ColorRepresentation } from "../../math/Color.js";
 import { SpotLight } from "../SpotLight.js";
 
+/**
+ * A projector light version of {@link SpotLight}. Can only be used with {@link WebGPURenderer}.
+ */
 declare class ProjectorLight extends SpotLight {
+    /**
+     * Aspect ratio of the light. Set to `null` to use the texture aspect ratio.
+     *
+     * @default null
+     */
     aspect: number | null;
-
-    constructor(
-        color?: ColorRepresentation,
-        intensity?: number,
-        distance?: number,
-        angle?: number,
-        penumbra?: number,
-        decay?: number,
-    );
+    copy(source: ProjectorLight, recursive?: boolean): this;
 }
 
 export default ProjectorLight;

three/src/materials/Material.d.ts

@@ -548,6 +548,7 @@ export class Material extends EventDispatcher<{ dispose: {} }> {
      * @default 0
      */
     readonly version: number;
+    defines?: Record<string, unknown> | undefined;
     /**
      * An optional callback that is executed immediately before the material is used to render a 3D object.
      *

three/src/materials/MeshLambertMaterial.d.ts

@@ -180,6 +180,12 @@ export interface MeshLambertMaterialProperties extends MaterialProperties {
      * @default 1
      */
     reflectivity: number;
+    /**
+     * Scales the effect of the environment map by multiplying its color.
+     *
+     * @default 1
+     */
+    envMapIntensity: number;
     /**
      * The index of refraction (IOR) of air (approximately 1) divided by the
      * index of refraction of the material. It is used with environment mapping

three/src/materials/MeshPhongMaterial.d.ts

@@ -194,6 +194,12 @@ export interface MeshPhongMaterialProperties extends MaterialProperties {
      * @default 1
      */
     reflectivity: number;
+    /**
+     * Scales the effect of the environment map by multiplying its color.
+     *
+     * @default 1
+     */
+    envMapIntensity: number;
     /**
      * The index of refraction (IOR) of air (approximately 1) divided by the
      * index of refraction of the material. It is used with environment mapping

three/src/materials/ShaderMaterial.d.ts

@@ -26,7 +26,7 @@ export interface ShaderMaterialProperties extends MaterialProperties {
      * #define BAR true
      * ```
      */
-    defines: { [key: string]: any };
+    defines: Record<string, unknown>;
     /**
      * An object of the form:
      * ```js
@@ -85,9 +85,22 @@ export interface ShaderMaterialProperties extends MaterialProperties {
      */
     wireframeLinewidth: number;
     /**
-     * Define whether the material color is affected by global fog settings; `true`
+     * Defines whether the material color is affected by global fog settings; `true`
      * to pass fog uniforms to the shader.
      *
+     * Setting this property to `true` requires the definition of fog uniforms. It is
+     * recommended to use `UniformsUtils.merge()` to combine the custom shader uniforms
+     * with predefined fog uniforms.
+     *
+     * ```js
+     * const material = new ShaderMaterial( {
+     *     uniforms: UniformsUtils.merge( [ UniformsLib[ 'fog' ], shaderUniforms ] );
+     *     vertexShader: vertexShader,
+     *     fragmentShader: fragmentShader,
+     *     fog: true
+     * } );
+     * ```
+     *
      * @default false
      */
     fog: boolean;
@@ -248,4 +261,6 @@ export class ShaderMaterial extends Material {
 }
 
 // eslint-disable-next-line @typescript-eslint/no-empty-interface
-export interface ShaderMaterial extends ShaderMaterialProperties {}
+export interface ShaderMaterial extends ShaderMaterialProperties {
+    defines: Record<string, unknown>;
+}

three/src/materials/nodes/Line2NodeMaterial.d.ts

@@ -4,12 +4,6 @@ import { MapColorPropertiesToColorRepresentations } from "../Material.js";
 import NodeMaterial, { NodeMaterialNodeProperties } from "./NodeMaterial.js";
 
 export interface Line2NodeMaterialNodeProperties extends NodeMaterialNodeProperties {
-    /**
-     * Whether vertex colors should be used or not.
-     *
-     * @default false
-     */
-    useColor: boolean;
     /**
      * The dash offset.
      *

three/src/materials/nodes/LineBasicNodeMaterial.d.ts

@@ -15,8 +15,6 @@ export interface LineBasicNodeMaterialParameters
 
 /**
  * Node material version of {@link LineBasicMaterial}.
- *
- * @augments NodeMaterial
  */
 declare class LineBasicNodeMaterial extends NodeMaterial {
     /**
@@ -28,8 +26,6 @@ declare class LineBasicNodeMaterial extends NodeMaterial {
     /**
      * This flag can be used for type testing.
      *
-     * @type {boolean}
-     * @readonly
      * @default true
      */
     readonly isLineBasicNodeMaterial: boolean;

three/src/materials/nodes/MeshBasicNodeMaterial.d.ts

@@ -5,6 +5,7 @@ import { MapColorPropertiesToColorRepresentations } from "../Material.js";
 import { MeshBasicMaterialParameters, MeshBasicMaterialProperties } from "../MeshBasicMaterial.js";
 import NodeMaterial, { NodeMaterialNodeProperties } from "./NodeMaterial.js";
 
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
 export interface MeshBasicNodeMaterialNodeProperties extends NodeMaterialNodeProperties {
 }
 
@@ -28,8 +29,6 @@ declare class MeshBasicNodeMaterial extends NodeMaterial {
     /**
      * This flag can be used for type testing.
      *
-     * @type {boolean}
-     * @readonly
      * @default true
      */
     readonly isMeshBasicNodeMaterial: boolean;

three/src/materials/nodes/MeshLambertNodeMaterial.d.ts

@@ -29,8 +29,6 @@ declare class MeshLambertNodeMaterial extends NodeMaterial {
     /**
      * This flag can be used for type testing.
      *
-     * @type {boolean}
-     * @readonly
      * @default true
      */
     readonly isMeshLambertNodeMaterial: boolean;

three/src/materials/nodes/MeshNormalNodeMaterial.d.ts

@@ -25,8 +25,6 @@ declare class MeshNormalNodeMaterial extends NodeMaterial {
     constructor(parameters?: MeshNormalNodeMaterialParameters);
     /**
      * This flag can be used for type testing.
-     *
-     * @type {boolean}
      */
     readonly isMeshNormalNodeMaterial: boolean;
     setValues(values?: MeshNormalNodeMaterialParameters): void;