three-stdlib 2.35.7 → 2.35.9

package/misc/MD2CharacterComplex.d.cts

@@ -0,0 +1,47 @@
+import type { Object3D, Mesh, Texture } from 'three'
+
+export class MD2CharacterComplex {
+  constructor()
+  scale: number
+  animationFPS: number
+  transitionFrames: number
+  maxSpeed: number
+  maxReverseSpeed: number
+  frontAcceleration: number
+  backAcceleration: number
+  frontDecceleration: number
+  angularSpeed: number
+  root: Object3D
+  meshBody: Mesh | null
+  meshWeapon: Mesh | null
+  controls: null
+  skinsBody: Texture[]
+  skinsWeapon: Texture[]
+  weapons: Mesh[]
+  currentSkin: number
+  onLoadComplete: () => void
+
+  meshes: Mesh[]
+  animations: object[]
+  loadCounter: number
+  speed: number
+  bodyOrientation: number
+  walkSpeed: number
+  crouchSpeed: number
+  activeAnimation: string
+  oldAnimation: string
+
+  enableShadows(enable: boolean): void
+  setVisible(enable: boolean): void
+  shareParts(original: MD2CharacterComplex): void
+  loadParts(config: object): void
+  setPlaybackRate(rate: number): void
+  setWireframe(wireframeEnabled: boolean): void
+  setSkin(index: number): void
+  setWeapon(index: number): void
+  setAnimation(animationName: string): void
+  update(delta: number): void
+  updateAnimations(delta: number): void
+  updateBehaviors(): void
+  updateMovementModel(delta: number): void
+}

package/misc/MD2CharacterComplex.d.ts

