@needle-tools/three 0.169.12 → 0.169.14

package/types/src/core/BufferGeometry.d.ts

@@ -0,0 +1,422 @@
+import { Box3 } from "../math/Box3.js";
+import { Matrix4 } from "../math/Matrix4.js";
+import { Quaternion } from "../math/Quaternion.js";
+import { Sphere } from "../math/Sphere.js";
+import { Vector2 } from "../math/Vector2.js";
+import { Vector3, Vector3Tuple } from "../math/Vector3.js";
+import { BufferAttribute, BufferAttributeJSON } from "./BufferAttribute.js";
+import { EventDispatcher } from "./EventDispatcher.js";
+import { GLBufferAttribute } from "./GLBufferAttribute.js";
+import { InterleavedBufferAttribute } from "./InterleavedBufferAttribute.js";
+
+export type NormalBufferAttributes = Record<string, BufferAttribute | InterleavedBufferAttribute>;
+export type NormalOrGLBufferAttributes = Record<
+    string,
+    BufferAttribute | InterleavedBufferAttribute | GLBufferAttribute
+>;
+
+export interface BufferGeometryJSON {
+    metadata?: { version: number; type: string; generator: string };
+
+    uuid: string;
+    type: string;
+
+    name?: string;
+    userData?: Record<string, unknown>;
+
+    data?: {
+        attributes: Record<string, BufferAttributeJSON>;
+
+        index?: { type: string; array: number[] };
+
+        morphAttributes?: Record<string, BufferAttributeJSON[]>;
+        morphTargetsRelative?: boolean;
+
+        groups?: GeometryGroup[];
+
+        boundingSphere?: { center: Vector3Tuple; radius: number };
+    };
+}
+
+export interface GeometryGroup {
+    /**
+     * Specifies the first element in this draw call – the first vertex for non-indexed geometry, otherwise the first triangle index.
+     * @remarks Expects a `Integer`
+     */
+    start: number;
+    /**
+     * Specifies how many vertices (or indices) are included.
+     * @remarks Expects a `Integer`
+     */
+    count: number;
+    /**
+     * Specifies the material array index to use.
+     * @remarks Expects a `Integer`
+     */
+    materialIndex?: number | undefined;
+}
+
+/**
+ * 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.
+ * @remarks
+ * To read and edit data in BufferGeometry attributes, see {@link THREE.BufferAttribute | BufferAttribute} documentation.
+ * @example
+ * ```typescript
+ * const geometry = new THREE.BufferGeometry();
+ *
+ * // create a simple square shape. We duplicate the top left and bottom right
+ * // vertices because each vertex needs to appear once per triangle.
+ * const vertices = new Float32Array( [
+ *   -1.0, -1.0,  1.0, // v0
+ *    1.0, -1.0,  1.0, // v1
+ *    1.0,  1.0,  1.0, // v2
+ *
+ *    1.0,  1.0,  1.0, // v3
+ *   -1.0,  1.0,  1.0, // v4
+ *   -1.0, -1.0,  1.0  // v5
+ * ] );
+ *
+ * // itemSize = 3 because there are 3 values (components) per vertex
+ * geometry.setAttribute( 'position', new THREE.BufferAttribute( vertices, 3 ) );
+ * const material = new THREE.MeshBasicMaterial( { color: 0xff0000 } );
+ * const mesh = new THREE.Mesh( geometry, material );
+ * ```
+ * @example
+ * ```typescript
+ * const geometry = new THREE.BufferGeometry();
+ *
+ * const vertices = new Float32Array( [
+ *   -1.0, -1.0,  1.0, // v0
+ *    1.0, -1.0,  1.0, // v1
+ *    1.0,  1.0,  1.0, // v2
+ *   -1.0,  1.0,  1.0, // v3
+ * ] );
+ * geometry.setAttribute( 'position', new THREE.BufferAttribute( vertices, 3 ) );
+ *
+ * const indices = [
+ *   0, 1, 2,
+ *   2, 3, 0,
+ * ];
+ *
+ * geometry.setIndex( indices );
+ * geometry.setAttribute( 'position', new THREE.BufferAttribute( vertices, 3 ) );
+ *
+ * const material = new THREE.MeshBasicMaterial( { color: 0xff0000 } );
+ * const mesh = new THREE.Mesh( geometry, material );
+ * ```
+ * @see Example: {@link https://threejs.org/examples/#webgl_buffergeometry | Mesh with non-indexed faces}
+ * @see Example: {@link https://threejs.org/examples/#webgl_buffergeometry_indexed | Mesh with indexed faces}
+ * @see Example: {@link https://threejs.org/examples/#webgl_buffergeometry_lines | Lines}
+ * @see Example: {@link https://threejs.org/examples/#webgl_buffergeometry_lines_indexed | Indexed Lines}
+ * @see Example: {@link https://threejs.org/examples/#webgl_buffergeometry_custom_attributes_particles | Particles}
+ * @see Example: {@link https://threejs.org/examples/#webgl_buffergeometry_rawshader | Raw Shaders}
+ * @see {@link https://threejs.org/docs/index.html#api/en/core/BufferGeometry | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/core/BufferGeometry.js | Source}
+ */
+export class BufferGeometry<
+    Attributes extends NormalOrGLBufferAttributes = NormalBufferAttributes,
+> extends EventDispatcher<{ dispose: {} }> {
+    /**
+     * This creates a new {@link THREE.BufferGeometry | BufferGeometry} object.
+     */
+    constructor();
+
+    /**
+     * Unique number for this {@link THREE.BufferGeometry | BufferGeometry} instance.
+     * @remarks Expects a `Integer`
+     */
+    id: number;
+
+    /**
+     * {@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;
+
+    /**
+     * Optional name for this {@link THREE.BufferGeometry | BufferGeometry} instance.
+     * @defaultValue `''`
+     */
+    name: string;
+
+    /**
+     * A Read-only _string_ to check if `this` object type.
+     * @remarks Sub-classes will update this value.
+     * @defaultValue `BufferGeometry`
+     */
+    readonly type: string | "BufferGeometry";
+
+    /**
+     * Allows for vertices to be re-used across multiple triangles; this is called using "indexed triangles".
+     * Each triangle is associated with the indices of three vertices. This attribute therefore stores the index of each vertex for each triangular face.
+     * If this attribute is not set, the {@link THREE.WebGLRenderer | renderer}  assumes that each three contiguous positions represent a single triangle.
+     * @defaultValue `null`
+     */
+    index: BufferAttribute | null;
+
+    /**
+     * This hashmap has as id the name of the attribute to be set and as value the {@link THREE.BufferAttribute | buffer} to set it to. Rather than accessing this property directly,
+     * use {@link setAttribute | .setAttribute} and {@link getAttribute | .getAttribute} to access attributes of this geometry.
+     * @defaultValue `{}`
+     */
+    attributes: Attributes;
+
+    /**
+     * Hashmap of {@link THREE.BufferAttribute | BufferAttributes} holding details of the geometry's morph targets.
+     * @remarks
+     * Once the geometry has been rendered, the morph attribute data cannot be changed.
+     * You will have to call {@link dispose | .dispose}(), and create a new instance of {@link THREE.BufferGeometry | BufferGeometry}.
+     * @defaultValue `{}`
+     */
+    morphAttributes: {
+        [name: string]: Array<BufferAttribute | InterleavedBufferAttribute>; // TODO Replace for 'Record<>'
+    };
+
+    /**
+     * Used to control the morph target behavior; when set to true, the morph target data is treated as relative offsets, rather than as absolute positions/normals.
+     * @defaultValue `false`
+     */
+    morphTargetsRelative: boolean;
+
+    /**
+     * Split the geometry into groups, each of which will be rendered in a separate WebGL draw call. This allows an array of materials to be used with the geometry.
+     * @remarks Every vertex and index must belong to exactly one group — groups must not share vertices or indices, and must not leave vertices or indices unused.
+     * @remarks Use {@link addGroup | .addGroup} to add groups, rather than modifying this array directly.
+     * @defaultValue `[]`
+     */
+    groups: GeometryGroup[];
+
+    /**
+     * Bounding box for the {@link THREE.BufferGeometry | BufferGeometry}, which can be calculated with {@link computeBoundingBox | .computeBoundingBox()}.
+     * @remarks Bounding boxes aren't computed by default. They need to be explicitly computed, otherwise they are `null`.
+     * @defaultValue `null`
+     */
+    boundingBox: Box3 | null;
+
+    /**
+     * Bounding sphere for the {@link THREE.BufferGeometry | BufferGeometry}, which can be calculated with {@link computeBoundingSphere | .computeBoundingSphere()}.
+     * @remarks bounding spheres aren't computed by default. They need to be explicitly computed, otherwise they are `null`.
+     * @defaultValue `null`
+     */
+    boundingSphere: Sphere | null;
+
+    /**
+     * Determines the part of the geometry to render. This should not be set directly, instead use {@link setDrawRange | .setDrawRange(...)}.
+     * @remarks For non-indexed {@link THREE.BufferGeometry | BufferGeometry}, count is the number of vertices to render.
+     * @remarks For indexed {@link THREE.BufferGeometry | BufferGeometry}, count is the number of indices to render.
+     * @defaultValue `{ start: 0, count: Infinity }`
+     */
+    drawRange: { start: number; count: number };
+
+    /**
+     * An object that can be used to store custom data about the BufferGeometry. It should not hold references to functions as these will not be cloned.
+     * @defaultValue `{}`
+     */
+    userData: Record<string, any>;
+
+    /**
+     * Read-only flag to check if a given object is of type {@link BufferGeometry}.
+     * @remarks This is a _constant_ value
+     * @defaultValue `true`
+     */
+    readonly isBufferGeometry: true;
+
+    /**
+     * Return the {@link index | .index} buffer.
+     */
+    getIndex(): BufferAttribute | null;
+
+    /**
+     * Set the {@link THREE.BufferGeometry.index | .index} buffer.
+     * @param index
+     */
+    setIndex(index: BufferAttribute | number[] | null): this;
+
+    /**
+     * Sets an {@link attributes | attribute} to this geometry with the specified name.
+     * @remarks
+     * Use this rather than the attributes property, because an internal hashmap of {@link attributes | .attributes} is maintained to speed up iterating over attributes.
+     * @param name
+     * @param attribute
+     */
+    setAttribute<K extends keyof Attributes>(name: K, attribute: Attributes[K]): this;
+
+    /**
+     * Returns the {@link attributes | attribute} with the specified name.
+     * @param name
+     */
+    getAttribute<K extends keyof Attributes>(name: K): Attributes[K];
+
+    /**
+     * Deletes the  {@link attributes | attribute} with the specified name.
+     * @param name
+     */
+    deleteAttribute(name: keyof Attributes): this;
+
+    /**
+     * Returns true if the {@link attributes | attribute} with the specified name exists.
+     * @param name
+     */
+    hasAttribute(name: keyof Attributes): boolean;
+
+    /**
+     * Adds a group to this geometry
+     * @see the {@link BufferGeometry.groups | groups} property for details.
+     * @param start
+     * @param count
+     * @param materialIndex
+     */
+    addGroup(start: number, count: number, materialIndex?: number): void;
+
+    /**
+     * Clears all groups.
+     */
+    clearGroups(): void;
+
+    /**
+     * Set the {@link drawRange | .drawRange} property
+     * @remarks For non-indexed BufferGeometry, count is the number of vertices to render
+     * @remarks For indexed BufferGeometry, count is the number of indices to render.
+     * @param start
+     * @param count is the number of vertices or indices to render. Expects a `Integer`
+     */
+    setDrawRange(start: number, count: number): void;
+
+    /**
+     * Applies the matrix transform to the geometry.
+     * @param matrix
+     */
+    applyMatrix4(matrix: Matrix4): this;
+
+    /**
+     * Applies the rotation represented by the quaternion to the geometry.
+     * @param quaternion
+     */
+    applyQuaternion(quaternion: Quaternion): this;
+
+    /**
+     * Rotate the geometry about the X axis. This is typically done as a one time operation, and not during a loop.
+     * @remarks Use {@link THREE.Object3D.rotation | Object3D.rotation} for typical real-time mesh rotation.
+     * @param angle radians. Expects a `Float`
+     */
+    rotateX(angle: number): this;
+
+    /**
+     * Rotate the geometry about the Y axis.
+     * @remarks This is typically done as a one time operation, and not during a loop.
+     * @remarks Use {@link THREE.Object3D.rotation | Object3D.rotation} for typical real-time mesh rotation.
+     * @param angle radians. Expects a `Float`
+     */
+    rotateY(angle: number): this;
+
+    /**
+     * Rotate the geometry about the Z axis.
+     * @remarks This is typically done as a one time operation, and not during a loop.
+     * @remarks Use {@link THREE.Object3D.rotation | Object3D.rotation} for typical real-time mesh rotation.
+     * @param angle radians. Expects a `Float`
+     */
+    rotateZ(angle: number): this;
+
+    /**
+     * Translate the geometry.
+     * @remarks This is typically done as a one time operation, and not during a loop.
+     * @remarks Use {@link THREE.Object3D.position | Object3D.position} for typical real-time mesh rotation.
+     * @param x Expects a `Float`
+     * @param y Expects a `Float`
+     * @param z Expects a `Float`
+     */
+    translate(x: number, y: number, z: number): this;
+
+    /**
+     * Scale the geometry data.
+     * @remarks This is typically done as a one time operation, and not during a loop.
+     * @remarks Use {@link THREE.Object3D.scale | Object3D.scale} for typical real-time mesh scaling.
+     * @param x Expects a `Float`
+     * @param y Expects a `Float`
+     * @param z Expects a `Float`
+     */
+    scale(x: number, y: number, z: number): this;
+
+    /**
+     * Rotates the geometry to face a point in space.
+     * @remarks This is typically done as a one time operation, and not during a loop.
+     * @remarks Use {@link THREE.Object3D.lookAt | Object3D.lookAt} for typical real-time mesh usage.
+     * @param vector A world vector to look at.
+     */
+    lookAt(vector: Vector3): this;
+
+    /**
+     * Center the geometry based on the bounding box.
+     */
+    center(): this;
+
+    /**
+     * Sets the attributes for this BufferGeometry from an array of points.
+     * @param points
+     */
+    setFromPoints(points: Vector3[] | Vector2[]): this;
+
+    /**
+     * Computes the bounding box of the geometry, and updates the {@link .boundingBox} attribute. The bounding box is
+     * not computed by the engine; it must be computed by your app. You may need to recompute the bounding box if the
+     * geometry vertices are modified.
+     */
+    computeBoundingBox(): void;
+
+    /**
+     * Computes the bounding sphere of the geometry, and updates the {@link .boundingSphere} attribute. The engine
+     * automatically computes the bounding sphere when it is needed, e.g., for ray casting or view frustum culling. You
+     * may need to recompute the bounding sphere if the geometry vertices are modified.
+     */
+    computeBoundingSphere(): void;
+
+    /**
+     * Calculates and adds a tangent attribute to this geometry.
+     * The computation is only supported for indexed geometries and if position, normal, and uv attributes are defined
+     * @remarks
+     * When using a tangent space normal map, prefer the MikkTSpace algorithm provided by
+     * {@link BufferGeometryUtils.computeMikkTSpaceTangents} instead.
+     */
+    computeTangents(): void;
+
+    /**
+     * Computes vertex normals for the given vertex data. For indexed geometries, the method sets each vertex normal to
+     * be the average of the face normals of the faces that share that vertex. For non-indexed geometries, vertices are
+     * not shared, and the method sets each vertex normal to be the same as the face normal.
+     */
+    computeVertexNormals(): void;
+
+    /**
+     * Every normal vector in a geometry will have a magnitude of 1
+     * @remarks This will correct lighting on the geometry surfaces.
+     */
+    normalizeNormals(): void;
+
+    /**
+     * Return a non-index version of an indexed BufferGeometry.
+     */
+    toNonIndexed(): BufferGeometry;
+
+    /**
+     * Convert the buffer geometry to three.js {@link https://github.com/mrdoob/three.js/wiki/JSON-Object-Scene-format-4 | JSON Object/Scene format}.
+     */
+    toJSON(): BufferGeometryJSON;
+
+    /**
+     * Creates a clone of this BufferGeometry
+     */
+    clone(): this;
+
+    /**
+     * Copies another BufferGeometry to this BufferGeometry.
+     * @param source
+     */
+    copy(source: BufferGeometry): this;
+
+    /**
+     * Frees the GPU-related resources allocated by this instance.
+     * @remarks Call this method whenever this instance is no longer used in your app.
+     */
+    dispose(): void;
+}

