@types/three 0.177.0 → 0.178.1

three/examples/jsm/tsl/display/RGBShiftNode.d.ts

@@ -1,5 +1,5 @@
-import { NodeRepresentation, ShaderNodeObject } from "three/tsl";
-import { TempNode, TextureNode, UniformNode } from "three/webgpu";
+import { ShaderNodeObject } from "three/tsl";
+import { Node, TempNode, TextureNode, UniformNode } from "three/webgpu";
 
 export default class RGBShiftNode extends TempNode {
     textureNode: TextureNode;
@@ -13,4 +13,4 @@ export default class RGBShiftNode extends TempNode {
     setSize(width: number, height: number): void;
 }
 
-export const rgbShift: (node: NodeRepresentation, amount?: number, angle?: number) => ShaderNodeObject<RGBShiftNode>;
+export const rgbShift: (node: Node, amount?: number, angle?: number) => ShaderNodeObject<RGBShiftNode>;

three/examples/jsm/tsl/display/SMAANode.d.ts

@@ -1,5 +1,5 @@
-import { NodeRepresentation, ShaderNodeObject } from "three/tsl";
-import { TempNode, TextureNode } from "three/webgpu";
+import { ShaderNodeObject } from "three/tsl";
+import { Node, TempNode, TextureNode } from "three/webgpu";
 
 declare class SMAANode extends TempNode {
     textureNode: TextureNode;
@@ -15,4 +15,4 @@ declare class SMAANode extends TempNode {
     getSearchTexture(): string;
 }
 
-export const smaa: (node: NodeRepresentation) => ShaderNodeObject<SMAANode>;
+export const smaa: (node: Node) => ShaderNodeObject<SMAANode>;

three/examples/jsm/tsl/display/SSRNode.d.ts

@@ -1,4 +1,4 @@
-import { NodeRepresentation, ShaderNodeObject } from "three/tsl";
+import { ShaderNodeObject } from "three/tsl";
 import { Camera, Node, TempNode, TextureNode, UniformNode } from "three/webgpu";
 
 declare class SSRNode extends TempNode {
@@ -30,9 +30,9 @@ declare class SSRNode extends TempNode {
 export default SSRNode;
 
 export const ssr: (
-    colorNode: NodeRepresentation,
-    depthNode: NodeRepresentation,
-    normalNode: NodeRepresentation,
-    metalnessNode: NodeRepresentation,
+    colorNode: Node,
+    depthNode: Node,
+    normalNode: Node,
+    metalnessNode: Node,
     camera: Camera,
 ) => ShaderNodeObject<SSRNode>;

three/examples/jsm/tsl/display/Sepia.d.ts

@@ -1,4 +1,4 @@
-import { NodeRepresentation, ShaderNodeObject } from "three/tsl";
+import { ShaderNodeObject } from "three/tsl";
 import { Node } from "three/webgpu";
 
-export const sepia: (color: NodeRepresentation) => ShaderNodeObject<Node>;
+export const sepia: (color: Node) => ShaderNodeObject<Node>;

three/examples/jsm/tsl/display/SobelOperatorNode.d.ts

@@ -1,5 +1,5 @@
-import { NodeRepresentation, ShaderNodeObject } from "three/tsl";
-import { TempNode, TextureNode } from "three/webgpu";
+import { ShaderNodeObject } from "three/tsl";
+import { Node, TempNode, TextureNode } from "three/webgpu";
 
 declare class SobelOperatorNode extends TempNode {
     textureNode: TextureNode;
@@ -9,4 +9,4 @@ declare class SobelOperatorNode extends TempNode {
 
 export default SobelOperatorNode;
 
-export const sobel: (node: NodeRepresentation) => ShaderNodeObject<SobelOperatorNode>;
+export const sobel: (node: Node) => ShaderNodeObject<SobelOperatorNode>;

three/examples/jsm/tsl/display/TransitionNode.d.ts

@@ -1,4 +1,4 @@
-import { NodeRepresentation, ShaderNodeObject } from "three/tsl";
+import { ShaderNodeObject } from "three/tsl";
 import { Node, TempNode, TextureNode, UniformNode } from "three/webgpu";
 
 declare class TransitionNode extends TempNode {
@@ -23,9 +23,9 @@ declare class TransitionNode extends TempNode {
 export default TransitionNode;
 
 export const transition: (
-    node: NodeRepresentation,
-    nodeB: NodeRepresentation,
-    mixTexture: NodeRepresentation,
+    node: Node,
+    nodeB: Node,
+    mixTexture: Node,
     mixRatio: UniformNode<number>,
     threshold: UniformNode<number>,
     useTexture: UniformNode<number>,

three/examples/jsm/tsl/display/hashBlur.d.ts

@@ -1,14 +1,14 @@
-import { NodeRepresentation, ShaderNodeObject } from "three/tsl";
+import { ShaderNodeObject } from "three/tsl";
 import { Node } from "three/webgpu";
 
 interface HashBlurOptions {
-    repeats?: NodeRepresentation | undefined;
-    mask?: NodeRepresentation | null | undefined;
+    repeats?: Node | undefined;
+    mask?: Node | null | undefined;
     premultipliedAlpha?: boolean | undefined;
 }
 
 export const hashBlur: (
-    textureNode: NodeRepresentation,
-    bluramount?: NodeRepresentation,
+    textureNode: Node,
+    bluramount?: Node | number,
     options?: HashBlurOptions,
 ) => ShaderNodeObject<Node>;

three/examples/jsm/tsl/lighting/TiledLightsNode.d.ts

@@ -1,11 +1,11 @@
-import { NodeRepresentation, ShaderNodeObject } from "three/tsl";
+import { ShaderNodeObject } from "three/tsl";
 import { LightsNode, Node } from "three/webgpu";
 
 export const circleIntersectsAABB: (
-    circleCenter: NodeRepresentation,
-    radius: NodeRepresentation,
-    minBounds: NodeRepresentation,
-    maxBounds: NodeRepresentation,
+    circleCenter: Node,
+    radius: Node,
+    minBounds: Node,
+    maxBounds: Node,
 ) => ShaderNodeObject<Node>;
 
 declare class TiledLightsNode extends LightsNode {

three/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/three",
-    "version": "0.177.0",
+    "version": "0.178.1",
     "description": "TypeScript definitions for three",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/three",
     "license": "MIT",
@@ -49,6 +49,6 @@
         "meshoptimizer": "~0.18.1"
     },
     "peerDependencies": {},
-    "typesPublisherContentHash": "b00477afa796eb933a6474b328923a76b02409bbc6391520fd096f0ace56fb28",
+    "typesPublisherContentHash": "d9c620a2d4d95c3bca7cfc75c9b59be43aedab8c28dfc9871f33870fefadd371",
     "typeScriptVersion": "5.1"
 }

three/src/Three.TSL.d.ts

@@ -68,6 +68,7 @@ export const backgroundBlurriness: typeof TSL.backgroundBlurriness;
 export const backgroundIntensity: typeof TSL.backgroundIntensity;
 export const backgroundRotation: typeof TSL.backgroundRotation;
 export const batch: typeof TSL.batch;
+export const bentNormalView: typeof TSL.bentNormalView;
 export const billboarding: typeof TSL.billboarding;
 export const bitAnd: typeof TSL.bitAnd;
 export const bitNot: typeof TSL.bitNot;
@@ -118,7 +119,6 @@ export const colorSpaceToWorking: typeof TSL.colorSpaceToWorking;
 export const colorToDirection: typeof TSL.colorToDirection;
 export const compute: typeof TSL.compute;
 export const computeSkinning: typeof TSL.computeSkinning;
-export const cond: typeof TSL.cond;
 export const Const: typeof TSL.Const;
 export const context: typeof TSL.context;
 export const convert: typeof TSL.convert;
@@ -237,7 +237,6 @@ export const globalId: typeof TSL.globalId;
 export const log: typeof TSL.log;
 export const log2: typeof TSL.log2;
 export const logarithmicDepthToViewZ: typeof TSL.logarithmicDepthToViewZ;
-export const loop: typeof TSL.loop;
 export const luminance: typeof TSL.luminance;
 export const mediumpModelViewMatrix: typeof TSL.mediumpModelViewMatrix;
 export const mat2: typeof TSL.mat2;
@@ -327,7 +326,6 @@ export const mx_transform_uv: typeof TSL.mx_transform_uv;
 export const mx_worley_noise_float: typeof TSL.mx_worley_noise_float;
 export const mx_worley_noise_vec2: typeof TSL.mx_worley_noise_vec2;
 export const mx_worley_noise_vec3: typeof TSL.mx_worley_noise_vec3;
-export const namespace: typeof TSL.namespace;
 export const negate: typeof TSL.negate;
 export const neutralToneMapping: typeof TSL.neutralToneMapping;
 export const nodeArray: typeof TSL.nodeArray;
@@ -340,7 +338,9 @@ export const normalGeometry: typeof TSL.normalGeometry;
 export const normalLocal: typeof TSL.normalLocal;
 export const normalMap: typeof TSL.normalMap;
 export const normalView: typeof TSL.normalView;
+export const normalViewGeometry: typeof TSL.normalViewGeometry;
 export const normalWorld: typeof TSL.normalWorld;
+export const normalWorldGeometry: typeof TSL.normalWorldGeometry;
 export const normalize: typeof TSL.normalize;
 export const not: typeof TSL.not;
 export const notEqual: typeof TSL.notEqual;
@@ -386,7 +386,7 @@ export const pow: typeof TSL.pow;
 export const pow2: typeof TSL.pow2;
 export const pow3: typeof TSL.pow3;
 export const pow4: typeof TSL.pow4;
-export const premult: typeof TSL.premult;
+export const premultiplyAlpha: typeof TSL.premultiplyAlpha;
 export const property: typeof TSL.property;
 export const radians: typeof TSL.radians;
 export const rand: typeof TSL.rand;
@@ -405,7 +405,6 @@ export const refract: typeof TSL.refract;
 export const refractVector: typeof TSL.refractVector;
 export const refractView: typeof TSL.refractView;
 export const reinhardToneMapping: typeof TSL.reinhardToneMapping;
-export const remainder: typeof TSL.remainder;
 export const remap: typeof TSL.remap;
 export const remapClamp: typeof TSL.remapClamp;
 export const renderGroup: typeof TSL.renderGroup;
@@ -418,6 +417,7 @@ export const round: typeof TSL.round;
 export const rtt: typeof TSL.rtt;
 export const sRGBTransferEOTF: typeof TSL.sRGBTransferEOTF;
 export const sRGBTransferOETF: typeof TSL.sRGBTransferOETF;
+export const sample: typeof TSL.sample;
 export const sampler: typeof TSL.sampler;
 export const samplerComparison: typeof TSL.samplerComparison;
 export const saturate: typeof TSL.saturate;
@@ -462,6 +462,7 @@ export const storageTexture: typeof TSL.storageTexture;
 export const string: typeof TSL.string;
 export const struct: typeof TSL.struct;
 export const sub: typeof TSL.sub;
+export const subBuild: typeof TSL.subBuild;
 export const subgroupIndex: typeof TSL.subgroupIndex;
 export const subgroupSize: typeof TSL.subgroupSize;
 export const tan: typeof TSL.tan;
@@ -474,6 +475,7 @@ export const texture: typeof TSL.texture;
 export const texture3D: typeof TSL.texture3D;
 export const textureBarrier: typeof TSL.textureBarrier;
 export const textureBicubic: typeof TSL.textureBicubic;
+export const textureBicubicLevel: typeof TSL.textureBicubicLevel;
 export const textureCubeUV: typeof TSL.textureCubeUV;
 export const textureLoad: typeof TSL.textureLoad;
 export const textureSize: typeof TSL.textureSize;
@@ -489,29 +491,22 @@ export const toonOutlinePass: typeof TSL.toonOutlinePass;
 export const transformDirection: typeof TSL.transformDirection;
 export const transformNormal: typeof TSL.transformNormal;
 export const transformNormalToView: typeof TSL.transformNormalToView;
-export const transformedBentNormalView: typeof TSL.transformedBentNormalView;
-export const transformedBitangentView: typeof TSL.transformedBitangentView;
-export const transformedBitangentWorld: typeof TSL.transformedBitangentWorld;
 export const transformedClearcoatNormalView: typeof TSL.transformedClearcoatNormalView;
 export const transformedNormalView: typeof TSL.transformedNormalView;
 export const transformedNormalWorld: typeof TSL.transformedNormalWorld;
-export const transformedTangentView: typeof TSL.transformedTangentView;
-export const transformedTangentWorld: typeof TSL.transformedTangentWorld;
 export const transmission: typeof TSL.transmission;
 export const transpose: typeof TSL.transpose;
 export const triNoise3D: typeof TSL.triNoise3D;
 export const triplanarTexture: typeof TSL.triplanarTexture;
 export const triplanarTextures: typeof TSL.triplanarTextures;
 export const trunc: typeof TSL.trunc;
-export const tslFn: typeof TSL.tslFn;
 export const uint: typeof TSL.uint;
 export const uniform: typeof TSL.uniform;
 export const uniformCubeTexture: typeof TSL.uniformCubeTexture;
 export const uniformArray: typeof TSL.uniformArray;
 export const uniformGroup: typeof TSL.uniformGroup;
 export const uniformTexture: typeof TSL.uniformTexture;
-export const uniforms: typeof TSL.uniforms;
-export const unpremult: typeof TSL.unpremult;
+export const unpremultiplyAlpha: typeof TSL.unpremultiplyAlpha;
 export const userData: typeof TSL.userData;
 export const uv: typeof TSL.uv;
 export const uvec2: typeof TSL.uvec2;
@@ -532,7 +527,6 @@ export const viewZToLogarithmicDepth: typeof TSL.viewZToLogarithmicDepth;
 export const viewZToOrthographicDepth: typeof TSL.viewZToOrthographicDepth;
 export const viewZToPerspectiveDepth: typeof TSL.viewZToPerspectiveDepth;
 export const viewport: typeof TSL.viewport;
-export const viewportBottomLeft: typeof TSL.viewportBottomLeft;
 export const viewportCoordinate: typeof TSL.viewportCoordinate;
 export const viewportDepthTexture: typeof TSL.viewportDepthTexture;
 export const viewportLinearDepth: typeof TSL.viewportLinearDepth;
@@ -542,7 +536,6 @@ export const viewportSafeUV: typeof TSL.viewportSafeUV;
 export const viewportSharedTexture: typeof TSL.viewportSharedTexture;
 export const viewportSize: typeof TSL.viewportSize;
 export const viewportTexture: typeof TSL.viewportTexture;
-export const viewportTopLeft: typeof TSL.viewportTopLeft;
 export const viewportUV: typeof TSL.viewportUV;
 export const wgsl: typeof TSL.wgsl;
 export const wgslFn: typeof TSL.wgslFn;
@@ -552,4 +545,4 @@ export const workgroupId: typeof TSL.workgroupId;
 export const workingToColorSpace: typeof TSL.workingToColorSpace;
 export const xor: typeof TSL.xor;
 
-export type { NodeRepresentation, ProxiedObject, ShaderNodeObject, Swizzable } from "./nodes/TSL.js";
+export type { ProxiedObject, ShaderNodeObject, Swizzable } from "./nodes/TSL.js";

three/src/Three.WebGPU.d.ts

@@ -20,6 +20,8 @@ import * as TSL from "./nodes/TSL.js";
 export { TSL };
 export { ClippingGroup } from "./objects/ClippingGroup.js";
 export { default as IndirectStorageBufferAttribute } from "./renderers/common/IndirectStorageBufferAttribute.js";
+export { default as Storage3DTexture } from "./renderers/common/Storage3DTexture.js";
+export { default as StorageArrayTexture } from "./renderers/common/StorageArrayTexture.js";
 export { default as StorageBufferAttribute } from "./renderers/common/StorageBufferAttribute.js";
 export { default as StorageInstancedBufferAttribute } from "./renderers/common/StorageInstancedBufferAttribute.js";
 export { default as StorageTexture } from "./renderers/common/StorageTexture.js";

three/src/constants.d.ts

@@ -780,23 +780,31 @@ export const TimestampQuery: {
     COMPUTE: "compute";
     RENDER: "render";
 };
-export type TimestampQuery = "compute" | "render";
+export type TimestampQuery = typeof TimestampQuery.COMPUTE | typeof TimestampQuery.RENDER;
 
 export const InterpolationSamplingType: {
     PERSPECTIVE: "perspective";
     LINEAR: "linear";
     FLAT: "flat";
 };
-export type InterpolationSamplingType = "perspective" | "linear" | "flat";
+export type InterpolationSamplingType =
+    | typeof InterpolationSamplingType.PERSPECTIVE
+    | typeof InterpolationSamplingType.LINEAR
+    | typeof InterpolationSamplingType.FLAT;
 
 export const InterpolationSamplingMode: {
     NORMAL: "normal";
     CENTROID: "centroid";
     SAMPLE: "sample";
-    FLAT_FIRST: "flat first";
-    FLAT_EITHER: "flat either";
+    FIRST: "first";
+    EITHER: "either";
 };
-export type InterpolationSamplingMode = "normal" | "centroid" | "sample" | "flat first" | "flat either";
+export type InterpolationSamplingMode =
+    | typeof InterpolationSamplingMode.NORMAL
+    | typeof InterpolationSamplingMode.CENTROID
+    | typeof InterpolationSamplingMode.SAMPLE
+    | typeof InterpolationSamplingMode.FIRST
+    | typeof InterpolationSamplingMode.EITHER;
 
 ///////////////////////////////////////////////////////////////////////////////
 // Texture - Internal Pixel Formats

three/src/core/BufferGeometry.d.ts

@@ -57,6 +57,10 @@ export interface GeometryGroup {
     materialIndex?: number | undefined;
 }
 
+export interface BufferGeometryEventMap {
+    dispose: {};
+}
+
 /**
  * A representation of mesh, line, or point geometry
  * Includes vertex positions, face indices, normals, colors, UVs, and custom attributes within buffers, reducing the cost of passing all this data to the GPU.
@@ -117,7 +121,8 @@ export interface GeometryGroup {
  */
 export class BufferGeometry<
     Attributes extends NormalOrGLBufferAttributes = NormalBufferAttributes,
-> extends EventDispatcher<{ dispose: {} }> {
+    TEventMap extends BufferGeometryEventMap = BufferGeometryEventMap,
+> extends EventDispatcher<TEventMap> {
     /**
      * This creates a new {@link THREE.BufferGeometry | BufferGeometry} object.
      */

three/src/core/GLBufferAttribute.d.ts

@@ -18,8 +18,16 @@ export class GLBufferAttribute {
      * @param itemSize How many values make up each item (vertex). See {@link GLBufferAttribute.itemSize | .itemSize}
      * @param elementSize `1`, `2` or `4`. The corresponding size (in bytes) for the given {@link type} param. See {@link GLBufferAttribute.elementSize | .elementSize}
      * @param count The expected number of vertices in VBO. See {@link GLBufferAttribute.count | .count}
+     * @param {boolean} [normalized=false] - Whether the data are normalized or not.
      */
-    constructor(buffer: WebGLBuffer, type: GLenum, itemSize: number, elementSize: 1 | 2 | 4, count: number);
+    constructor(
+        buffer: WebGLBuffer,
+        type: GLenum,
+        itemSize: number,
+        elementSize: 1 | 2 | 4,
+        count: number,
+        normalized?: boolean,
+    );
 
     /**
      * Read-only flag to check if a given object is of type {@link GLBufferAttribute}.
@@ -87,6 +95,15 @@ export class GLBufferAttribute {
      */
     count: number;
 
+    /**
+     * Applies to integer data only. Indicates how the underlying data in the buffer maps to
+     * the values in the GLSL code. For instance, if `buffer` contains data of `gl.UNSIGNED_SHORT`,
+     * and `normalized` is `true`, the values `0 - +65535` in the buffer data will be mapped to
+     * `0.0f - +1.0f` in the GLSL attribute. If `normalized` is `false`, the values will be converted
+     * to floats unmodified, i.e. `65535` becomes `65535.0f`.
+     */
+    normalized: boolean;
+
     /**
      * A version number, incremented every time the needsUpdate property is set to true.
      * @remarks Expects a `Integer`

three/src/helpers/AxesHelper.d.ts

@@ -1,3 +1,5 @@
+import { BufferGeometry } from "../core/BufferGeometry.js";
+import { LineBasicMaterial } from "../materials/LineBasicMaterial.js";
 import { ColorRepresentation } from "../math/Color.js";
 import { LineSegments } from "../objects/LineSegments.js";
 
@@ -18,7 +20,7 @@ import { LineSegments } from "../objects/LineSegments.js";
  * @see {@link https://threejs.org/docs/index.html#api/en/helpers/AxesHelper | Official Documentation}
  * @see {@link https://github.com/mrdoob/three.js/blob/master/src/helpers/AxesHelper.js | Source}
  */
-export class AxesHelper extends LineSegments {
+export class AxesHelper extends LineSegments<BufferGeometry, LineBasicMaterial> {
     /**
      * Create a new instance of {@link AxesHelper}
      * @param size Size of the lines representing the axes. Default `1`

three/src/materials/LineBasicMaterial.d.ts

@@ -1,55 +1,87 @@
-import { Color, ColorRepresentation } from "../math/Color.js";
+import { Color } from "../math/Color.js";
 import { Texture } from "../textures/Texture.js";
-import { Material, MaterialParameters } from "./Material.js";
-
-export interface LineBasicMaterialParameters extends MaterialParameters {
-    color?: ColorRepresentation | undefined;
-    fog?: boolean | undefined;
-    linewidth?: number | undefined;
-    linecap?: string | undefined;
-    linejoin?: string | undefined;
-}
-
-export class LineBasicMaterial extends Material {
-    constructor(parameters?: LineBasicMaterialParameters);
-
-    /**
-     * Read-only flag to check if a given object is of type {@link LineBasicMaterial}.
-     * @remarks This is a _constant_ value
-     * @defaultValue `true`
-     */
-    readonly isLineBasicMaterial: true;
+import { MapColorPropertiesToColorRepresentations, Material, MaterialProperties } from "./Material.js";
 
+export interface LineBasicMaterialProperties extends MaterialProperties {
     /**
-     * @default 0xffffff
+     * Color of the material.
+     *
+     * @default (1,1,1)
      */
     color: Color;
-
     /**
-     * Whether the material is affected by fog. Default is true.
-     * @default true
+     * Sets the color of the lines using data from a texture. The texture map
+     * color is modulated by the diffuse `color`.
+     *
+     * @default null
      */
-    fog: boolean;
-
+    map: Texture | null;
     /**
+     * Controls line thickness or lines.
+     *
+     * Can only be used with {@link SVGRenderer}. WebGL and WebGPU
+     * ignore this setting and always render line primitives with a
+     * width of one pixel.
+     *
      * @default 1
      */
     linewidth: number;
-
     /**
+     * Defines appearance of line ends.
+     *
+     * Can only be used with {@link SVGRenderer}.
+     *
      * @default 'round'
      */
-    linecap: string;
-
+    linecap: "butt" | "round" | "square";
     /**
+     * Defines appearance of line joints.
+     *
+     * Can only be used with {@link SVGRenderer}.
+     *
      * @default 'round'
      */
-    linejoin: string;
-
+    linejoin: "round" | "bevel" | "miter";
     /**
-     * Sets the color of the lines using data from a {@link Texture}.
+     * Whether the material is affected by fog or not.
+     *
+     * @default true
      */
-    map: Texture | null;
+    fog: boolean;
+}
+
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+export interface LineBasicMaterialParameters
+    extends Partial<MapColorPropertiesToColorRepresentations<LineBasicMaterialProperties>>
+{}
 
-    setValues(parameters: LineBasicMaterialParameters): void;
+/**
+ * A material for rendering line primitives.
+ *
+ * Materials define the appearance of renderable 3D objects.
+ *
+ * ```js
+ * const material = new THREE.LineBasicMaterial( { color: 0xffffff } );
+ * ```
+ */
+export class LineBasicMaterial extends Material {
+    /**
+     * Constructs a new line basic material.
+     *
+     * @param {Object} [parameters] - An object with one or more properties
+     * defining the material's appearance. Any property of the material
+     * (including any property from inherited materials) can be passed
+     * in here. Color values can be passed any type of value accepted
+     * by {@link Color#set}.
+     */
+    constructor(parameters?: LineBasicMaterialParameters);
+    /**
+     * This flag can be used for type testing.
+     *
+     * @default true
+     */
+    readonly isLineBasicMaterial: boolean;
 }
+
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+export interface LineBasicMaterial extends LineBasicMaterialProperties {}

three/src/materials/LineDashedMaterial.d.ts

@@ -1,35 +1,55 @@
-import { LineBasicMaterial, LineBasicMaterialParameters } from "./LineBasicMaterial.js";
-
-export interface LineDashedMaterialParameters extends LineBasicMaterialParameters {
-    scale?: number | undefined;
-    dashSize?: number | undefined;
-    gapSize?: number | undefined;
-}
-
-export class LineDashedMaterial extends LineBasicMaterial {
-    constructor(parameters?: LineDashedMaterialParameters);
-
-    /**
-     * Read-only flag to check if a given object is of type {@link LineDashedMaterial}.
-     * @remarks This is a _constant_ value
-     * @defaultValue `true`
-     */
-    readonly isLineDashedMaterial: true;
+import { LineBasicMaterial, LineBasicMaterialProperties } from "./LineBasicMaterial.js";
+import { MapColorPropertiesToColorRepresentations } from "./Material.js";
 
+export interface LineDashedMaterialProperties extends LineBasicMaterialProperties {
     /**
+     * The scale of the dashed part of a line.
+     *
      * @default 1
      */
     scale: number;
-
     /**
-     * @default 1
+     * The size of the dash. This is both the gap with the stroke.
+     *
+     * @default 3
      */
     dashSize: number;
-
     /**
+     * The size of the gap.
+     *
      * @default 1
      */
     gapSize: number;
+}
 
-    setValues(parameters: LineDashedMaterialParameters): void;
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+export interface LineDashedMaterialParameters
+    extends Partial<MapColorPropertiesToColorRepresentations<LineDashedMaterialProperties>>
+{}
+
+/**
+ * A material for rendering line primitives.
+ *
+ * Materials define the appearance of renderable 3D objects.
+ *
+ * ```js
+ * const material = new THREE.LineDashedMaterial( {
+ * 	color: 0xffffff,
+ * 	scale: 1,
+ * 	dashSize: 3,
+ * 	gapSize: 1,
+ * } );
+ * ```
+ */
+export class LineDashedMaterial extends LineBasicMaterial {
+    constructor(parameters?: LineDashedMaterialParameters);
+    /**
+     * This flag can be used for type testing.
+     *
+     * @default true
+     */
+    readonly isLineDashedMaterial: boolean;
 }
+
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+export interface LineDashedMaterial extends LineDashedMaterialProperties {}