@@ -1,4 +1,4 @@
-import { Object3D, Mesh, Texture } from 'three'
+import type { Object3D, Mesh, Texture } from 'three'
 
 export class MD2CharacterComplex {
   constructor()

package/misc/MorphAnimMesh.d.cts

@@ -0,0 +1,13 @@
+import type { AnimationAction, AnimationMixer, BufferGeometry, Material, Mesh } from 'three'
+
+export class MorphAnimMesh extends Mesh {
+  constructor(geometry: BufferGeometry, material: Material)
+  mixer: AnimationMixer
+  activeAction: AnimationAction | null
+
+  setDirectionForward(): void
+  setDirectionBackward(): void
+  playAnimation(label: string, fps: number): void
+  updateAnimation(delta: number): void
+  copy(source: MorphAnimMesh, recursive?: boolean): this
+}

package/misc/MorphAnimMesh.d.ts

@@ -1,4 +1,4 @@
-import { AnimationAction, AnimationMixer, BufferGeometry, Material, Mesh } from 'three'
+import type { AnimationAction, AnimationMixer, BufferGeometry, Material, Mesh } from 'three'
 
 export class MorphAnimMesh extends Mesh {
   constructor(geometry: BufferGeometry, material: Material)

package/misc/MorphBlendMesh.d.cts

@@ -0,0 +1,21 @@
+import type { BufferGeometry, Material, Mesh } from 'three'
+
+export class MorphBlendMesh extends Mesh {
+  constructor(geometry: BufferGeometry, material: Material)
+  animationsMap: object
+  animationsList: object[]
+
+  createAnimation(name: string, start: number, end: number, fps: number): void
+  autoCreateAnimations(fps: number): void
+  setAnimationDirectionForward(name: string): void
+  setAnimationDirectionBackward(name: string): void
+  setAnimationFPS(name: string, fps: number): void
+  setAnimationDuration(name: string, duration: number): void
+  setAnimationWeight(name: string, weight: number): void
+  setAnimationTime(name: string, time: number): void
+  getAnimationTime(name: string): number
+  getAnimationDuration(name: string): number
+  playAnimation(name: string): void
+  stopAnimation(name: string): void
+  update(delta: number): void
+}

package/misc/MorphBlendMesh.d.ts

@@ -1,4 +1,4 @@
-import { BufferGeometry, Material, Mesh } from 'three'
+import type { BufferGeometry, Material, Mesh } from 'three'
 
 export class MorphBlendMesh extends Mesh {
   constructor(geometry: BufferGeometry, material: Material)

package/misc/ProgressiveLightmap.d.cts

@@ -0,0 +1,60 @@
+import type {
+  Camera,
+  Material,
+  Mesh,
+  MeshBasicMaterial,
+  MeshPhongMaterial,
+  Object3D,
+  PlaneGeometry,
+  Texture,
+  Vector3,
+  WebGLRenderer,
+  Scene,
+  WebGLRenderTarget,
+} from 'three'
+
+export interface UVBoxes {
+  w: number
+  h: number
+  index: number
+}
+
+export interface LightMapContainers {
+  basicMat: Material | Material[]
+  object: Object3D
+}
+
+export class ProgressiveLightMap {
+  renderer: WebGLRenderer
+  res: number
+  lightMapContainers: LightMapContainers[]
+  compiled: boolean
+  scene: Scene
+  tinyTarget: WebGLRenderTarget
+  buffer1Active: boolean
+  firstUpdate: boolean
+  warned: boolean
+
+  progressiveLightMap1: WebGLRenderTarget
+  progressiveLightMap2: WebGLRenderTarget
+
+  uvMat: MeshPhongMaterial
+
+  uv_boxes: UVBoxes[]
+
+  blurringPlane: Mesh<PlaneGeometry, MeshBasicMaterial>
+
+  labelMaterial: MeshBasicMaterial
+  labelPlane: PlaneGeometry
+  labelMesh: Mesh<PlaneGeometry, MeshBasicMaterial>
+
+  constructor(renderer: WebGLRenderer, res?: number)
+
+  addObjectsToLightMap(objects: Object3D[]): void
+
+  update(camera: Camera, blendWindow?: number, blurEdges?: boolean): void
+
+  showDebugLightmap(visible: boolean, position?: Vector3): void
+
+  private _initializeBlurPlane(res: number, lightMap?: Texture | null): void
+}

package/misc/ProgressiveLightmap.d.ts

@@ -1,4 +1,4 @@
-import {
+import type {
   Camera,
   Material,
   Mesh,

package/misc/RollerCoaster.d.cts

@@ -0,0 +1,21 @@
+import type { BufferGeometry, Curve, Mesh, Vector3 } from 'three'
+
+export class RollerCoasterGeometry extends BufferGeometry {
+  constructor(curve: Curve<Vector3>, divisions: number)
+}
+
+export class RollerCoasterLiftersGeometry extends BufferGeometry {
+  constructor(curve: Curve<Vector3>, divisions: number)
+}
+
+export class RollerCoasterShadowGeometry extends BufferGeometry {
+  constructor(curve: Curve<Vector3>, divisions: number)
+}
+
+export class SkyGeometry extends BufferGeometry {
+  constructor(curve: Curve<Vector3>, divisions: number)
+}
+
+export class TreesGeometry extends BufferGeometry {
+  constructor(landscape: Mesh)
+}

package/misc/RollerCoaster.d.ts

@@ -1,4 +1,4 @@
-import { BufferGeometry, Curve, Mesh, Vector3 } from 'three'
+import type { BufferGeometry, Curve, Mesh, Vector3 } from 'three'
 
 export class RollerCoasterGeometry extends BufferGeometry {
   constructor(curve: Curve<Vector3>, divisions: number)

package/misc/Timer.d.cts

@@ -0,0 +1,27 @@
+declare class Timer {
+    private _previousTime;
+    private _currentTime;
+    private _delta;
+    private _elapsed;
+    private _timescale;
+    private _useFixedDelta;
+    private _fixedDelta;
+    private _usePageVisibilityAPI;
+    private _pageVisibilityHandler;
+    constructor();
+    connect(): this;
+    dispose(): this;
+    disableFixedDelta(): this;
+    enableFixedDelta(): this;
+    getDelta(): number;
+    getElapsedTime(): number;
+    getFixedDelta(): number;
+    getTimescale(): number;
+    reset(): this;
+    setFixedDelta(fixedDelta: number): this;
+    setTimescale(timescale: number): this;
+    update(): this;
+    get elapsedTime(): number;
+    private _now;
+}
+export type { Timer };

package/misc/Timer.d.ts

@@ -24,4 +24,4 @@ declare class Timer {
     get elapsedTime(): number;
     private _now;
 }
-export { Timer };
+export type { Timer };

package/misc/TubePainter.d.cts

@@ -0,0 +1,10 @@
+import type { Matrix4, Mesh, Vector3 } from 'three'
+
+export class TubePainter {
+  constructor()
+
+  mesh: Mesh
+
+  stroke(position1: Vector3, position2: Vector3, matrix1: Matrix4, matrix2: Matrix4): void
+  updateGeometry(start: number, end: number): void
+}

package/misc/TubePainter.d.ts

@@ -1,4 +1,4 @@
-import { Matrix4, Mesh, Vector3 } from 'three'
+import type { Matrix4, Mesh, Vector3 } from 'three'
 
 export class TubePainter {
   constructor()

package/misc/Volume.d.cts

@@ -0,0 +1,37 @@
+import type { Matrix3 } from 'three'
+
+import type { VolumeSlice } from './VolumeSlice.d.cts'
+
+export class Volume {
+  constructor(xLength?: number, yLength?: number, zLength?: number, type?: string, arrayBuffer?: ArrayLike<number>)
+
+  xLength: number
+  yLength: number
+  zLength: number
+
+  axisOrder: Array<'x' | 'y' | 'z'>
+
+  data: ArrayLike<number>
+
+  spacing: number[]
+  offset: number[]
+
+  matrix: Matrix3
+
+  lowerThreshold: number
+  upperThreshold: number
+
+  sliceList: VolumeSlice[]
+
+  getData(i: number, j: number, k: number): number
+  access(i: number, j: number, k: number): number
+  reverseAccess(index: number): number[]
+
+  map(functionToMap: () => void, context: this): this
+
+  extractPerpendicularPlane(axis: string, RASIndex: number): object
+  extractSlice(axis: string, index: number): VolumeSlice
+
+  repaintAllSlices(): this
+  computeMinMax(): number[]
+}

package/misc/Volume.d.ts

@@ -1,6 +1,6 @@
-import { Matrix3 } from 'three'
+import type { Matrix3 } from 'three'
 
-import { VolumeSlice } from './VolumeSlice'
+import type { VolumeSlice } from './VolumeSlice.d.ts'
 
 export class Volume {
   constructor(xLength?: number, yLength?: number, zLength?: number, type?: string, arrayBuffer?: ArrayLike<number>)

package/misc/VolumeSlice.d.cts

@@ -0,0 +1,28 @@
+import type { Matrix3, Mesh } from 'three'
+
+import type { Volume } from './Volume.d.cts'
+
+export class VolumeSlice {
+  constructor(volume: Volume, index?: number, axis?: string)
+
+  index: number
+  axis: string
+
+  canvas: HTMLCanvasElement
+  canvasBuffer: HTMLCanvasElement
+
+  ctx: CanvasRenderingContext2D
+  ctxBuffer: CanvasRenderingContext2D
+
+  mesh: Mesh
+
+  geometryNeedsUpdate: boolean
+
+  sliceAccess: number
+  jLength: number
+  iLength: number
+  matrix: Matrix3
+
+  repaint(): void
+  updateGeometry(): void
+}

package/misc/VolumeSlice.d.ts

@@ -1,6 +1,6 @@
-import { Matrix3, Mesh } from 'three'
+import type { Matrix3, Mesh } from 'three'
 
-import { Volume } from './Volume'
+import type { Volume } from './Volume.d.ts'
 
 export class VolumeSlice {
   constructor(volume: Volume, index?: number, axis?: string)

package/misc/WebGL.d.cts

@@ -0,0 +1,5 @@
+export type declare function isWebGLAvailable(): boolean;
+export type declare function isWebGL2Available(): boolean;
+export type declare function getWebGLErrorMessage(): HTMLDivElement;
+export type declare function getWebGL2ErrorMessage(): HTMLDivElement;
+export type declare function getErrorMessage(version: 1 | 2): HTMLDivElement;

package/misc/WebGL.d.ts

@@ -1,5 +1,5 @@
-export declare function isWebGLAvailable(): boolean;
-export declare function isWebGL2Available(): boolean;
-export declare function getWebGLErrorMessage(): HTMLDivElement;
-export declare function getWebGL2ErrorMessage(): HTMLDivElement;
-export declare function getErrorMessage(version: 1 | 2): HTMLDivElement;
+export type declare function isWebGLAvailable(): boolean;
+export type declare function isWebGL2Available(): boolean;
+export type declare function getWebGLErrorMessage(): HTMLDivElement;
+export type declare function getWebGL2ErrorMessage(): HTMLDivElement;
+export type declare function getErrorMessage(version: 1 | 2): HTMLDivElement;

package/modifiers/CurveModifier.d.cts

@@ -0,0 +1,91 @@
+import type { DataTexture, Mesh, InstancedMesh, Material, Curve, BufferGeometry } from 'three';
+import type { IUniform } from 'three';
+/**
+ * Make a new DataTexture to store the descriptions of the curves.
+ *
+ * @param { number } numberOfCurves the number of curves needed to be described by this texture.
+ */
+export type declare const initSplineTexture: (numberOfCurves?: number) => DataTexture;
+/**
+ * Write the curve description to the data texture
+ *
+ * @param { DataTexture } texture The DataTexture to write to
+ * @param { Curve } splineCurve The curve to describe
+ * @param { number } offset Which curve slot to write to
+ */
+export type declare const updateSplineTexture: <TCurve extends Curve<any>>(texture: DataTexture, splineCurve: TCurve, offset?: number) => void;
+export interface INumericUniform extends IUniform {
+    type: 'f' | 'i';
+    value: number;
+}
+export type CurveModifierUniforms = {
+    spineTexture: IUniform<DataTexture>;
+    pathOffset: INumericUniform;
+    pathSegment: INumericUniform;
+    spineOffset: INumericUniform;
+    spineLength: INumericUniform;
+    flow: INumericUniform;
+};
+/**
+ * Create a new set of uniforms for describing the curve modifier
+ *
+ * @param { DataTexture } Texture which holds the curve description
+ */
+export type declare const getUniforms: (splineTexture: DataTexture) => CurveModifierUniforms;
+export type ModifiedMaterial<TMaterial extends Material> = TMaterial & {
+    __ok: boolean;
+};
+export type declare function modifyShader<TMaterial extends Material = Material>(material: ModifiedMaterial<TMaterial>, uniforms: CurveModifierUniforms, numberOfCurves?: number): void;
+/**
+ * A helper class for making meshes bend aroudn curves
+ */
+export type declare class Flow<TMesh extends Mesh = Mesh> {
+    curveArray: Curve<any>[];
+    curveLengthArray: number[];
+    object3D: TMesh;
+    splineTexure: DataTexture;
+    uniforms: CurveModifierUniforms;
+    /**
+     * @param {Mesh} mesh The mesh to clone and modify to bend around the curve
+     * @param {number} numberOfCurves The amount of space that should preallocated for additional curves
+     */
+    constructor(mesh: TMesh, numberOfCurves?: number);
+    updateCurve<TCurve extends Curve<any>>(index: number, curve: TCurve): void;
+    moveAlongCurve(amount: number): void;
+}
+/**
+ * A helper class for creating instanced versions of flow, where the instances are placed on the curve.
+ */
+export type declare class InstancedFlow<TGeometry extends BufferGeometry = BufferGeometry, TMaterial extends Material = Material> extends Flow<InstancedMesh<TGeometry, TMaterial>> {
+    offsets: number[];
+    whichCurve: number[];
+    /**
+     *
+     * @param {number} count The number of instanced elements
+     * @param {number} curveCount The number of curves to preallocate for
+     * @param {Geometry} geometry The geometry to use for the instanced mesh
+     * @param {Material} material The material to use for the instanced mesh
+     */
+    constructor(count: number, curveCount: number, geometry: TGeometry, material: TMaterial);
+    /**
+     * The extra information about which curve and curve position is stored in the translation components of the matrix for the instanced objects
+     * This writes that information to the matrix and marks it as needing update.
+     *
+     * @param {number} index of the instanced element to update
+     */
+    private writeChanges;
+    /**
+     * Move an individual element along the curve by a specific amount
+     *
+     * @param {number} index Which element to update
+     * @param {number} offset Move by how much
+     */
+    moveIndividualAlongCurve(index: number, offset: number): void;
+    /**
+     * Select which curve to use for an element
+     *
+     * @param {number} index the index of the instanced element to update
+     * @param {number} curveNo the index of the curve it should use
+     */
+    setCurve(index: number, curveNo: number): void;
+}

package/modifiers/CurveModifier.d.ts

@@ -1,11 +1,11 @@
-import { DataTexture, Mesh, InstancedMesh, Material, Curve, BufferGeometry } from 'three';
+import type { DataTexture, Mesh, InstancedMesh, Material, Curve, BufferGeometry } from 'three';
 import type { IUniform } from 'three';
 /**
  * Make a new DataTexture to store the descriptions of the curves.
  *
  * @param { number } numberOfCurves the number of curves needed to be described by this texture.
  */
-export declare const initSplineTexture: (numberOfCurves?: number) => DataTexture;
+export type declare const initSplineTexture: (numberOfCurves?: number) => DataTexture;
 /**
  * Write the curve description to the data texture
  *
@@ -13,7 +13,7 @@ export declare const initSplineTexture: (numberOfCurves?: number) => DataTexture
  * @param { Curve } splineCurve The curve to describe
  * @param { number } offset Which curve slot to write to
  */
-export declare const updateSplineTexture: <TCurve extends Curve<any>>(texture: DataTexture, splineCurve: TCurve, offset?: number) => void;
+export type declare const updateSplineTexture: <TCurve extends Curve<any>>(texture: DataTexture, splineCurve: TCurve, offset?: number) => void;
 export interface INumericUniform extends IUniform {
     type: 'f' | 'i';
     value: number;
@@ -31,15 +31,15 @@ export type CurveModifierUniforms = {
  *
  * @param { DataTexture } Texture which holds the curve description
  */
-export declare const getUniforms: (splineTexture: DataTexture) => CurveModifierUniforms;
+export type declare const getUniforms: (splineTexture: DataTexture) => CurveModifierUniforms;
 export type ModifiedMaterial<TMaterial extends Material> = TMaterial & {
     __ok: boolean;
 };
-export declare function modifyShader<TMaterial extends Material = Material>(material: ModifiedMaterial<TMaterial>, uniforms: CurveModifierUniforms, numberOfCurves?: number): void;
+export type declare function modifyShader<TMaterial extends Material = Material>(material: ModifiedMaterial<TMaterial>, uniforms: CurveModifierUniforms, numberOfCurves?: number): void;
 /**
  * A helper class for making meshes bend aroudn curves
  */
-export declare class Flow<TMesh extends Mesh = Mesh> {
+export type declare class Flow<TMesh extends Mesh = Mesh> {
     curveArray: Curve<any>[];
     curveLengthArray: number[];
     object3D: TMesh;
@@ -56,7 +56,7 @@ export declare class Flow<TMesh extends Mesh = Mesh> {
 /**
  * A helper class for creating instanced versions of flow, where the instances are placed on the curve.
  */
-export declare class InstancedFlow<TGeometry extends BufferGeometry = BufferGeometry, TMaterial extends Material = Material> extends Flow<InstancedMesh<TGeometry, TMaterial>> {
+export type declare class InstancedFlow<TGeometry extends BufferGeometry = BufferGeometry, TMaterial extends Material = Material> extends Flow<InstancedMesh<TGeometry, TMaterial>> {
     offsets: number[];
     whichCurve: number[];
     /**

package/modifiers/EdgeSplitModifier.d.cts

@@ -0,0 +1,19 @@
+import type { BufferGeometry } from 'three';
+declare class EdgeSplitModifier {
+    private A;
+    private B;
+    private C;
+    private positions;
+    private normals;
+    private indexes;
+    private pointToIndexMap;
+    private splitIndexes;
+    private oldNormals;
+    constructor();
+    private computeNormals;
+    private mapPositionsToIndexes;
+    private edgeSplitToGroups;
+    private edgeSplit;
+    modify: (geometry: BufferGeometry, cutOffAngle: number, tryKeepNormals?: boolean) => BufferGeometry;
+}
+export type { EdgeSplitModifier };

package/modifiers/EdgeSplitModifier.d.ts

@@ -1,4 +1,4 @@
-import { BufferGeometry } from 'three';
+import type { BufferGeometry } from 'three';
 declare class EdgeSplitModifier {
     private A;
     private B;
@@ -16,4 +16,4 @@ declare class EdgeSplitModifier {
     private edgeSplit;
     modify: (geometry: BufferGeometry, cutOffAngle: number, tryKeepNormals?: boolean) => BufferGeometry;
 }
-export { EdgeSplitModifier };
+export type { EdgeSplitModifier };

package/modifiers/SimplifyModifier.d.cts

@@ -0,0 +1,19 @@
+import type { BufferGeometry } from 'three';
+/**
+ *	Simplification Geometry Modifier
+ *    - based on code and technique
+ *	  - by Stan Melax in 1998
+ *	  - Progressive Mesh type Polygon Reduction Algorithm
+ *    - http://www.melax.com/polychop/
+ */
+declare class SimplifyModifier {
+    constructor();
+    private computeEdgeCollapseCost;
+    private removeVertex;
+    private computeEdgeCostAtVertex;
+    private removeFace;
+    private collapse;
+    private minimumCostEdge;
+    modify: (geometry: BufferGeometry, count: number) => BufferGeometry;
+}
+export type { SimplifyModifier };

package/modifiers/SimplifyModifier.d.ts

@@ -1,4 +1,4 @@
-import { BufferGeometry } from 'three';
+import type { BufferGeometry } from 'three';
 /**
  *	Simplification Geometry Modifier
  *    - based on code and technique
@@ -16,4 +16,4 @@ declare class SimplifyModifier {
     private minimumCostEdge;
     modify: (geometry: BufferGeometry, count: number) => BufferGeometry;
 }
-export { SimplifyModifier };
+export type { SimplifyModifier };

package/modifiers/TessellateModifier.d.cts

@@ -0,0 +1,11 @@
+import type { BufferGeometry } from 'three';
+/**
+ * Break faces with edges longer than maxEdgeLength
+ */
+declare class TessellateModifier {
+    maxEdgeLength: number;
+    maxIterations: number;
+    constructor(maxEdgeLength?: number, maxIterations?: number);
+    modify: (geometry: BufferGeometry) => BufferGeometry;
+}
+export type { TessellateModifier };

package/modifiers/TessellateModifier.d.ts

@@ -1,4 +1,4 @@
-import { BufferGeometry } from 'three';
+import type { BufferGeometry } from 'three';
 /**
  * Break faces with edges longer than maxEdgeLength
  */
@@ -8,4 +8,4 @@ declare class TessellateModifier {
     constructor(maxEdgeLength?: number, maxIterations?: number);
     modify: (geometry: BufferGeometry) => BufferGeometry;
 }
-export { TessellateModifier };
+export type { TessellateModifier };

package/objects/BatchedMesh.d.cts

@@ -0,0 +1,48 @@
+import type { Matrix4, Mesh, BufferGeometry, Material, DataTexture, IUniform } from 'three';
+declare class BatchedMesh extends Mesh<BufferGeometry, Material> {
+    _vertexStarts: number[];
+    _vertexCounts: number[];
+    _indexStarts: number[];
+    _indexCounts: number[];
+    _reservedRanges: {
+        vertexStart: number;
+        vertexCount: number;
+        indexStart: number;
+        indexCount: number;
+    }[];
+    _visible: boolean[];
+    _active: boolean[];
+    _maxGeometryCount: number;
+    _maxVertexCount: number;
+    _maxIndexCount: number;
+    _geometryInitialized: boolean;
+    _geometryCount: number;
+    _matrices: Matrix4[];
+    _matricesTexture: DataTexture | null;
+    _customUniforms: Record<string, IUniform>;
+    constructor(maxGeometryCount: number, maxVertexCount: number, maxIndexCount?: number, material?: Material);
+    _initMatricesTexture(): void;
+    _initShader(): void;
+    _initializeGeometry(reference: BufferGeometry): void;
+    _validateGeometry(geometry: BufferGeometry): void;
+    getGeometryCount(): number;
+    getVertexCount(): number;
+    getIndexCount(): number;
+    addGeometry(geometry: BufferGeometry, vertexCount?: number, indexCount?: number): number;
+    /**
+     * @deprecated use `addGeometry` instead.
+     */
+    applyGeometry(geometry: BufferGeometry): number;
+    setGeometryAt(id: number, geometry: BufferGeometry): number;
+    deleteGeometry(geometryId: number): this;
+    optimize(): never;
+    setMatrixAt(geometryId: number, matrix: Matrix4): this;
+    getMatrixAt(geometryId: number, matrix: Matrix4): Matrix4;
+    setVisibleAt(geometryId: number, value: boolean): this;
+    getVisibleAt(geometryId: number): boolean;
+    raycast(): void;
+    copy(): never;
+    toJSON(): never;
+    dispose(): this;
+}
+export type { BatchedMesh };

package/objects/BatchedMesh.d.ts

@@ -1,4 +1,4 @@
-import { Matrix4, Mesh, BufferGeometry, Material, DataTexture, IUniform } from 'three';
+import type { Matrix4, Mesh, BufferGeometry, Material, DataTexture, IUniform } from 'three';
 declare class BatchedMesh extends Mesh<BufferGeometry, Material> {
     _vertexStarts: number[];
     _vertexCounts: number[];
@@ -45,4 +45,4 @@ declare class BatchedMesh extends Mesh<BufferGeometry, Material> {
     toJSON(): never;
     dispose(): this;
 }
-export { BatchedMesh };
+export type { BatchedMesh };