package/types/src/core/Clock.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Object for keeping track of time
+ * @remarks
+ * This uses {@link https://developer.mozilla.org/en-US/docs/Web/API/Performance/now | performance.now} if it is available,
+ * otherwise it reverts to the less accurate {@link https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Date/now | Date.now}.
+ * @see {@link https://threejs.org/docs/index.html#api/en/core/Clock | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/core/Clock.js | Source}
+ */
+export class Clock {
+    /**
+     * Create a new instance of {@link THREE.Clock | Clock}
+     * @param autoStart - Whether to automatically start the clock when {@link getDelta | .getDelta()} is called for the first time. Default `true`
+     */
+    constructor(autoStart?: boolean);
+
+    /**
+     * If set, starts the clock automatically when {@link getDelta | .getDelta()} is called for the first time.
+     * @defaultValue `true`
+     */
+    autoStart: boolean;
+
+    /**
+     * Holds the time at which the clock's {@link start | .start()} method was last called.
+     * @defaultValue `0`
+     */
+    startTime: number;
+
+    /**
+     * Holds the time at which the clock's {@link start | .start()}, {@link getElapsedTime | .getElapsedTime()} or {@link getDelta | .getDelta()} methods were last called.
+     * @defaultValue `0`
+     */
+    oldTime: number;
+
+    /**
+     * Keeps track of the total time that the clock has been running.
+     * @defaultValue `0`
+     */
+    elapsedTime: number;
+
+    /**
+     * Whether the clock is running or not.
+     * @defaultValue `false`
+     */
+    running: boolean;
+
+    /**
+     * Starts clock.
+     * @remarks
+     * Also sets the {@link startTime | .startTime} and {@link oldTime | .oldTime} to the current time,
+     * sets {@link elapsedTime | .elapsedTime} to `0` and {@link running | .running} to `true`.
+     */
+    start(): void;
+
+    /**
+     * Stops clock and sets {@link oldTime | oldTime} to the current time.
+     */
+    stop(): void;
+
+    /**
+     * Get the seconds passed since the clock started and sets {@link oldTime | .oldTime} to the current time.
+     * @remarks
+     * If {@link autoStart | .autoStart} is `true` and the clock is not running, also starts the clock.
+     */
+    getElapsedTime(): number;
+
+    /**
+     * Get the seconds passed since the time {@link oldTime | .oldTime} was set and sets {@link oldTime | .oldTime} to the current time.
+     * @remarks
+     * If {@link autoStart | .autoStart} is `true` and the clock is not running, also starts the clock.
+     */
+    getDelta(): number;
+}

package/types/src/core/EventDispatcher.d.ts

@@ -0,0 +1,82 @@
+/**
+ * The minimal basic Event that can be dispatched by a {@link EventDispatcher<>}.
+ */
+export interface BaseEvent<TEventType extends string = string> {
+    readonly type: TEventType;
+}
+
+/**
+ * The minimal expected contract of a fired Event that was dispatched by a {@link EventDispatcher<>}.
+ */
+export interface Event<TEventType extends string = string, TTarget = unknown> {
+    readonly type: TEventType;
+    readonly target: TTarget;
+}
+
+export type EventListener<TEventData, TEventType extends string, TTarget> = (
+    event: TEventData & Event<TEventType, TTarget>,
+) => void;
+
+/**
+ * JavaScript events for custom objects
+ * @example
+ * ```typescript
+ * // Adding events to a custom object
+ * class Car extends EventDispatcher {
+ *   start() {
+ *     this.dispatchEvent( { type: 'start', message: 'vroom vroom!' } );
+ *   }
+ * };
+ * // Using events with the custom object
+ * const car = new Car();
+ * car.addEventListener( 'start', ( event ) => {
+ *   alert( event.message );
+ * } );
+ * car.start();
+ * ```
+ * @see {@link https://github.com/mrdoob/eventdispatcher.js | mrdoob EventDispatcher on GitHub}
+ * @see {@link https://threejs.org/docs/index.html#api/en/core/EventDispatcher | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/core/EventDispatcher.js | Source}
+ */
+export class EventDispatcher<TEventMap extends {} = {}> {
+    /**
+     * Creates {@link THREE.EventDispatcher | EventDispatcher} object.
+     */
+    constructor();
+
+    /**
+     * Adds a listener to an event type.
+     * @param type The type of event to listen to.
+     * @param listener The function that gets called when the event is fired.
+     */
+    addEventListener<T extends Extract<keyof TEventMap, string>>(
+        type: T,
+        listener: EventListener<TEventMap[T], T, this>,
+    ): void;
+
+    /**
+     * Checks if listener is added to an event type.
+     * @param type The type of event to listen to.
+     * @param listener The function that gets called when the event is fired.
+     */
+    hasEventListener<T extends Extract<keyof TEventMap, string>>(
+        type: T,
+        listener: EventListener<TEventMap[T], T, this>,
+    ): boolean;
+
+    /**
+     * Removes a listener from an event type.
+     * @param type The type of the listener that gets removed.
+     * @param listener The listener function that gets removed.
+     */
+    removeEventListener<T extends Extract<keyof TEventMap, string>>(
+        type: T,
+        listener: EventListener<TEventMap[T], T, this>,
+    ): void;
+
+    /**
+     * Fire an event type.
+     * @param event The event that gets fired.
+     */
+    dispatchEvent<T extends Extract<keyof TEventMap, string>>(event: BaseEvent<T> & TEventMap[T]): void;
+}

package/types/src/core/GLBufferAttribute.d.ts

@@ -0,0 +1,121 @@
+/**
+ * This buffer attribute class does not construct a VBO.
+ * Instead, it uses whatever VBO is passed in constructor and can later be altered via the {@link buffer | .buffer} property.
+ * @remarks
+ * It is required to pass additional params alongside the VBO
+ * Those are: the GL context, the GL data type, the number of components per vertex, the number of bytes per component, and the number of vertices.
+ * @remarks
+ * The most common use case for this class is when some kind of GPGPU calculation interferes or even produces the VBOs in question.
+ * @see Example: {@link https://threejs.org/examples/#webgl_buffergeometry_glbufferattribute | WebGL / buffergeometry / glbufferattribute}
+ * @see {@link https://threejs.org/docs/index.html#api/en/core/GLBufferAttribute | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/core/GLBufferAttribute.js | Source}
+ */
+export class GLBufferAttribute {
+    /**
+     * This creates a new GLBufferAttribute object.
+     * @param buffer Must be a {@link https://developer.mozilla.org/en-US/docs/Web/API/WebGLBuffer | WebGLBuffer}. See {@link GLBufferAttribute.buffer | .buffer}
+     * @param type One of {@link https://developer.mozilla.org/en-US/docs/Web/API/WebGL_API/Constants#Data_types | WebGL Data Types}. See {@link GLBufferAttribute.type | .type}
+     * @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}
+     */
+    constructor(buffer: WebGLBuffer, type: GLenum, itemSize: number, elementSize: 1 | 2 | 4, count: number);
+
+    /**
+     * Read-only flag to check if a given object is of type {@link GLBufferAttribute}.
+     * @remarks This is a _constant_ value
+     * @defaultValue `true`
+     */
+    readonly isGLBufferAttribute: true;
+
+    /**
+     * Optional name for this attribute instance.
+     * @defaultValue `""`
+     */
+    name: string;
+
+    /**
+     * The current {@link https://developer.mozilla.org/en-US/docs/Web/API/WebGLBuffer | WebGLBuffer} instance.
+     */
+    buffer: WebGLBuffer;
+
+    /**
+     * A {@link https://developer.mozilla.org/en-US/docs/Web/API/WebGL_API/Constants#Data_types | WebGL Data Type} describing the underlying VBO contents.
+     *
+     * #### WebGL Data Type (`GLenum`)
+     * - gl.BYTE: 0x1400
+     * - gl.UNSIGNED_BYTE: 0x1401
+     * - gl.SHORT: 0x1402
+     * - gl.UNSIGNED_SHORT: 0x1403
+     * - gl.INT: 0x1404
+     * - gl.UNSIGNED_INT: 0x1405
+     * - gl.FLOAT: 0x1406
+     * @remarks Set this property together with {@link elementSize | .elementSize}. The recommended way is using the {@link setType | .setType()} method.
+     * @remarks Expects a `DataType` `GLenum` _possible values:_ `0x1400` `0x1401` `0x1402` `0x1403` `0x1404` `0x1405` `0x1406`
+     */
+    type: GLenum;
+
+    /**
+     * How many values make up each item (vertex).
+     * @remarks The number of values of the array that should be associated with a particular vertex.
+     * For instance, if this attribute is storing a 3-component vector (such as a position, normal, or color), then itemSize should be 3.
+     * @remarks Expects a `Integer`
+     */
+    itemSize: number;
+
+    /**
+     * Stores the corresponding size in bytes for the current {@link type | .type} property value.
+     *
+     * The corresponding size (_in bytes_) for the given "type" param.
+     * #### WebGL Data Type (`GLenum`)
+     * - gl.BYTE: 1
+     * - gl.UNSIGNED_BYTE: 1
+     * - gl.SHORT: 2
+     * - gl.UNSIGNED_SHORT: 2
+     * - gl.INT: 4
+     * - gl.UNSIGNED_INT: 4
+     * - gl.FLOAT: 4
+     * @remarks Set this property together with {@link type | .type}. The recommended way is using the {@link setType | .setType} method.
+     * @see `constructor`` for a list of known type sizes.
+     * @remarks Expects a `1`, `2` or `4`
+     */
+    elementSize: 1 | 2 | 4;
+
+    /**
+     * The expected number of vertices in VBO.
+     * @remarks Expects a `Integer`
+     */
+    count: number;
+
+    /**
+     * A version number, incremented every time the needsUpdate property is set to true.
+     * @remarks Expects a `Integer`
+     */
+    version: number;
+
+    /**
+     * Setting this to true increments {@link version | .version}.
+     * @remarks _set-only property_.
+     */
+    set needsUpdate(value: boolean);
+
+    /**
+     * Sets the {@link buffer | .buffer} property.
+     */
+    setBuffer(buffer: WebGLBuffer): this;
+
+    /**
+     * Sets the both {@link GLBufferAttribute.type | type} and {@link GLBufferAttribute.elementSize | elementSize} properties.
+     */
+    setType(type: GLenum, elementSize: 1 | 2 | 4): this;
+
+    /**
+     * Sets the {@link GLBufferAttribute.itemSize | itemSize} property.
+     */
+    setItemSize(itemSize: number): this;
+
+    /**
+     * Sets the {@link GLBufferAttribute.count | count} property.
+     */
+    setCount(count: number): this;
+}