Add all given .d.ts file

src/Three.Legacy.d.ts

@@ -0,0 +1,13 @@
+import { Geometry } from './core/Geometry';
+import { Material } from './materials/Material';
+import { Object3D } from './core/Object3D';
+import { Scene } from './scenes/Scene';
+
+export namespace SceneUtils {
+  export function createMultiMaterialObject(
+    geometry: Geometry,
+    materials: Material[]
+  ): Object3D;
+  export function detach(child: Object3D, parent: Object3D, scene: Scene): void;
+  export function attach(child: Object3D, scene: Scene, parent: Object3D): void;
+}

src/Three.d.ts

@@ -0,0 +1,169 @@
+import './polyfills.js';
+
+// export {
+//   WebGLMultisampleRenderTarget,
+// } from './renderers/WebGLMultisampleRenderTarget.js';
+export { WebGLRenderTargetCube } from './renderers/WebGLRenderTargetCube.js';
+export { WebGLRenderTarget } from './renderers/WebGLRenderTarget.js';
+export { WebGLRenderer } from './renderers/WebGLRenderer.js';
+export { ShaderLib } from './renderers/shaders/ShaderLib.js';
+export { UniformsLib } from './renderers/shaders/UniformsLib.js';
+export { UniformsUtils } from './renderers/shaders/UniformsUtils.js';
+export { ShaderChunk } from './renderers/shaders/ShaderChunk.js';
+export { FogExp2 } from './scenes/FogExp2.js';
+export { Fog } from './scenes/Fog.js';
+export { Scene } from './scenes/Scene.js';
+export { Sprite } from './objects/Sprite.js';
+export { LOD } from './objects/LOD.js';
+export { SkinnedMesh } from './objects/SkinnedMesh.js';
+export { Skeleton } from './objects/Skeleton.js';
+export { Bone } from './objects/Bone.js';
+export { Mesh } from './objects/Mesh.js';
+export { LineSegments } from './objects/LineSegments.js';
+//export { LineLoop } from './objects/LineLoop.js';
+export { Line } from './objects/Line.js';
+export { Points } from './objects/Points.js';
+export { Group } from './objects/Group.js';
+export { VideoTexture } from './textures/VideoTexture.js';
+export { DataTexture } from './textures/DataTexture.js';
+//export { DataTexture3D } from './textures/DataTexture3D.js';
+export { CompressedTexture } from './textures/CompressedTexture.js';
+export { CubeTexture } from './textures/CubeTexture.js';
+export { CanvasTexture } from './textures/CanvasTexture.js';
+export { DepthTexture } from './textures/DepthTexture.js';
+export { Texture } from './textures/Texture.js';
+export * from './geometries/Geometries.js';
+export * from './materials/Materials.js';
+//export { AnimationLoader } from './loaders/AnimationLoader.js';
+export { CompressedTextureLoader } from './loaders/CompressedTextureLoader.js';
+export { DataTextureLoader } from './loaders/DataTextureLoader.js';
+export { CubeTextureLoader } from './loaders/CubeTextureLoader.js';
+export { TextureLoader } from './loaders/TextureLoader.js';
+export { ObjectLoader } from './loaders/ObjectLoader.js';
+export { MaterialLoader } from './loaders/MaterialLoader.js';
+export { BufferGeometryLoader } from './loaders/BufferGeometryLoader.js';
+export { LoadingManager } from './loaders/LoadingManager.js';
+export { ImageLoader } from './loaders/ImageLoader.js';
+//export { ImageBitmapLoader } from './loaders/ImageBitmapLoader.js';
+export { FontLoader } from './loaders/FontLoader.js';
+export { FileLoader } from './loaders/FileLoader.js';
+export { Loader } from './loaders/Loader.js';
+export { LoaderUtils } from './loaders/LoaderUtils.js';
+export { Cache } from './loaders/Cache.js';
+export { AudioLoader } from './loaders/AudioLoader.js';
+export { SpotLightShadow } from './lights/SpotLightShadow.js';
+export { SpotLight } from './lights/SpotLight.js';
+export { PointLight } from './lights/PointLight.js';
+//export { RectAreaLight } from './lights/RectAreaLight.js';
+export { HemisphereLight } from './lights/HemisphereLight.js';
+export { DirectionalLightShadow } from './lights/DirectionalLightShadow.js';
+export { DirectionalLight } from './lights/DirectionalLight.js';
+export { AmbientLight } from './lights/AmbientLight.js';
+export { LightShadow } from './lights/LightShadow.js';
+export { Light } from './lights/Light.js';
+export { StereoCamera } from './cameras/StereoCamera.js';
+export { PerspectiveCamera } from './cameras/PerspectiveCamera.js';
+export { OrthographicCamera } from './cameras/OrthographicCamera.js';
+export { CubeCamera } from './cameras/CubeCamera.js';
+export { ArrayCamera } from './cameras/ArrayCamera.js';
+export { Camera } from './cameras/Camera.js';
+export { AudioListener } from './audio/AudioListener.js';
+export { PositionalAudio } from './audio/PositionalAudio.js';
+export { AudioContext } from './audio/AudioContext.js';
+export { AudioAnalyser } from './audio/AudioAnalyser.js';
+export { Audio } from './audio/Audio.js';
+export { VectorKeyframeTrack } from './animation/tracks/VectorKeyframeTrack.js';
+export { StringKeyframeTrack } from './animation/tracks/StringKeyframeTrack.js';
+export {
+  QuaternionKeyframeTrack,
+} from './animation/tracks/QuaternionKeyframeTrack.js';
+export { NumberKeyframeTrack } from './animation/tracks/NumberKeyframeTrack.js';
+export { ColorKeyframeTrack } from './animation/tracks/ColorKeyframeTrack.js';
+export {
+  BooleanKeyframeTrack,
+} from './animation/tracks/BooleanKeyframeTrack.js';
+export { PropertyMixer } from './animation/PropertyMixer.js';
+export { PropertyBinding } from './animation/PropertyBinding.js';
+export { KeyframeTrack } from './animation/KeyframeTrack.js';
+export { AnimationUtils } from './animation/AnimationUtils.js';
+export { AnimationObjectGroup } from './animation/AnimationObjectGroup.js';
+export { AnimationMixer } from './animation/AnimationMixer.js';
+export { AnimationClip } from './animation/AnimationClip.js';
+export { Uniform } from './core/Uniform.js';
+export { InstancedBufferGeometry } from './core/InstancedBufferGeometry.js';
+export { BufferGeometry } from './core/BufferGeometry.js';
+export { Geometry } from './core/Geometry.js';
+export {
+  InterleavedBufferAttribute,
+} from './core/InterleavedBufferAttribute.js';
+export {
+  InstancedInterleavedBuffer,
+} from './core/InstancedInterleavedBuffer.js';
+export { InterleavedBuffer } from './core/InterleavedBuffer.js';
+export { InstancedBufferAttribute } from './core/InstancedBufferAttribute.js';
+export * from './core/BufferAttribute.js';
+export { Face3 } from './core/Face3.js';
+export { Object3D } from './core/Object3D.js';
+export { Raycaster } from './core/Raycaster.js';
+export { Layers } from './core/Layers.js';
+export { EventDispatcher } from './core/EventDispatcher.js';
+export { Clock } from './core/Clock.js';
+export {
+  QuaternionLinearInterpolant,
+} from './math/interpolants/QuaternionLinearInterpolant.js';
+export { LinearInterpolant } from './math/interpolants/LinearInterpolant.js';
+export {
+  DiscreteInterpolant,
+} from './math/interpolants/DiscreteInterpolant.js';
+export { CubicInterpolant } from './math/interpolants/CubicInterpolant.js';
+export { Interpolant } from './math/Interpolant.js';
+export { Triangle } from './math/Triangle.js';
+export { Math } from './math/Math.js';
+export { Spherical } from './math/Spherical.js';
+export { Cylindrical } from './math/Cylindrical.js';
+export { Plane } from './math/Plane.js';
+export { Frustum } from './math/Frustum.js';
+export { Sphere } from './math/Sphere.js';
+export { Ray } from './math/Ray.js';
+export { Matrix4 } from './math/Matrix4.js';
+export { Matrix3 } from './math/Matrix3.js';
+export { Box3 } from './math/Box3.js';
+export { Box2 } from './math/Box2.js';
+export { Line3 } from './math/Line3.js';
+export { Euler } from './math/Euler.js';
+export { Vector4 } from './math/Vector4.js';
+export { Vector3 } from './math/Vector3.js';
+export { Vector2 } from './math/Vector2.js';
+export { Quaternion } from './math/Quaternion.js';
+export { Color } from './math/Color.js';
+export {
+  ImmediateRenderObject,
+} from './extras/objects/ImmediateRenderObject.js';
+export { VertexNormalsHelper } from './helpers/VertexNormalsHelper.js';
+export { SpotLightHelper } from './helpers/SpotLightHelper.js';
+export { SkeletonHelper } from './helpers/SkeletonHelper.js';
+export { PointLightHelper } from './helpers/PointLightHelper.js';
+//export { RectAreaLightHelper } from './helpers/RectAreaLightHelper.js';
+export { HemisphereLightHelper } from './helpers/HemisphereLightHelper.js';
+export { GridHelper } from './helpers/GridHelper.js';
+//export { PolarGridHelper } from './helpers/PolarGridHelper.js';
+export { FaceNormalsHelper } from './helpers/FaceNormalsHelper.js';
+export { DirectionalLightHelper } from './helpers/DirectionalLightHelper.js';
+export { CameraHelper } from './helpers/CameraHelper.js';
+export { BoxHelper } from './helpers/BoxHelper.js';
+//export { Box3Helper } from './helpers/Box3Helper.js';
+export { PlaneHelper } from './helpers/PlaneHelper.js';
+export { ArrowHelper } from './helpers/ArrowHelper.js';
+export { AxesHelper } from './helpers/AxesHelper.js';
+export * from './extras/curves/Curves.js';
+export { Shape } from './extras/core/Shape.js';
+export { Path } from './extras/core/Path.js';
+export { ShapePath } from './extras/core/ShapePath.js';
+export { Font } from './extras/core/Font.js';
+export { CurvePath } from './extras/core/CurvePath.js';
+export { Curve } from './extras/core/Curve.js';
+export { ImageUtils } from './extras/ImageUtils.js';
+export { ShapeUtils } from './extras/ShapeUtils.js';
+//export { WebGLUtils } from './renderers/webgl/WebGLUtils.js';
+export * from './constants.js';
+export * from './Three.Legacy.js';

src/animation/AnimationAction.d.ts

@@ -0,0 +1,56 @@
+import { AnimationMixer } from './AnimationMixer';
+import { AnimationClip } from './AnimationClip';
+import { AnimationActionLoopStyles } from '../constants';
+// Animation ////////////////////////////////////////////////////////////////////////////////////////
+
+export class AnimationAction {
+  loop: boolean;
+  time: number;
+  timeScale: number;
+  weight: number;
+  repetitions: number;
+  paused: boolean;
+  enabled: boolean;
+  clampWhenFinished: boolean;
+  zeroSlopeAtStart: boolean;
+  zeroSlopeAtEnd: boolean;
+
+  play(): AnimationAction;
+  stop(): AnimationAction;
+  reset(): AnimationAction;
+  isRunning(): boolean;
+  startAt(time: number): AnimationAction;
+  setLoop(
+    mode: AnimationActionLoopStyles,
+    repetitions: number
+  ): AnimationAction;
+  setEffectiveWeight(weight: number): AnimationAction;
+  getEffectiveWeight(): number;
+  fadeIn(duration: number): AnimationAction;
+  fadeOut(duration: number): AnimationAction;
+  crossFadeFrom(
+    fadeOutAction: AnimationAction,
+    duration: number,
+    warp: boolean
+  ): AnimationAction;
+  crossFadeTo(
+    fadeInAction: AnimationAction,
+    duration: number,
+    warp: boolean
+  ): AnimationAction;
+  stopFading(): AnimationAction;
+  setEffectiveTimeScale(timeScale: number): AnimationAction;
+  getEffectiveTimeScale(): number;
+  setDuration(duration: number): AnimationAction;
+  syncWith(action: AnimationAction): AnimationAction;
+  halt(duration: number): AnimationAction;
+  warp(
+    statTimeScale: number,
+    endTimeScale: number,
+    duration: number
+  ): AnimationAction;
+  stopWarping(): AnimationAction;
+  getMixer(): AnimationMixer;
+  getClip(): AnimationClip;
+  getRoot(): any;
+}

src/animation/AnimationClip.d.ts

@@ -0,0 +1,37 @@
+import { KeyframeTrack } from './KeyframeTrack';
+import { Bone } from './../objects/Bone';
+import { MorphTarget } from '../core/Geometry';
+
+export class AnimationClip {
+  constructor(name?: string, duration?: number, tracks?: KeyframeTrack[]);
+
+  name: string;
+  tracks: KeyframeTrack[];
+  duration: number;
+  uuid: string;
+  results: any[];
+
+  resetDuration(): void;
+  trim(): AnimationClip;
+  optimize(): AnimationClip;
+
+  static CreateFromMorphTargetSequence(
+    name: string,
+    morphTargetSequence: MorphTarget[],
+    fps: number,
+    noLoop: boolean
+  ): AnimationClip;
+  static findByName(clipArray: AnimationClip[], name: string): AnimationClip;
+  static CreateClipsFromMorphTargetSequences(
+    morphTargets: MorphTarget[],
+    fps: number,
+    noLoop: boolean
+  ): AnimationClip[];
+  static parse(json: any): AnimationClip;
+  static parseAnimation(
+    animation: any,
+    bones: Bone[],
+    nodeName: string
+  ): AnimationClip;
+  static toJSON(): any;
+}

src/animation/AnimationMixer.d.ts

@@ -0,0 +1,19 @@
+import { AnimationClip } from './AnimationClip';
+import { AnimationAction } from './AnimationAction';
+import { EventDispatcher } from './../core/EventDispatcher';
+
+export class AnimationMixer extends EventDispatcher {
+  constructor(root: any);
+
+  time: number;
+  timeScale: number;
+
+  clipAction(clip: AnimationClip, root?: any): AnimationAction;
+  existingAction(clip: AnimationClip, root?: any): AnimationAction;
+  stopAllAction(): AnimationMixer;
+  update(deltaTime: number): AnimationMixer;
+  getRoot(): any;
+  uncacheClip(clip: AnimationClip): void;
+  uncacheRoot(root: any): void;
+  uncacheAction(clip: AnimationClip, root?: any): void;
+}

src/animation/AnimationObjectGroup.d.ts

@@ -0,0 +1,16 @@
+export class AnimationObjectGroup {
+  constructor(...args: any[]);
+
+  uuid: string;
+  stats: {
+    bindingsPerObject: number;
+    objects: {
+      total: number;
+      inUse: number;
+    };
+  };
+
+  add(...args: any[]): void;
+  remove(...args: any[]): void;
+  uncache(...args: any[]): void;
+}

src/animation/AnimationUtils.d.ts

@@ -0,0 +1,17 @@
+export namespace AnimationUtils {
+  export function arraySlice(array: any, from: number, to: number): any;
+  export function convertArray(array: any, type: any, forceClone: boolean): any;
+  export function isTypedArray(object: any): boolean;
+  export function getKeyFrameOrder(times: number): number[];
+  export function sortedArray(
+    values: any[],
+    stride: number,
+    order: number[]
+  ): any[];
+  export function flattenJSON(
+    jsonKeys: string[],
+    times: any[],
+    values: any[],
+    valuePropertyName: string
+  ): void;
+}

src/animation/KeyframeTrack.d.ts

@@ -0,0 +1,41 @@
+import { DiscreteInterpolant } from './../math/interpolants/DiscreteInterpolant';
+import { LinearInterpolant } from './../math/interpolants/LinearInterpolant';
+import { CubicInterpolant } from './../math/interpolants/CubicInterpolant';
+import { InterpolationModes } from '../constants';
+
+export class KeyframeTrack {
+  constructor(
+    name: string,
+    times: any[],
+    values: any[],
+    interpolation?: InterpolationModes
+  );
+
+  name: string;
+  times: any[];
+  values: any[];
+
+  ValueTypeName: string;
+  TimeBufferType: Float32Array;
+  ValueBufferType: Float32Array;
+
+  DefaultInterpolation: InterpolationModes;
+
+  InterpolantFactoryMethodDiscrete(result: any): DiscreteInterpolant;
+  InterpolantFactoryMethodLinear(result: any): LinearInterpolant;
+  InterpolantFactoryMethodSmooth(result: any): CubicInterpolant;
+
+  setInterpolation(interpolation: InterpolationModes): void;
+  getInterpolation(): InterpolationModes;
+
+  getValuesize(): number;
+
+  shift(timeOffset: number): KeyframeTrack;
+  scale(timeScale: number): KeyframeTrack;
+  trim(startTime: number, endTime: number): KeyframeTrack;
+  validate(): boolean;
+  optimize(): KeyframeTrack;
+
+  static parse(json: any): KeyframeTrack;
+  static toJSON(track: KeyframeTrack): any;
+}

src/animation/PropertyBinding.d.ts

@@ -0,0 +1,38 @@
+export class PropertyBinding {
+  constructor(rootNode: any, path: string, parsedPath?: any);
+
+  path: string;
+  parsedPath: any;
+  node: any;
+  rootNode: any;
+
+  getValue(targetArray: any, offset: number): any;
+  setValue(sourceArray: any, offset: number): void;
+  bind(): void;
+  unbind(): void;
+
+  BindingType: { [bindingType: string]: number };
+  Versioning: { [versioning: string]: number };
+
+  GetterByBindingType: Function[];
+  SetterByBindingTypeAndVersioning: Array<Function[]>;
+
+  static create(
+    root: any,
+    path: any,
+    parsedPath?: any
+  ): PropertyBinding | PropertyBinding.Composite;
+  static parseTrackName(trackName: string): any;
+  static findNode(root: any, nodeName: string): any;
+}
+
+export namespace PropertyBinding {
+  export class Composite {
+    constructor(targetGroup: any, path: any, parsedPath?: any);
+
+    getValue(array: any, offset: number): any;
+    setValue(array: any, offset: number): void;
+    bind(): void;
+    unbind(): void;
+  }
+}

src/animation/PropertyMixer.d.ts

@@ -0,0 +1,15 @@
+export class PropertyMixer {
+  constructor(binding: any, typeName: string, valueSize: number);
+
+  binding: any;
+  valueSize: number;
+  buffer: any;
+  cumulativeWeight: number;
+  useCount: number;
+  referenceCount: number;
+
+  accumulate(accuIndex: number, weight: number): void;
+  apply(accuIndex: number): void;
+  saveOriginalState(): void;
+  restoreOriginalState(): void;
+}

src/animation/tracks/BooleanKeyframeTrack.d.ts

@@ -0,0 +1,5 @@
+import { KeyframeTrack } from './../KeyframeTrack';
+
+export class BooleanKeyframeTrack extends KeyframeTrack {
+  constructor(name: string, times: any[], values: any[]);
+}

src/animation/tracks/ColorKeyframeTrack.d.ts

@@ -0,0 +1,11 @@
+import { KeyframeTrack } from './../KeyframeTrack';
+import { InterpolationModes } from '../../constants';
+
+export class ColorKeyframeTrack extends KeyframeTrack {
+  constructor(
+    name: string,
+    times: any[],
+    values: any[],
+    interpolation?: InterpolationModes
+  );
+}

src/animation/tracks/NumberKeyframeTrack.d.ts

@@ -0,0 +1,11 @@
+import { KeyframeTrack } from './../KeyframeTrack';
+import { InterpolationModes } from '../../constants';
+
+export class NumberKeyframeTrack extends KeyframeTrack {
+  constructor(
+    name: string,
+    times: any[],
+    values: any[],
+    interpolation?: InterpolationModes
+  );
+}

src/animation/tracks/QuaternionKeyframeTrack.d.ts

@@ -0,0 +1,11 @@
+import { KeyframeTrack } from './../KeyframeTrack';
+import { InterpolationModes } from '../../constants';
+
+export class QuaternionKeyframeTrack extends KeyframeTrack {
+  constructor(
+    name: string,
+    times: any[],
+    values: any[],
+    interpolation?: InterpolationModes
+  );
+}

src/animation/tracks/StringKeyframeTrack.d.ts

@@ -0,0 +1,11 @@
+import { KeyframeTrack } from './../KeyframeTrack';
+import { InterpolationModes } from '../../constants';
+
+export class StringKeyframeTrack extends KeyframeTrack {
+  constructor(
+    name: string,
+    times: any[],
+    values: any[],
+    interpolation?: InterpolationModes
+  );
+}

src/animation/tracks/VectorKeyframeTrack.d.ts

@@ -0,0 +1,11 @@
+import { KeyframeTrack } from './../KeyframeTrack';
+import { InterpolationModes } from '../../constants';
+
+export class VectorKeyframeTrack extends KeyframeTrack {
+  constructor(
+    name: string,
+    times: any[],
+    values: any[],
+    interpolation?: InterpolationModes
+  );
+}

src/audio/Audio.d.ts

@@ -0,0 +1,49 @@
+import { Object3D } from './../core/Object3D';
+import { AudioListener } from './AudioListener';
+import { AudioContext } from './AudioContext';
+
+// Extras / Audio /////////////////////////////////////////////////////////////////////
+
+export class Audio extends Object3D {
+  constructor(listener: AudioListener);
+  type: 'Audio';
+
+  context: AudioContext;
+  gain: GainNode;
+  autoplay: boolean;
+  buffer: null | Audio;
+  loop: boolean;
+  startTime: number;
+  offset: number;
+  playbackRate: number;
+  isPlaying: boolean;
+  hasPlaybackControl: boolean;
+  sourceType: string;
+  source: AudioBufferSourceNode;
+  filters: any[];
+
+  getOutput(): GainNode;
+  setNodeSource(audioNode: AudioBufferSourceNode): this;
+  setMediaElementSource(mediaElement: MediaElementAudioSourceNode): this;
+  setBuffer(audioBuffer: AudioBuffer): this;
+  play(): this;
+  onEnded(): void;
+  pause(): this;
+  stop(): this;
+  connect(): this;
+  disconnect(): this;
+  getFilters(): any[];
+  setFilter(value: any[]): this;
+  getFilter(): any;
+  setFilter(filter: any): this;
+  setPlaybackRate(value: number): this;
+  getPlaybackRate(): number;
+  getLoop(): boolean;
+  setLoop(value: boolean): void;
+  getVolume(): number;
+  setVolume(value: number): this;
+  /**
+   * @deprecated Use {@link AudioLoader} instead.
+   */
+  load(file: string): Audio;
+}

src/audio/AudioAnalyser.d.ts

@@ -0,0 +1,14 @@
+export class AudioAnalyser {
+  constructor(audio: any, fftSize: number);
+
+  analyser: any;
+  data: Uint8Array;
+
+  getFrequencyData(): Uint8Array;
+  getAverageFrequency(): number;
+
+  /**
+   * @deprecated Use {@link AudioAnalyser#getFrequencyData .getFrequencyData()} instead.
+   */
+  getData(file: any): any;
+}

src/audio/AudioContext.d.ts

@@ -0,0 +1 @@
+export const AudioContext: AudioContext;

src/audio/AudioListener.d.ts

@@ -0,0 +1,19 @@
+import { Object3D } from './../core/Object3D';
+import { AudioContext } from './AudioContext';
+
+export class AudioListener extends Object3D {
+  constructor();
+
+  type: 'AudioListener';
+  context: AudioContext;
+  gain: GainNode;
+  filter: null | any;
+
+  getInput(): GainNode;
+  removeFilter(): void;
+  setFilter(value: any): void;
+  getFilter(): any;
+  setMasterVolume(value: number): void;
+  getMasterVolume(): number;
+  updateMatrixWorld(force?: boolean): void;
+}

src/audio/PositionalAudio.d.ts

@@ -0,0 +1,28 @@
+import { AudioListener } from './AudioListener';
+import { Audio } from './Audio';
+
+export class AudioBuffer {
+  constructor(context: any);
+
+  context: any;
+  ready: boolean;
+  readyCallbacks: Function[];
+
+  load(file: string): AudioBuffer;
+  onReady(callback: Function): void;
+}
+
+export class PositionalAudio extends Audio {
+  constructor(listener: AudioListener);
+
+  panner: PannerNode;
+
+  setRefDistance(value: number): void;
+  getRefDistance(): number;
+  setRolloffFactor(value: number): void;
+  getRolloffFactor(): number;
+  setDistanceModel(value: number): void;
+  getDistanceModel(): number;
+  setMaxDistance(value: number): void;
+  getMaxDistance(): number;
+}

src/cameras/ArrayCamera.d.ts

@@ -0,0 +1,8 @@
+import { PerspectiveCamera } from './PerspectiveCamera';
+
+export class ArrayCamera extends PerspectiveCamera {
+  constructor(cameras?: PerspectiveCamera[]);
+
+  cameras: PerspectiveCamera[];
+  isArrayCamera: true;
+}

src/cameras/Camera.d.ts

@@ -0,0 +1,33 @@
+import { Matrix4 } from './../math/Matrix4';
+import { Vector3 } from './../math/Vector3';
+import { Object3D } from './../core/Object3D';
+
+// Cameras ////////////////////////////////////////////////////////////////////////////////////////
+
+/**
+ * Abstract base class for cameras. This class should always be inherited when you build a new camera.
+ */
+export class Camera extends Object3D {
+  /**
+   * This constructor sets following properties to the correct type: matrixWorldInverse, projectionMatrix and projectionMatrixInverse.
+   */
+  constructor();
+
+  /**
+   * This is the inverse of matrixWorld. MatrixWorld contains the Matrix which has the world transform of the Camera.
+   */
+  matrixWorldInverse: Matrix4;
+
+  /**
+   * This is the matrix which contains the projection.
+   */
+  projectionMatrix: Matrix4;
+
+  isCamera: true;
+
+  copy(source: Camera, recursive?: boolean): this;
+
+  getWorldDirection(target: Vector3): Vector3;
+
+  updateMatrixWorld(force: boolean): void;
+}

src/cameras/CubeCamera.d.ts

@@ -0,0 +1,19 @@
+import { WebGLRenderTargetCube } from './../renderers/WebGLRenderTargetCube';
+import { Scene } from './../scenes/Scene';
+import { WebGLRenderer } from './../renderers/WebGLRenderer';
+import { Object3D } from './../core/Object3D';
+
+export class CubeCamera extends Object3D {
+  constructor(near?: number, far?: number, cubeResolution?: number);
+
+  type: 'CubeCamera';
+
+  renderTarget: WebGLRenderTargetCube;
+
+  /**
+   * @deprecated Use {@link CubeCamera#update .update()} instead
+   */
+  //updateCubeMap(renderer: Renderer, scene: Scene): void;
+
+  update(renderer: WebGLRenderer, scene: Scene): void;
+}

src/cameras/OrthographicCamera.d.ts

@@ -0,0 +1,89 @@
+import { Camera } from './Camera';
+
+/**
+ * Camera with orthographic projection
+ *
+ * @example
+ * var camera = new THREE.OrthographicCamera( width / - 2, width / 2, height / 2, height / - 2, 1, 1000 );
+ * scene.add( camera );
+ *
+ * @see <a href="https://github.com/mrdoob/three.js/blob/master/src/cameras/OrthographicCamera.js">src/cameras/OrthographicCamera.js</a>
+ */
+export class OrthographicCamera extends Camera {
+  /**
+   * @param left Camera frustum left plane.
+   * @param right Camera frustum right plane.
+   * @param top Camera frustum top plane.
+   * @param bottom Camera frustum bottom plane.
+   * @param near Camera frustum near plane.
+   * @param far Camera frustum far plane.
+   */
+  constructor(
+    left: number,
+    right: number,
+    top: number,
+    bottom: number,
+    near?: number,
+    far?: number
+  );
+
+  type: 'OrthographicCamera';
+
+  isOrthographicCamera: true;
+
+  zoom: number;
+  view: null | {
+    enabled: boolean;
+    fullWidth: number;
+    fullHeight: number;
+    offsetX: number;
+    offsetY: number;
+    width: number;
+    height: number;
+  };
+
+  /**
+   * Camera frustum left plane.
+   */
+  left: number;
+
+  /**
+   * Camera frustum right plane.
+   */
+  right: number;
+
+  /**
+   * Camera frustum top plane.
+   */
+  top: number;
+
+  /**
+   * Camera frustum bottom plane.
+   */
+  bottom: number;
+
+  /**
+   * Camera frustum near plane.
+   */
+  near: number;
+
+  /**
+   * Camera frustum far plane.
+   */
+  far: number;
+
+  /**
+   * Updates the camera projection matrix. Must be called after change of parameters.
+   */
+  updateProjectionMatrix(): void;
+  setViewOffset(
+    fullWidth: number,
+    fullHeight: number,
+    offsetX: number,
+    offsetY: number,
+    width: number,
+    height: number
+  ): void;
+  clearViewOffset(): void;
+  toJSON(meta?: any): any;
+}

src/cameras/PerspectiveCamera.d.ts

@@ -0,0 +1,123 @@
+import { Camera } from './Camera';
+
+/**
+ * Camera with perspective projection.
+ *
+ * # example
+ *     var camera = new THREE.PerspectiveCamera( 45, width / height, 1, 1000 );
+ *     scene.add( camera );
+ *
+ * @source https://github.com/mrdoob/three.js/blob/master/src/cameras/PerspectiveCamera.js
+ */
+export class PerspectiveCamera extends Camera {
+  /**
+   * @param fov Camera frustum vertical field of view. Default value is 50.
+   * @param aspect Camera frustum aspect ratio. Default value is 1.
+   * @param near Camera frustum near plane. Default value is 0.1.
+   * @param far Camera frustum far plane. Default value is 2000.
+   */
+  constructor(fov?: number, aspect?: number, near?: number, far?: number);
+
+  type: 'PerspectiveCamera';
+
+  isPerspectiveCamera: true;
+
+  zoom: number;
+
+  /**
+   * Camera frustum vertical field of view, from bottom to top of view, in degrees.
+   */
+  fov: number;
+
+  /**
+   * Camera frustum aspect ratio, window width divided by window height.
+   */
+  aspect: number;
+
+  /**
+   * Camera frustum near plane.
+   */
+  near: number;
+
+  /**
+   * Camera frustum far plane.
+   */
+  far: number;
+
+  focus: number;
+  view: null | {
+    enabled: boolean;
+    fullWidth: number;
+    fullHeight: number;
+    offsetX: number;
+    offsetY: number;
+    width: number;
+    height: number;
+  };
+  filmGauge: number;
+  filmOffset: number;
+
+  setFocalLength(focalLength: number): void;
+  getFocalLength(): number;
+  getEffectiveFOV(): number;
+  getFilmWidth(): number;
+  getFilmHeight(): number;
+
+  /**
+   * Sets an offset in a larger frustum. This is useful for multi-window or multi-monitor/multi-machine setups.
+   * For example, if you have 3x2 monitors and each monitor is 1920x1080 and the monitors are in grid like this:
+   *
+   *     +---+---+---+
+   *     | A | B | C |
+   *     +---+---+---+
+   *     | D | E | F |
+   *     +---+---+---+
+   *
+   * then for each monitor you would call it like this:
+   *
+   *     var w = 1920;
+   *     var h = 1080;
+   *     var fullWidth = w * 3;
+   *     var fullHeight = h * 2;
+   *
+   *     // A
+   *     camera.setViewOffset( fullWidth, fullHeight, w * 0, h * 0, w, h );
+   *     // B
+   *     camera.setViewOffset( fullWidth, fullHeight, w * 1, h * 0, w, h );
+   *     // C
+   *     camera.setViewOffset( fullWidth, fullHeight, w * 2, h * 0, w, h );
+   *     // D
+   *     camera.setViewOffset( fullWidth, fullHeight, w * 0, h * 1, w, h );
+   *     // E
+   *     camera.setViewOffset( fullWidth, fullHeight, w * 1, h * 1, w, h );
+   *     // F
+   *     camera.setViewOffset( fullWidth, fullHeight, w * 2, h * 1, w, h ); Note there is no reason monitors have to be the same size or in a grid.
+   *
+   * @param fullWidth full width of multiview setup
+   * @param fullHeight full height of multiview setup
+   * @param x horizontal offset of subcamera
+   * @param y vertical offset of subcamera
+   * @param width width of subcamera
+   * @param height height of subcamera
+   */
+  setViewOffset(
+    fullWidth: number,
+    fullHeight: number,
+    x: number,
+    y: number,
+    width: number,
+    height: number
+  ): void;
+  clearViewOffset(): void;
+
+  /**
+   * Updates the camera projection matrix. Must be called after change of parameters.
+   */
+  updateProjectionMatrix(): void;
+  toJSON(meta?: any): any;
+
+  /**
+   * @deprecated Use {@link PerspectiveCamera#setFocalLength .setFocalLength()} and {@link PerspectiveCamera#filmGauge .filmGauge} instead.
+   */
+  setLens(focalLength: number, frameHeight?: number): void;
+}

src/cameras/StereoCamera.d.ts

@@ -0,0 +1,15 @@
+import { PerspectiveCamera } from './PerspectiveCamera';
+import { Camera } from './Camera';
+
+export class StereoCamera extends Camera {
+  constructor();
+
+  type: 'StereoCamera';
+
+  aspect: number;
+  eyeSep: number;
+  cameraL: PerspectiveCamera;
+  cameraR: PerspectiveCamera;
+
+  update(camera: PerspectiveCamera): void;
+}

src/constants.d.ts

@@ -0,0 +1,218 @@
+export const REVISION: string;
+
+// https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent.button
+export enum MOUSE {
+  LEFT,
+  MIDDLE,
+  RIGHT,
+}
+
+// GL STATE CONSTANTS
+export enum CullFace {}
+export const CullFaceNone: CullFace;
+export const CullFaceBack: CullFace;
+export const CullFaceFront: CullFace;
+export const CullFaceFrontBack: CullFace;
+
+export enum FrontFaceDirection {}
+export const FrontFaceDirectionCW: FrontFaceDirection;
+export const FrontFaceDirectionCCW: FrontFaceDirection;
+
+// Shadowing Type
+export enum ShadowMapType {}
+export const BasicShadowMap: ShadowMapType;
+export const PCFShadowMap: ShadowMapType;
+export const PCFSoftShadowMap: ShadowMapType;
+
+// MATERIAL CONSTANTS
+
+// side
+export enum Side {}
+export const FrontSide: Side;
+export const BackSide: Side;
+export const DoubleSide: Side;
+
+// shading
+export enum Shading {}
+export const FlatShading: Shading;
+export const SmoothShading: Shading;
+
+// colors
+export enum Colors {}
+export const NoColors: Colors;
+export const FaceColors: Colors;
+export const VertexColors: Colors;
+
+// blending modes
+export enum Blending {}
+export const NoBlending: Blending;
+export const NormalBlending: Blending;
+export const AdditiveBlending: Blending;
+export const SubtractiveBlending: Blending;
+export const MultiplyBlending: Blending;
+export const CustomBlending: Blending;
+
+// custom blending equations
+// (numbers start from 100 not to clash with other
+//  mappings to OpenGL constants defined in Texture.js)
+export enum BlendingEquation {}
+export const AddEquation: BlendingEquation;
+export const SubtractEquation: BlendingEquation;
+export const ReverseSubtractEquation: BlendingEquation;
+export const MinEquation: BlendingEquation;
+export const MaxEquation: BlendingEquation;
+
+// custom blending destination factors
+export enum BlendingDstFactor {}
+export const ZeroFactor: BlendingDstFactor;
+export const OneFactor: BlendingDstFactor;
+export const SrcColorFactor: BlendingDstFactor;
+export const OneMinusSrcColorFactor: BlendingDstFactor;
+export const SrcAlphaFactor: BlendingDstFactor;
+export const OneMinusSrcAlphaFactor: BlendingDstFactor;
+export const DstAlphaFactor: BlendingDstFactor;
+export const OneMinusDstAlphaFactor: BlendingDstFactor;
+export const DstColorFactor: BlendingDstFactor;
+export const OneMinusDstColorFactor: BlendingDstFactor;
+
+// custom blending src factors
+export enum BlendingSrcFactor {}
+export const SrcAlphaSaturateFactor: BlendingSrcFactor;
+
+// depth modes
+export enum DepthModes {}
+export const NeverDepth: DepthModes;
+export const AlwaysDepth: DepthModes;
+export const LessDepth: DepthModes;
+export const LessEqualDepth: DepthModes;
+export const EqualDepth: DepthModes;
+export const GreaterEqualDepth: DepthModes;
+export const GreaterDepth: DepthModes;
+export const NotEqualDepth: DepthModes;
+
+// TEXTURE CONSTANTS
+// Operations
+export enum Combine {}
+export const MultiplyOperation: Combine;
+export const MixOperation: Combine;
+export const AddOperation: Combine;
+
+// Tone Mapping modes
+export enum ToneMapping {}
+export const NoToneMapping: ToneMapping;
+export const LinearToneMapping: ToneMapping;
+export const ReinhardToneMapping: ToneMapping;
+export const Uncharted2ToneMapping: ToneMapping;
+export const CineonToneMapping: ToneMapping;
+
+// Mapping modes
+export enum Mapping {}
+export const UVMapping: Mapping;
+export const CubeReflectionMapping: Mapping;
+export const CubeRefractionMapping: Mapping;
+export const EquirectangularReflectionMapping: Mapping;
+export const EquirectangularRefractionMapping: Mapping;
+export const SphericalReflectionMapping: Mapping;
+export const CubeUVReflectionMapping: Mapping;
+export const CubeUVRefractionMapping: Mapping;
+
+// Wrapping modes
+export enum Wrapping {}
+export const RepeatWrapping: Wrapping;
+export const ClampToEdgeWrapping: Wrapping;
+export const MirroredRepeatWrapping: Wrapping;
+
+// Filters
+export enum TextureFilter {}
+export const NearestFilter: TextureFilter;
+export const NearestMipMapNearestFilter: TextureFilter;
+export const NearestMipMapLinearFilter: TextureFilter;
+export const LinearFilter: TextureFilter;
+export const LinearMipMapNearestFilter: TextureFilter;
+export const LinearMipMapLinearFilter: TextureFilter;
+
+// Data types
+export enum TextureDataType {}
+export const UnsignedByteType: TextureDataType;
+export const ByteType: TextureDataType;
+export const ShortType: TextureDataType;
+export const UnsignedShortType: TextureDataType;
+export const IntType: TextureDataType;
+export const UnsignedIntType: TextureDataType;
+export const FloatType: TextureDataType;
+export const HalfFloatType: TextureDataType;
+
+// Pixel types
+export enum PixelType {}
+export const UnsignedShort4444Type: PixelType;
+export const UnsignedShort5551Type: PixelType;
+export const UnsignedShort565Type: PixelType;
+export const UnsignedInt248Type: PixelType;
+
+// Pixel formats
+export enum PixelFormat {}
+export const AlphaFormat: PixelFormat;
+export const RGBFormat: PixelFormat;
+export const RGBAFormat: PixelFormat;
+export const LuminanceFormat: PixelFormat;
+export const LuminanceAlphaFormat: PixelFormat;
+export const RGBEFormat: PixelFormat;
+export const DepthFormat: PixelFormat;
+export const DepthStencilFormat: PixelFormat;
+
+// Compressed texture formats
+// DDS / ST3C Compressed texture formats
+export enum CompressedPixelFormat {}
+export const RGB_S3TC_DXT1_Format: CompressedPixelFormat;
+export const RGBA_S3TC_DXT1_Format: CompressedPixelFormat;
+export const RGBA_S3TC_DXT3_Format: CompressedPixelFormat;
+export const RGBA_S3TC_DXT5_Format: CompressedPixelFormat;
+
+// PVRTC compressed './texture formats
+export const RGB_PVRTC_4BPPV1_Format: CompressedPixelFormat;
+export const RGB_PVRTC_2BPPV1_Format: CompressedPixelFormat;
+export const RGBA_PVRTC_4BPPV1_Format: CompressedPixelFormat;
+export const RGBA_PVRTC_2BPPV1_Format: CompressedPixelFormat;
+
+// ETC compressed texture formats
+export const RGB_ETC1_Format: CompressedPixelFormat;
+
+// Loop styles for AnimationAction
+export enum AnimationActionLoopStyles {}
+export const LoopOnce: AnimationActionLoopStyles;
+export const LoopRepeat: AnimationActionLoopStyles;
+export const LoopPingPong: AnimationActionLoopStyles;
+
+// Interpolation
+export enum InterpolationModes {}
+export const InterpolateDiscrete: InterpolationModes;
+export const InterpolateLinear: InterpolationModes;
+export const InterpolateSmooth: InterpolationModes;
+
+// Interpolant ending modes
+export enum InterpolationEndingModes {}
+export const ZeroCurvatureEnding: InterpolationEndingModes;
+export const ZeroSlopeEnding: InterpolationEndingModes;
+export const WrapAroundEnding: InterpolationEndingModes;
+
+// Triangle Draw modes
+export enum TrianglesDrawModes {}
+export const TrianglesDrawMode: TrianglesDrawModes;
+export const TriangleStripDrawMode: TrianglesDrawModes;
+export const TriangleFanDrawMode: TrianglesDrawModes;
+
+// Texture Encodings
+export enum TextureEncoding {}
+export const LinearEncoding: TextureEncoding;
+export const sRGBEncoding: TextureEncoding;
+export const GammaEncoding: TextureEncoding;
+export const RGBEEncoding: TextureEncoding;
+export const LogLuvEncoding: TextureEncoding;
+export const RGBM7Encoding: TextureEncoding;
+export const RGBM16Encoding: TextureEncoding;
+export const RGBDEncoding: TextureEncoding;
+
+// Depth packing strategies
+export enum DepthPackingStrategies {}
+export const BasicDepthPacking: DepthPackingStrategies;
+export const RGBADepthPacking: DepthPackingStrategies;

src/core/BufferAttribute.d.ts

@@ -0,0 +1,198 @@
+/**
+ * @see <a href="https://github.com/mrdoob/three.js/blob/master/src/core/BufferAttribute.js">src/core/BufferAttribute.js</a>
+ */
+export class BufferAttribute {
+  constructor(array: ArrayLike<number>, itemSize: number, normalized?: boolean); // array parameter should be TypedArray.
+
+  uuid: string;
+  array: ArrayLike<number>;
+  itemSize: number;
+  dynamic: boolean;
+  updateRange: { offset: number; count: number };
+  version: number;
+  normalized: boolean;
+  needsUpdate: boolean;
+  count: number;
+  onUpload: Function;
+
+  setArray(array?: ArrayBufferView): void;
+  setDynamic(dynamic: boolean): BufferAttribute;
+  clone(): this;
+  copy(source: BufferAttribute): this;
+  copyAt(
+    index1: number,
+    attribute: BufferAttribute,
+    index2: number
+  ): BufferAttribute;
+  copyArray(array: ArrayLike<number>): BufferAttribute;
+  copyColorsArray(
+    colors: { r: number; g: number; b: number }[]
+  ): BufferAttribute;
+  copyVector2sArray(vectors: { x: number; y: number }[]): BufferAttribute;
+  copyVector3sArray(
+    vectors: { x: number; y: number; z: number }[]
+  ): BufferAttribute;
+  copyVector4sArray(
+    vectors: { x: number; y: number; z: number; w: number }[]
+  ): BufferAttribute;
+  set(
+    value: ArrayLike<number> | ArrayBufferView,
+    offset?: number
+  ): BufferAttribute;
+  getX(index: number): number;
+  setX(index: number, x: number): BufferAttribute;
+  getY(index: number): number;
+  setY(index: number, y: number): BufferAttribute;
+  getZ(index: number): number;
+  setZ(index: number, z: number): BufferAttribute;
+  getW(index: number): number;
+  setW(index: number, z: number): BufferAttribute;
+  setXY(index: number, x: number, y: number): BufferAttribute;
+  setXYZ(index: number, x: number, y: number, z: number): BufferAttribute;
+  setXYZW(
+    index: number,
+    x: number,
+    y: number,
+    z: number,
+    w: number
+  ): BufferAttribute;
+  /**
+   * @deprecated Use {@link BufferAttribute#count .count} instead.
+   */
+  length: number;
+}
+
+/**
+ * @deprecated THREE.Int8Attribute has been removed. Use new THREE.Int8BufferAttribute() instead.
+ */
+export class Int8Attribute extends BufferAttribute {
+  constructor(array: any, itemSize: number);
+}
+
+/**
+ * @deprecated THREE.Uint8Attribute has been removed. Use new THREE.Uint8BufferAttribute() instead.
+ */
+export class Uint8Attribute extends BufferAttribute {
+  constructor(array: any, itemSize: number);
+}
+
+/**
+ * @deprecated THREE.Uint8ClampedAttribute has been removed. Use new THREE.Uint8ClampedBufferAttribute() instead.
+ */
+export class Uint8ClampedAttribute extends BufferAttribute {
+  constructor(array: any, itemSize: number);
+}
+
+/**
+ * @deprecated THREE.Int16Attribute has been removed. Use new THREE.Int16BufferAttribute() instead.
+ */
+export class Int16Attribute extends BufferAttribute {
+  constructor(array: any, itemSize: number);
+}
+
+/**
+ * @deprecated THREE.Uint16Attribute has been removed. Use new THREE.Uint16BufferAttribute() instead.
+ */
+export class Uint16Attribute extends BufferAttribute {
+  constructor(array: any, itemSize: number);
+}
+
+/**
+ * @deprecated THREE.Int32Attribute has been removed. Use new THREE.Int32BufferAttribute() instead.
+ */
+export class Int32Attribute extends BufferAttribute {
+  constructor(array: any, itemSize: number);
+}
+
+/**
+ * @deprecated THREE.Uint32Attribute has been removed. Use new THREE.Uint32BufferAttribute() instead.
+ */
+export class Uint32Attribute extends BufferAttribute {
+  constructor(array: any, itemSize: number);
+}
+
+/**
+ * @deprecated THREE.Float32Attribute has been removed. Use new THREE.Float32BufferAttribute() instead.
+ */
+export class Float32Attribute extends BufferAttribute {
+  constructor(array: any, itemSize: number);
+}
+
+/**
+ * @deprecated THREE.Float64Attribute has been removed. Use new THREE.Float64BufferAttribute() instead.
+ */
+export class Float64Attribute extends BufferAttribute {
+  constructor(array: any, itemSize: number);
+}
+
+export class Int8BufferAttribute extends BufferAttribute {
+  constructor(
+    array: Iterable<number> | ArrayLike<number> | ArrayBuffer,
+    itemSize: number,
+    normalized?: boolean
+  );
+}
+
+export class Uint8BufferAttribute extends BufferAttribute {
+  constructor(
+    array: Iterable<number> | ArrayLike<number> | ArrayBuffer,
+    itemSize: number,
+    normalized?: boolean
+  );
+}
+
+export class Uint8ClampedBufferAttribute extends BufferAttribute {
+  constructor(
+    array: Iterable<number> | ArrayLike<number> | ArrayBuffer,
+    itemSize: number,
+    normalized?: boolean
+  );
+}
+
+export class Int16BufferAttribute extends BufferAttribute {
+  constructor(
+    array: Iterable<number> | ArrayLike<number> | ArrayBuffer,
+    itemSize: number,
+    normalized?: boolean
+  );
+}
+
+export class Uint16BufferAttribute extends BufferAttribute {
+  constructor(
+    array: Iterable<number> | ArrayLike<number> | ArrayBuffer,
+    itemSize: number,
+    normalized?: boolean
+  );
+}
+
+export class Int32BufferAttribute extends BufferAttribute {
+  constructor(
+    array: Iterable<number> | ArrayLike<number> | ArrayBuffer,
+    itemSize: number,
+    normalized?: boolean
+  );
+}
+
+export class Uint32BufferAttribute extends BufferAttribute {
+  constructor(
+    array: Iterable<number> | ArrayLike<number> | ArrayBuffer,
+    itemSize: number,
+    normalized?: boolean
+  );
+}
+
+export class Float32BufferAttribute extends BufferAttribute {
+  constructor(
+    array: Iterable<number> | ArrayLike<number> | ArrayBuffer,
+    itemSize: number,
+    normalized?: boolean
+  );
+}
+
+export class Float64BufferAttribute extends BufferAttribute {
+  constructor(
+    array: Iterable<number> | ArrayLike<number> | ArrayBuffer,
+    itemSize: number,
+    normalized?: boolean
+  );
+}

src/core/BufferGeometry.d.ts

@@ -0,0 +1,144 @@
+import { BufferAttribute } from './BufferAttribute';
+import { Box3 } from './../math/Box3';
+import { Sphere } from './../math/Sphere';
+import { Matrix4 } from './../math/Matrix4';
+import { Vector2 } from './../math/Vector2';
+import { Vector3 } from './../math/Vector3';
+import { Object3D } from './Object3D';
+import { Geometry } from './Geometry';
+import { DirectGeometry } from './DirectGeometry';
+import { EventDispatcher } from './EventDispatcher';
+import { InterleavedBufferAttribute } from './InterleavedBufferAttribute';
+/**
+ * @deprecated Use {@link BufferAttribute#setDynamic THREE.BufferAttribute().setDynamic( true )} instead.
+ */
+
+/**
+ * This is a superefficent class for geometries because it saves all data in buffers.
+ * It reduces memory costs and cpu cycles. But it is not as easy to work with because of all the nessecary buffer calculations.
+ * It is mainly interesting when working with static objects.
+ *
+ * @see <a href="https://github.com/mrdoob/three.js/blob/master/src/core/BufferGeometry.js">src/core/BufferGeometry.js</a>
+ */
+export class BufferGeometry extends EventDispatcher {
+  /**
+   * This creates a new BufferGeometry. It also sets several properties to an default value.
+   */
+  constructor();
+
+  static MaxIndex: number;
+
+  /**
+   * Unique number of this buffergeometry instance
+   */
+  id: number;
+  uuid: string;
+  name: string;
+  type: string;
+  index: BufferAttribute;
+  attributes: {
+    [name: string]: BufferAttribute | InterleavedBufferAttribute;
+  };
+  morphAttributes: any;
+  groups: { start: number; count: number; materialIndex?: number }[];
+  boundingBox: Box3;
+  boundingSphere: Sphere;
+  drawRange: { start: number; count: number };
+
+  getIndex(): BufferAttribute;
+  setIndex(index: BufferAttribute | number[]): void;
+
+  addAttribute(
+    name: string,
+    attribute: BufferAttribute | InterleavedBufferAttribute
+  ): BufferGeometry;
+
+  getAttribute(name: string): BufferAttribute | InterleavedBufferAttribute;
+  removeAttribute(name: string): BufferGeometry;
+
+  addGroup(start: number, count: number, materialIndex?: number): void;
+  clearGroups(): void;
+
+  setDrawRange(start: number, count: number): void;
+
+  /**
+   * Bakes matrix transform directly into vertex coordinates.
+   */
+  applyMatrix(matrix: Matrix4): BufferGeometry;
+
+  rotateX(angle: number): BufferGeometry;
+  rotateY(angle: number): BufferGeometry;
+  rotateZ(angle: number): BufferGeometry;
+  translate(x: number, y: number, z: number): BufferGeometry;
+  scale(x: number, y: number, z: number): BufferGeometry;
+  lookAt(v: Vector3): void;
+
+  center(): BufferGeometry;
+
+  setFromObject(object: Object3D): BufferGeometry;
+  setFromPoints(points: Vector3[] | Vector2[]): BufferGeometry;
+  updateFromObject(object: Object3D): void;
+
+  fromGeometry(geometry: Geometry, settings?: any): BufferGeometry;
+
+  fromDirectGeometry(geometry: DirectGeometry): BufferGeometry;
+
+  /**
+   * Computes bounding box of the geometry, updating Geometry.boundingBox attribute.
+   * Bounding boxes aren't computed by default. They need to be explicitly computed, otherwise they are null.
+   */
+  computeBoundingBox(): void;
+
+  /**
+   * Computes bounding sphere of the geometry, updating Geometry.boundingSphere attribute.
+   * Bounding spheres aren't' computed by default. They need to be explicitly computed, otherwise they are null.
+   */
+  computeBoundingSphere(): void;
+
+  /**
+   * Computes vertex normals by averaging face normals.
+   */
+  computeVertexNormals(): void;
+
+  merge(geometry: BufferGeometry, offset: number): BufferGeometry;
+  normalizeNormals(): void;
+
+  toNonIndexed(): BufferGeometry;
+
+  toJSON(): any;
+  clone(): this;
+  copy(source: BufferGeometry): this;
+
+  /**
+   * Disposes the object from memory.
+   * You need to call this when you want the bufferGeometry removed while the application is running.
+   */
+  dispose(): void;
+
+  /**
+   * @deprecated Use {@link BufferGeometry#groups .groups} instead.
+   */
+  drawcalls: any;
+
+  /**
+   * @deprecated Use {@link BufferGeometry#groups .groups} instead.
+   */
+  offsets: any;
+
+  /**
+   * @deprecated Use {@link BufferGeometry#setIndex .setIndex()} instead.
+   */
+  addIndex(index: any): void;
+
+  /**
+   * @deprecated Use {@link BufferGeometry#addGroup .addGroup()} instead.
+   */
+  addDrawCall(start: any, count: any, indexOffset?: any): void;
+
+  /**
+   * @deprecated Use {@link BufferGeometry#clearGroups .clearGroups()} instead.
+   */
+  clearDrawCalls(): void;
+
+  addAttribute(name: any, array: any, itemSize: any): any;
+}

src/core/Clock.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Object for keeping track of time.
+ *
+ * @see <a href="https://github.com/mrdoob/three.js/blob/master/src/core/Clock.js">src/core/Clock.js</a>
+ */
+export class Clock {
+  /**
+   * @param autoStart Automatically start the clock.
+   */
+  constructor(autoStart?: boolean);
+
+  /**
+   * If set, starts the clock automatically when the first update is called.
+   */
+  autoStart: boolean;
+
+  /**
+   * When the clock is running, It holds the starttime of the clock.
+   * This counted from the number of milliseconds elapsed since 1 January 1970 00:00:00 UTC.
+   */
+  startTime: number;
+
+  /**
+   * When the clock is running, It holds the previous time from a update.
+   * This counted from the number of milliseconds elapsed since 1 January 1970 00:00:00 UTC.
+   */
+  oldTime: number;
+
+  /**
+   * When the clock is running, It holds the time elapsed between the start of the clock to the previous update.
+   * This parameter is in seconds of three decimal places.
+   */
+  elapsedTime: number;
+
+  /**
+   * This property keeps track whether the clock is running or not.
+   */
+  running: boolean;
+
+  /**
+   * Starts clock.
+   */
+  start(): void;
+
+  /**
+   * Stops clock.
+   */
+  stop(): void;
+
+  /**
+   * Get the seconds passed since the clock started.
+   */
+  getElapsedTime(): number;
+
+  /**
+   * Get the seconds passed since the last call to this method.
+   */
+  getDelta(): number;
+}

src/core/DirectGeometry.d.ts

@@ -0,0 +1,50 @@
+import { Vector3 } from './../math/Vector3';
+import { Color } from './../math/Color';
+import { Vector2 } from './../math/Vector2';
+import { Vector4 } from './../math/Vector4';
+import { Box3 } from './../math/Box3';
+import { Sphere } from './../math/Sphere';
+import { Geometry } from './Geometry';
+import { Event } from './Face3';
+import { EventDispatcher } from './EventDispatcher';
+import { MorphTarget } from './Geometry.js';
+/**
+ * @see <a href="https://github.com/mrdoob/three.js/blob/master/src/core/DirectGeometry.js">src/core/DirectGeometry.js</a>
+ */
+export class DirectGeometry extends EventDispatcher {
+  constructor();
+
+  id: number;
+  uuid: string;
+  name: string;
+  type: string;
+  indices: number[];
+  vertices: Vector3[];
+  normals: Vector3[];
+  colors: Color[];
+  uvs: Vector2[];
+  uvs2: Vector2[];
+  groups: { start: number; materialIndex: number }[];
+  morphTargets: MorphTarget[];
+  skinWeights: Vector4[];
+  skinIndices: Vector4[];
+  boundingBox: Box3;
+  boundingSphere: Sphere;
+  verticesNeedUpdate: boolean;
+  normalsNeedUpdate: boolean;
+  colorsNeedUpdate: boolean;
+  uvsNeedUpdate: boolean;
+  groupsNeedUpdate: boolean;
+
+  computeBoundingBox(): void;
+  computeBoundingSphere(): void;
+  computeGroups(geometry: Geometry): void;
+  fromGeometry(geometry: Geometry): DirectGeometry;
+  dispose(): void;
+
+  // EventDispatcher mixins
+  addEventListener(type: string, listener: (event: Event) => void): void;
+  hasEventListener(type: string, listener: (event: Event) => void): boolean;
+  removeEventListener(type: string, listener: (event: Event) => void): void;
+  dispatchEvent(event: { type: string; [attachment: string]: any }): void;
+}

src/core/EventDispatcher.d.ts

@@ -0,0 +1,60 @@
+import { Event } from './Face3';
+
+/**
+ * JavaScript events for custom objects
+ *
+ * # Example
+ *     var Car = function () {
+ *
+ *         EventDispatcher.call( this );
+ *         this.start = function () {
+ *
+ *             this.dispatchEvent( { type: 'start', message: 'vroom vroom!' } );
+ *
+ *         };
+ *
+ *     };
+ *
+ *     var car = new Car();
+ *     car.addEventListener( 'start', function ( event ) {
+ *
+ *         alert( event.message );
+ *
+ *     } );
+ *     car.start();
+ *
+ * @source src/core/EventDispatcher.js
+ */
+export class EventDispatcher {
+  /**
+   * Creates eventDispatcher object. It needs to be call with '.call' to add the functionality to an 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(type: string, listener: (event: Event) => void): 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(type: string, listener: (event: Event) => void): 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(type: string, listener: (event: Event) => void): void;
+
+  /**
+   * Fire an event type.
+   * @param type The type of event that gets fired.
+   */
+  dispatchEvent(event: { type: string; [attachment: string]: any }): void;
+}

src/core/Face3.d.ts

@@ -0,0 +1,104 @@
+import { Vector3 } from './../math/Vector3';
+import { Color } from './../math/Color';
+
+export interface Event {
+  type: string;
+  target?: any;
+  [attachment: string]: any;
+}
+
+/**
+ * Triangle face.
+ *
+ * # Example
+ *     var normal = new THREE.Vector3( 0, 1, 0 );
+ *     var color = new THREE.Color( 0xffaa00 );
+ *     var face = new THREE.Face3( 0, 1, 2, normal, color, 0 );
+ *
+ * @source https://github.com/mrdoob/three.js/blob/master/src/core/Face3.js
+ */
+export class Face3 {
+  /**
+   * @param a Vertex A index.
+   * @param b Vertex B index.
+   * @param c Vertex C index.
+   * @param normal Face normal or array of vertex normals.
+   * @param color Face color or array of vertex colors.
+   * @param materialIndex Material index.
+   */
+  constructor(
+    a: number,
+    b: number,
+    c: number,
+    normal?: Vector3,
+    color?: Color,
+    materialIndex?: number
+  );
+  constructor(
+    a: number,
+    b: number,
+    c: number,
+    normal?: Vector3,
+    vertexColors?: Color[],
+    materialIndex?: number
+  );
+  constructor(
+    a: number,
+    b: number,
+    c: number,
+    vertexNormals?: Vector3[],
+    color?: Color,
+    materialIndex?: number
+  );
+  constructor(
+    a: number,
+    b: number,
+    c: number,
+    vertexNormals?: Vector3[],
+    vertexColors?: Color[],
+    materialIndex?: number
+  );
+
+  /**
+   * Vertex A index.
+   */
+  a: number;
+
+  /**
+   * Vertex B index.
+   */
+  b: number;
+
+  /**
+   * Vertex C index.
+   */
+  c: number;
+
+  /**
+   * Face normal.
+   */
+  normal: Vector3;
+
+  /**
+   * Array of 4 vertex normals.
+   */
+  vertexNormals: Vector3[];
+
+  /**
+   * Face color.
+   */
+  color: Color;
+
+  /**
+   * Array of 4 vertex normals.
+   */
+  vertexColors: Color[];
+
+  /**
+   * Material index (points to {@link Geometry.materials}).
+   */
+  materialIndex: number;
+
+  clone(): this;
+  copy(source: Face3): this;
+}

src/core/Geometry.d.ts

@@ -0,0 +1,265 @@
+import { Vector3 } from './../math/Vector3';
+import { Color } from './../math/Color';
+import { Face3, Event } from './Face3';
+import { Vector2 } from './../math/Vector2';
+import { Vector4 } from './../math/Vector4';
+import { Box3 } from './../math/Box3';
+import { Sphere } from './../math/Sphere';
+import { Matrix4 } from './../math/Matrix4';
+import { BufferGeometry } from './BufferGeometry';
+import { Matrix } from './../math/Matrix3';
+import { Mesh } from './../objects/Mesh';
+import { Bone } from './../objects/Bone';
+import { AnimationClip } from './../animation/AnimationClip';
+import { EventDispatcher } from './EventDispatcher';
+
+/**
+ * @deprecated Use {@link Face3} instead.
+ */
+
+export interface MorphTarget {
+  name: string;
+  vertices: Vector3[];
+}
+
+export interface MorphColor {
+  name: string;
+  colors: Color[];
+}
+
+export interface MorphNormals {
+  name: string;
+  normals: Vector3[];
+}
+
+export let GeometryIdCount: number;
+
+/**
+ * Base class for geometries
+ *
+ * # Example
+ *     var geometry = new THREE.Geometry();
+ *     geometry.vertices.push( new THREE.Vector3( -10, 10, 0 ) );
+ *     geometry.vertices.push( new THREE.Vector3( -10, -10, 0 ) );
+ *     geometry.vertices.push( new THREE.Vector3( 10, -10, 0 ) );
+ *     geometry.faces.push( new THREE.Face3( 0, 1, 2 ) );
+ *     geometry.computeBoundingSphere();
+ *
+ * @see https://github.com/mrdoob/three.js/blob/master/src/core/Geometry.js
+ */
+export class Geometry extends EventDispatcher {
+  constructor();
+
+  /**
+   * Unique number of this geometry instance
+   */
+  id: number;
+
+  uuid: string;
+
+  /**
+   * Name for this geometry. Default is an empty string.
+   */
+  name: string;
+
+  type: string;
+
+  /**
+   * The array of vertices hold every position of points of the model.
+   * To signal an update in this array, Geometry.verticesNeedUpdate needs to be set to true.
+   */
+  vertices: Vector3[];
+
+  /**
+   * Array of vertex colors, matching number and order of vertices.
+   * Used in ParticleSystem, Line and Ribbon.
+   * Meshes use per-face-use-of-vertex colors embedded directly in faces.
+   * To signal an update in this array, Geometry.colorsNeedUpdate needs to be set to true.
+   */
+  colors: Color[];
+
+  /**
+   * Array of triangles or/and quads.
+   * The array of faces describe how each vertex in the model is connected with each other.
+   * To signal an update in this array, Geometry.elementsNeedUpdate needs to be set to true.
+   */
+  faces: Face3[];
+
+  /**
+   * Array of face UV layers.
+   * Each UV layer is an array of UV matching order and number of vertices in faces.
+   * To signal an update in this array, Geometry.uvsNeedUpdate needs to be set to true.
+   */
+  faceVertexUvs: Vector2[][][];
+
+  /**
+   * Array of morph targets. Each morph target is a Javascript object:
+   *
+   *     { name: "targetName", vertices: [ new THREE.Vector3(), ... ] }
+   *
+   * Morph vertices match number and order of primary vertices.
+   */
+  morphTargets: MorphTarget[];
+
+  /**
+   * Array of morph normals. Morph normals have similar structure as morph targets, each normal set is a Javascript object:
+   *
+   *     morphNormal = { name: "NormalName", normals: [ new THREE.Vector3(), ... ] }
+   */
+  morphNormals: MorphNormals[];
+
+  /**
+   * Array of skinning weights, matching number and order of vertices.
+   */
+  skinWeights: Vector4[];
+
+  /**
+   * Array of skinning indices, matching number and order of vertices.
+   */
+  skinIndices: Vector4[];
+
+  /**
+   *
+   */
+  lineDistances: number[];
+
+  /**
+   * Bounding box.
+   */
+  boundingBox: Box3;
+
+  /**
+   * Bounding sphere.
+   */
+  boundingSphere: Sphere;
+
+  /**
+   * Set to true if the vertices array has been updated.
+   */
+  verticesNeedUpdate: boolean;
+
+  /**
+   * Set to true if the faces array has been updated.
+   */
+  elementsNeedUpdate: boolean;
+
+  /**
+   * Set to true if the uvs array has been updated.
+   */
+  uvsNeedUpdate: boolean;
+
+  /**
+   * Set to true if the normals array has been updated.
+   */
+  normalsNeedUpdate: boolean;
+
+  /**
+   * Set to true if the colors array has been updated.
+   */
+  colorsNeedUpdate: boolean;
+
+  /**
+   * Set to true if the linedistances array has been updated.
+   */
+  lineDistancesNeedUpdate: boolean;
+
+  /**
+   *
+   */
+  groupsNeedUpdate: boolean;
+
+  /**
+   * Bakes matrix transform directly into vertex coordinates.
+   */
+  applyMatrix(matrix: Matrix4): Geometry;
+
+  rotateX(angle: number): Geometry;
+  rotateY(angle: number): Geometry;
+  rotateZ(angle: number): Geometry;
+
+  translate(x: number, y: number, z: number): Geometry;
+  scale(x: number, y: number, z: number): Geometry;
+  lookAt(vector: Vector3): void;
+
+  fromBufferGeometry(geometry: BufferGeometry): Geometry;
+
+  center(): Geometry;
+
+  normalize(): Geometry;
+
+  /**
+   * Computes face normals.
+   */
+  computeFaceNormals(): void;
+
+  /**
+   * Computes vertex normals by averaging face normals.
+   * Face normals must be existing / computed beforehand.
+   */
+  computeVertexNormals(areaWeighted?: boolean): void;
+
+  /**
+   * Compute vertex normals, but duplicating face normals.
+   */
+  computeFlatVertexNormals(): void;
+
+  /**
+   * Computes morph normals.
+   */
+  computeMorphNormals(): void;
+
+  /**
+   * Computes bounding box of the geometry, updating {@link Geometry.boundingBox} attribute.
+   */
+  computeBoundingBox(): void;
+
+  /**
+   * Computes bounding sphere of the geometry, updating Geometry.boundingSphere attribute.
+   * Neither bounding boxes or bounding spheres are computed by default. They need to be explicitly computed, otherwise they are null.
+   */
+  computeBoundingSphere(): void;
+
+  merge(
+    geometry: Geometry,
+    matrix?: Matrix,
+    materialIndexOffset?: number
+  ): void;
+
+  mergeMesh(mesh: Mesh): void;
+
+  /**
+   * Checks for duplicate vertices using hashmap.
+   * Duplicated vertices are removed and faces' vertices are updated.
+   */
+  mergeVertices(): number;
+
+  setFromPoints(points: Array<Vector2> | Array<Vector3>): this;
+
+  sortFacesByMaterialIndex(): void;
+
+  toJSON(): any;
+
+  /**
+   * Creates a new clone of the Geometry.
+   */
+  clone(): this;
+
+  copy(source: Geometry): this;
+
+  /**
+   * Removes The object from memory.
+   * Don't forget to call this method when you remove an geometry because it can cuase meomory leaks.
+   */
+  dispose(): void;
+
+  // These properties do not exist in a normal Geometry class, but if you use the instance that was passed by JSONLoader, it will be added.
+  bones: Bone[];
+  animation: AnimationClip;
+  animations: AnimationClip[];
+
+  // EventDispatcher mixins
+  addEventListener(type: string, listener: (event: Event) => void): void;
+  hasEventListener(type: string, listener: (event: Event) => void): boolean;
+  removeEventListener(type: string, listener: (event: Event) => void): void;
+  dispatchEvent(event: { type: string; [attachment: string]: any }): void;
+}

src/core/InstancedBufferAttribute.d.ts

@@ -0,0 +1,46 @@
+import { BufferGeometry } from './BufferGeometry';
+import { BufferAttribute } from './BufferAttribute';
+
+/**
+ * @see <a href="https://github.com/mrdoob/three.js/blob/master/examples/js/BufferGeometryUtils.js">examples/js/BufferGeometryUtils.js</a>
+ */
+export namespace BufferGeometryUtils {
+  export function mergeBufferGeometries(
+    geometries: BufferGeometry[]
+  ): BufferGeometry;
+  export function computeTangents(geometry: BufferGeometry): null;
+  export function mergeBufferAttributes(
+    attributes: BufferAttribute[]
+  ): BufferAttribute;
+}
+
+/**
+ * @deprecated
+ */
+export namespace GeometryUtils {
+  /**
+   * @deprecated Use {@link Geometry#merge geometry.merge( geometry2, matrix, materialIndexOffset )} instead.
+   */
+  export function merge(
+    geometry1: any,
+    geometry2: any,
+    materialIndexOffset?: any
+  ): any;
+  /**
+   * @deprecated Use {@link Geometry#center geometry.center()} instead.
+   */
+  export function center(geometry: any): any;
+}
+
+/**
+ * @see <a href="https://github.com/mrdoob/three.js/blob/master/src/core/InstancedBufferAttribute.js">src/core/InstancedBufferAttribute.js</a>
+ */
+export class InstancedBufferAttribute extends BufferAttribute {
+  constructor(
+    data: ArrayLike<number>,
+    itemSize: number,
+    meshPerAttribute?: number
+  );
+
+  meshPerAttribute: number;
+}

src/core/InstancedBufferGeometry.d.ts

@@ -0,0 +1,13 @@
+import { BufferGeometry } from './BufferGeometry';
+
+/**
+ * @see <a href="https://github.com/mrdoob/three.js/blob/master/src/core/InstancedBufferGeometry.js">src/core/InstancedBufferGeometry.js</a>
+ */
+export class InstancedBufferGeometry extends BufferGeometry {
+  constructor();
+
+  groups: { start: number; count: number; instances: number }[];
+  maxInstancedCount: number;
+
+  addGroup(start: number, count: number, instances: number): void;
+}

src/core/InstancedInterleavedBuffer.d.ts

@@ -0,0 +1,14 @@
+import { InterleavedBuffer } from './InterleavedBuffer';
+
+/**
+ * @see <a href="https://github.com/mrdoob/three.js/blob/master/src/core/InstancedInterleavedBuffer.js">src/core/InstancedInterleavedBuffer.js</a>
+ */
+export class InstancedInterleavedBuffer extends InterleavedBuffer {
+  constructor(
+    array: ArrayLike<number>,
+    stride: number,
+    meshPerAttribute?: number
+  );
+
+  meshPerAttribute: number;
+}

src/core/InterleavedBuffer.d.ts

@@ -0,0 +1,28 @@
+import { InterleavedBufferAttribute } from './InterleavedBufferAttribute';
+
+/**
+ * @see <a href="https://github.com/mrdoob/three.js/blob/master/src/core/InterleavedBuffer.js">src/core/InterleavedBuffer.js</a>
+ */
+export class InterleavedBuffer {
+  constructor(array: ArrayLike<number>, stride: number);
+
+  array: ArrayLike<number>;
+  stride: number;
+  dynamic: boolean;
+  updateRange: { offset: number; count: number };
+  version: number;
+  length: number;
+  count: number;
+  needsUpdate: boolean;
+
+  setArray(array?: ArrayBufferView): void;
+  setDynamic(dynamic: boolean): InterleavedBuffer;
+  clone(): this;
+  copy(source: InterleavedBuffer): this;
+  copyAt(
+    index1: number,
+    attribute: InterleavedBufferAttribute,
+    index2: number
+  ): InterleavedBuffer;
+  set(value: ArrayLike<number>, index: number): InterleavedBuffer;
+}

src/core/InterleavedBufferAttribute.d.ts

@@ -0,0 +1,47 @@
+import { InterleavedBuffer } from './InterleavedBuffer';
+/**
+ * @see <a href="https://github.com/mrdoob/three.js/blob/master/src/core/InterleavedBufferAttribute.js">src/core/InterleavedBufferAttribute.js</a>
+ */
+export class InterleavedBufferAttribute {
+  constructor(
+    interleavedBuffer: InterleavedBuffer,
+    itemSize: number,
+    offset: number,
+    normalized?: boolean
+  );
+
+  uuid: string;
+  data: InterleavedBuffer;
+  itemSize: number;
+  offset: number;
+  count: number;
+  normalized: boolean;
+  array: any[];
+
+  getX(index: number): number;
+  setX(index: number, x: number): InterleavedBufferAttribute;
+  getY(index: number): number;
+  setY(index: number, y: number): InterleavedBufferAttribute;
+  getZ(index: number): number;
+  setZ(index: number, z: number): InterleavedBufferAttribute;
+  getW(index: number): number;
+  setW(index: number, z: number): InterleavedBufferAttribute;
+  setXY(index: number, x: number, y: number): InterleavedBufferAttribute;
+  setXYZ(
+    index: number,
+    x: number,
+    y: number,
+    z: number
+  ): InterleavedBufferAttribute;
+  setXYZW(
+    index: number,
+    x: number,
+    y: number,
+    z: number,
+    w: number
+  ): InterleavedBufferAttribute;
+  /**
+   * @deprecated Use {@link InterleavedBufferAttribute#count .count} instead.
+   */
+  length: number;
+}

src/core/Layers.d.ts

@@ -0,0 +1,11 @@
+export class Layers {
+  constructor();
+
+  mask: number;
+
+  set(channel: number): void;
+  enable(channel: number): void;
+  toggle(channel: number): void;
+  disable(channel: number): void;
+  test(layers: Layers): boolean;
+}

src/core/Object3D.d.ts

@@ -0,0 +1,326 @@
+import { Vector3 } from './../math/Vector3';
+import { Euler } from './../math/Euler';
+import { Quaternion } from './../math/Quaternion';
+import { Matrix4 } from './../math/Matrix4';
+import { Matrix3 } from './../math/Matrix3';
+import { Layers } from './Layers';
+import { WebGLRenderer } from './../renderers/WebGLRenderer';
+import { Scene } from './../scenes/Scene';
+import { Camera } from './../cameras/Camera';
+import { Geometry } from './Geometry';
+import { Material } from './../materials/Material';
+import { Group } from './../objects/Group';
+import { Raycaster } from './Raycaster';
+import { EventDispatcher } from './EventDispatcher';
+import { BufferGeometry } from './BufferGeometry';
+import { Intersection } from './Raycaster';
+
+export let Object3DIdCount: number;
+
+/**
+ * Base class for scene graph objects
+ */
+export class Object3D extends EventDispatcher {
+  constructor();
+
+  /**
+   * Unique number of this object instance.
+   */
+  id: number;
+
+  /**
+   *
+   */
+  uuid: string;
+
+  /**
+   * Optional name of the object (doesn't need to be unique).
+   */
+  name: string;
+
+  type: string;
+
+  /**
+   * Object's parent in the scene graph.
+   */
+  parent: Object3D | null;
+
+  /**
+   * Array with object's children.
+   */
+  children: Object3D[];
+
+  /**
+   * Up direction.
+   */
+  up: Vector3;
+
+  /**
+   * Object's local position.
+   */
+  position: Vector3;
+
+  /**
+   * Object's local rotation (Euler angles), in radians.
+   */
+  rotation: Euler;
+
+  /**
+   * Global rotation.
+   */
+  quaternion: Quaternion;
+
+  /**
+   * Object's local scale.
+   */
+  scale: Vector3;
+
+  modelViewMatrix: Matrix4;
+
+  normalMatrix: Matrix3;
+
+  /**
+   * Local transform.
+   */
+  matrix: Matrix4;
+
+  /**
+   * The global transform of the object. If the Object3d has no parent, then it's identical to the local transform.
+   */
+  matrixWorld: Matrix4;
+
+  /**
+   * When this is set, it calculates the matrix of position, (rotation or quaternion) and scale every frame and also recalculates the matrixWorld property.
+   */
+  matrixAutoUpdate: boolean;
+
+  /**
+   * When this is set, it calculates the matrixWorld in that frame and resets this property to false.
+   */
+  matrixWorldNeedsUpdate: boolean;
+
+  layers: Layers;
+  /**
+   * Object gets rendered if true.
+   */
+  visible: boolean;
+
+  /**
+   * Gets rendered into shadow map.
+   */
+  castShadow: boolean;
+
+  /**
+   * Material gets baked in shadow receiving.
+   */
+  receiveShadow: boolean;
+
+  /**
+   * When this is set, it checks every frame if the object is in the frustum of the camera. Otherwise the object gets drawn every frame even if it isn't visible.
+   */
+  frustumCulled: boolean;
+
+  renderOrder: number;
+
+  /**
+   * An object that can be used to store custom data about the Object3d. It should not hold references to functions as these will not be cloned.
+   */
+  userData: { [key: string]: any };
+
+  /**
+   * Used to check whether this or derived classes are Object3Ds. Default is true.
+   * You should not change this, as it is used internally for optimisation.
+   */
+  isObject3D: true;
+
+  /**
+   * Calls before rendering object
+   */
+  onBeforeRender: (
+    renderer: WebGLRenderer,
+    scene: Scene,
+    camera: Camera,
+    geometry: Geometry | BufferGeometry,
+    material: Material,
+    group: Group
+  ) => void;
+
+  /**
+   * Calls after rendering object
+   */
+  onAfterRender: (
+    renderer: WebGLRenderer,
+    scene: Scene,
+    camera: Camera,
+    geometry: Geometry | BufferGeometry,
+    material: Material,
+    group: Group
+  ) => void;
+
+  static DefaultUp: Vector3;
+  static DefaultMatrixAutoUpdate: boolean;
+
+  /**
+   * This updates the position, rotation and scale with the matrix.
+   */
+  applyMatrix(matrix: Matrix4): void;
+
+  applyQuaternion(quaternion: Quaternion): this;
+
+  /**
+   *
+   */
+  setRotationFromAxisAngle(axis: Vector3, angle: number): void;
+
+  /**
+   *
+   */
+  setRotationFromEuler(euler: Euler): void;
+
+  /**
+   *
+   */
+  setRotationFromMatrix(m: Matrix4): void;
+
+  /**
+   *
+   */
+  setRotationFromQuaternion(q: Quaternion): void;
+
+  /**
+   * Rotate an object along an axis in object space. The axis is assumed to be normalized.
+   * @param axis  A normalized vector in object space.
+   * @param angle  The angle in radians.
+   */
+  rotateOnAxis(axis: Vector3, angle: number): this;
+
+  /**
+   * Rotate an object along an axis in world space. The axis is assumed to be normalized. Method Assumes no rotated parent.
+   * @param axis  A normalized vector in object space.
+   * @param angle  The angle in radians.
+   */
+  rotateOnWorldAxis(axis: Vector3, angle: number): this;
+
+  /**
+   *
+   * @param angle
+   */
+  rotateX(angle: number): this;
+
+  /**
+   *
+   * @param angle
+   */
+  rotateY(angle: number): this;
+
+  /**
+   *
+   * @param angle
+   */
+  rotateZ(angle: number): this;
+
+  /**
+   * @param axis  A normalized vector in object space.
+   * @param distance  The distance to translate.
+   */
+  translateOnAxis(axis: Vector3, distance: number): this;
+
+  /**
+   * Translates object along x axis by distance.
+   * @param distance Distance.
+   */
+  translateX(distance: number): this;
+
+  /**
+   * Translates object along y axis by distance.
+   * @param distance Distance.
+   */
+  translateY(distance: number): this;
+
+  /**
+   * Translates object along z axis by distance.
+   * @param distance Distance.
+   */
+  translateZ(distance: number): this;
+
+  /**
+   * Updates the vector from local space to world space.
+   * @param vector A local vector.
+   */
+  localToWorld(vector: Vector3): Vector3;
+
+  /**
+   * Updates the vector from world space to local space.
+   * @param vector A world vector.
+   */
+  worldToLocal(vector: Vector3): Vector3;
+
+  /**
+   * Rotates object to face point in space.
+   * @param vector A world vector to look at.
+   */
+  lookAt(vector: Vector3 | number, y?: number, z?: number): void;
+
+  /**
+   * Adds object as child of this object.
+   */
+  add(...object: Object3D[]): this;
+
+  /**
+   * Removes object as child of this object.
+   */
+  remove(...object: Object3D[]): this;
+
+  /**
+   * Searches through the object's children and returns the first with a matching id.
+   * @param id  Unique number of the object instance
+   */
+  getObjectById(id: number): Object3D | undefined;
+
+  /**
+   * Searches through the object's children and returns the first with a matching name.
+   * @param name  String to match to the children's Object3d.name property.
+   */
+  getObjectByName(name: string): Object3D | undefined;
+
+  getObjectByProperty(name: string, value: string): Object3D | undefined;
+
+  getWorldPosition(target: Vector3): Vector3;
+  getWorldQuaternion(target: Quaternion): Quaternion;
+  getWorldScale(target: Vector3): Vector3;
+  getWorldDirection(target: Vector3): Vector3;
+
+  raycast(raycaster: Raycaster, intersects: Intersection[]): void;
+
+  traverse(callback: (object: Object3D) => any): void;
+
+  traverseVisible(callback: (object: Object3D) => any): void;
+
+  traverseAncestors(callback: (object: Object3D) => any): void;
+
+  /**
+   * Updates local transform.
+   */
+  updateMatrix(): void;
+
+  /**
+   * Updates global transform of the object and its children.
+   */
+  updateMatrixWorld(force: boolean): void;
+
+  toJSON(meta?: {
+    geometries: any;
+    materials: any;
+    textures: any;
+    images: any;
+  }): any;
+
+  clone(recursive?: boolean): this;
+
+  /**
+   *
+   * @param object
+   * @param recursive
+   */
+  copy(source: Object3D, recursive?: boolean): this;
+}

src/core/Raycaster.d.ts

@@ -0,0 +1,101 @@
+import { Vector3 } from './../math/Vector3';
+import { Face3 } from './Face3';
+import { Object3D } from './Object3D';
+import { Vector2 } from './../math/Vector2';
+import { Ray } from './../math/Ray';
+import { Camera } from './../cameras/Camera';
+
+export interface Intersection {
+  distance: number;
+  distanceToRay?: number;
+  point: Vector3;
+  index?: number;
+  face?: Face3 | null;
+  faceIndex?: number;
+  object: Object3D;
+  uv?: Vector2;
+}
+
+export interface RaycasterParameters {
+  Mesh?: any;
+  Line?: any;
+  LOD?: any;
+  Points?: { threshold: number };
+  Sprite?: any;
+}
+
+export class Raycaster {
+  /**
+   * This creates a new raycaster object.
+   * @param origin The origin vector where the ray casts from.
+   * @param direction The direction vector that gives direction to the ray. Should be normalized.
+   * @param near All results returned are further away than near. Near can't be negative. Default value is 0.
+   * @param far All results returned are closer then far. Far can't be lower then near . Default value is Infinity.
+   */
+  constructor(
+    origin?: Vector3,
+    direction?: Vector3,
+    near?: number,
+    far?: number
+  );
+
+  /** The Ray used for the raycasting. */
+  ray: Ray;
+
+  /**
+   * The near factor of the raycaster. This value indicates which objects can be discarded based on the
+   * distance. This value shouldn't be negative and should be smaller than the far property.
+   */
+  near: number;
+
+  /**
+   * The far factor of the raycaster. This value indicates which objects can be discarded based on the
+   * distance. This value shouldn't be negative and should be larger than the near property.
+   */
+  far: number;
+
+  params: RaycasterParameters;
+
+  /**
+   * The precision factor of the raycaster when intersecting Line objects.
+   */
+  linePrecision: number;
+
+  /**
+   * Updates the ray with a new origin and direction.
+   * @param origin The origin vector where the ray casts from.
+   * @param direction The normalized direction vector that gives direction to the ray.
+   */
+  set(origin: Vector3, direction: Vector3): void;
+
+  /**
+   * Updates the ray with a new origin and direction.
+   * @param coords 2D coordinates of the mouse, in normalized device coordinates (NDC)---X and Y components should be between -1 and 1.
+   * @param camera camera from which the ray should originate
+   */
+  setFromCamera(coords: { x: number; y: number }, camera: Camera): void;
+
+  /**
+   * Checks all intersection between the ray and the object with or without the descendants. Intersections are returned sorted by distance, closest first.
+   * @param object The object to check for intersection with the ray.
+   * @param recursive If true, it also checks all descendants. Otherwise it only checks intersecton with the object. Default is false.
+   * @param optionalTarget (optional) target to set the result. Otherwise a new Array is instantiated. If set, you must clear this array prior to each call (i.e., array.length = 0;).
+   */
+  intersectObject(
+    object: Object3D,
+    recursive?: boolean,
+    optionalTarget?: Intersection[]
+  ): Intersection[];
+
+  /**
+   * Checks all intersection between the ray and the objects with or without the descendants. Intersections are returned sorted by distance, closest first. Intersections are of the same form as those returned by .intersectObject.
+   * @param objects The objects to check for intersection with the ray.
+   * @param recursive If true, it also checks all descendants of the objects. Otherwise it only checks intersecton with the objects. Default is false.
+   * @param optionalTarget (optional) target to set the result. Otherwise a new Array is instantiated. If set, you must clear this array prior to each call (i.e., array.length = 0;).
+   */
+  intersectObjects(
+    objects: Object3D[],
+    recursive?: boolean,
+    optionalTarget?: Intersection[]
+  ): Intersection[];
+}

src/core/Uniform.d.ts

@@ -0,0 +1,22 @@
+export class Uniform {
+  constructor(value: any);
+  /**
+   * @deprecated
+   */
+  constructor(type: string, value: any);
+  /**
+   * @deprecated
+   */
+  type: string;
+  value: any;
+  /**
+   * @deprecated Use {@link Object3D#onBeforeRender object.onBeforeRender()} instead.
+   */
+  dynamic: boolean;
+  onUpdateCallback: Function;
+
+  /**
+   * @deprecated Use {@link Object3D#onBeforeRender object.onBeforeRender()} instead.
+   */
+  onUpdate(callback: Function): Uniform;
+}

src/extras/ImageUtils.d.ts

@@ -0,0 +1,34 @@
+import { Mapping } from '../constants';
+import { Texture } from '../textures/Texture';
+
+// Extras /////////////////////////////////////////////////////////////////////
+
+/**
+ * @deprecated Use {@link TextureLoader} instead.
+ */
+export namespace ImageUtils {
+  /**
+   * @deprecated
+   */
+  export let crossOrigin: string;
+
+  /**
+   * @deprecated Use {@link TextureLoader THREE.TextureLoader()} instead.
+   */
+  export function loadTexture(
+    url: string,
+    mapping?: Mapping,
+    onLoad?: (texture: Texture) => void,
+    onError?: (message: string) => void
+  ): Texture;
+
+  /**
+   * @deprecated Use {@link CubeTextureLoader THREE.CubeTextureLoader()} instead.
+   */
+  export function loadTextureCube(
+    array: string[],
+    mapping?: Mapping,
+    onLoad?: (texture: Texture) => void,
+    onError?: (message: string) => void
+  ): Texture;
+}

src/extras/ShapeUtils.d.ts

@@ -0,0 +1,11 @@
+interface Vec2 {
+  x: number;
+  y: number;
+}
+
+export namespace ShapeUtils {
+  export function area(contour: Vec2[]): number;
+  export function triangulate(contour: Vec2[], indices: boolean): number[];
+  export function triangulateShape(contour: Vec2[], holes: Vec2[]): number[][];
+  export function isClockWise(pts: Vec2[]): boolean;
+}

src/extras/core/Curve.d.ts

@@ -0,0 +1,77 @@
+import { Vector } from './../../math/Vector2';
+
+// Extras / Core /////////////////////////////////////////////////////////////////////
+
+/**
+ * An extensible curve object which contains methods for interpolation
+ * class Curve<T extends Vector>
+ */
+export class Curve<T extends Vector> {
+  /**
+   * This value determines the amount of divisions when calculating the cumulative segment lengths of a curve via .getLengths.
+   * To ensure precision when using methods like .getSpacedPoints, it is recommended to increase .arcLengthDivisions if the curve is very large.
+   * Default is 200.
+   */
+  arcLengthDivisions: number;
+
+  /**
+   * Returns a vector for point t of the curve where t is between 0 and 1
+   * getPoint(t: number): T;
+   */
+  getPoint(t: number, optionalTarget?: T): T;
+
+  /**
+   * Returns a vector for point at relative position in curve according to arc length
+   * getPointAt(u: number): T;
+   */
+  getPointAt(u: number, optionalTarget?: T): T;
+
+  /**
+   * Get sequence of points using getPoint( t )
+   * getPoints(divisions?: number): T[];
+   */
+  getPoints(divisions?: number): T[];
+
+  /**
+   * Get sequence of equi-spaced points using getPointAt( u )
+   * getSpacedPoints(divisions?: number): T[];
+   */
+  getSpacedPoints(divisions?: number): T[];
+
+  /**
+   * Get total curve arc length
+   */
+  getLength(): number;
+
+  /**
+   * Get list of cumulative segment lengths
+   */
+  getLengths(divisions?: number): number[];
+
+  /**
+   * Update the cumlative segment distance cache
+   */
+  updateArcLengths(): void;
+
+  /**
+   * Given u ( 0 .. 1 ), get a t to find p. This gives you points which are equi distance
+   */
+  getUtoTmapping(u: number, distance: number): number;
+
+  /**
+   * Returns a unit vector tangent at t. If the subclassed curve do not implement its tangent derivation, 2 points a small delta apart will be used to find its gradient which seems to give a reasonable approximation
+   * getTangent(t: number): T;
+   */
+  getTangent(t: number): T;
+
+  /**
+   * Returns tangent at equidistance point u on the curve
+   * getTangentAt(u: number): T;
+   */
+  getTangentAt(u: number): T;
+
+  /**
+   * @deprecated since r84.
+   */
+  static create(constructorFunc: Function, getPointFunc: Function): Function;
+}

src/extras/core/CurvePath.d.ts

@@ -0,0 +1,33 @@
+import { Curve } from './Curve';
+import { Geometry } from './../../core/Geometry';
+import { Vector } from './../../math/Vector2';
+
+export class CurvePath<T extends Vector> extends Curve<T> {
+  constructor();
+
+  curves: Curve<T>[];
+  autoClose: boolean;
+
+  add(curve: Curve<T>): void;
+  checkConnection(): boolean;
+  closePath(): void;
+  getPoint(t: number): T;
+  getLength(): number;
+  updateArcLengths(): void;
+  getCurveLengths(): number[];
+  getSpacedPoints(divisions?: number): T[];
+  getPoints(divisions?: number): T[];
+
+  /**
+   * @deprecated Use {@link Geometry#setFromPoints new THREE.Geometry().setFromPoints( points )} instead.
+   */
+  createPointsGeometry(divisions: number): Geometry;
+  /**
+   * @deprecated Use {@link Geometry#setFromPoints new THREE.Geometry().setFromPoints( points )} instead.
+   */
+  createSpacedPointsGeometry(divisions: number): Geometry;
+  /**
+   * @deprecated Use {@link Geometry#setFromPoints new THREE.Geometry().setFromPoints( points )} instead.
+   */
+  createGeometry(points: T[]): Geometry;
+}

src/extras/core/Font.d.ts

@@ -0,0 +1,7 @@
+export class Font {
+  constructor(jsondata: any);
+
+  data: string;
+
+  generateShapes(text: string, size: number, divisions: number): any[];
+}

src/extras/core/Path.d.ts

@@ -0,0 +1,80 @@
+import { Vector2 } from './../../math/Vector2';
+import { CurvePath } from './CurvePath';
+
+export enum PathActions {
+  MOVE_TO,
+  LINE_TO,
+  QUADRATIC_CURVE_TO, // Bezier quadratic curve
+  BEZIER_CURVE_TO, // Bezier cubic curve
+  CSPLINE_THRU, // Catmull-rom spline
+  ARC, // Circle
+  ELLIPSE,
+}
+
+export interface PathAction {
+  action: PathActions;
+  args: any;
+}
+
+/**
+ * a 2d path representation, comprising of points, lines, and cubes, similar to the html5 2d canvas api. It extends CurvePath.
+ */
+export class Path extends CurvePath<Vector2> {
+  constructor(points?: Vector2[]);
+
+  currentPoint: Vector2;
+
+  /**
+   * @deprecated Use {@link Path#setFromPoints .setFromPoints()} instead.
+   */
+  fromPoints(vectors: Vector2[]): void;
+  setFromPoints(vectors: Vector2[]): void;
+  moveTo(x: number, y: number): void;
+  lineTo(x: number, y: number): void;
+  quadraticCurveTo(aCPx: number, aCPy: number, aX: number, aY: number): void;
+  bezierCurveTo(
+    aCP1x: number,
+    aCP1y: number,
+    aCP2x: number,
+    aCP2y: number,
+    aX: number,
+    aY: number
+  ): void;
+  splineThru(pts: Vector2[]): void;
+  arc(
+    aX: number,
+    aY: number,
+    aRadius: number,
+    aStartAngle: number,
+    aEndAngle: number,
+    aClockwise: boolean
+  ): void;
+  absarc(
+    aX: number,
+    aY: number,
+    aRadius: number,
+    aStartAngle: number,
+    aEndAngle: number,
+    aClockwise: boolean
+  ): void;
+  ellipse(
+    aX: number,
+    aY: number,
+    xRadius: number,
+    yRadius: number,
+    aStartAngle: number,
+    aEndAngle: number,
+    aClockwise: boolean,
+    aRotation: number
+  ): void;
+  absellipse(
+    aX: number,
+    aY: number,
+    xRadius: number,
+    yRadius: number,
+    aStartAngle: number,
+    aEndAngle: number,
+    aClockwise: boolean,
+    aRotation: number
+  ): void;
+}

src/extras/core/Shape.d.ts

@@ -0,0 +1,35 @@
+import { Vector2 } from './../../math/Vector2';
+import { Path } from './Path';
+import { ExtrudeGeometry } from './../../geometries/ExtrudeGeometry';
+import { ShapeGeometry } from './../../geometries/ShapeGeometry';
+
+/**
+ * Defines a 2d shape plane using paths.
+ */
+export class Shape extends Path {
+  constructor(points?: Vector2[]);
+
+  holes: Path[];
+
+  /**
+   * @deprecated Use {@link ExtrudeGeometry ExtrudeGeometry()} instead.
+   */
+  extrude(options?: any): ExtrudeGeometry;
+
+  /**
+   * @deprecated Use {@link ShapeGeometry ShapeGeometry()} instead.
+   */
+  makeGeometry(options?: any): ShapeGeometry;
+  getPointsHoles(divisions: number): Vector2[][];
+
+  /**
+   * @deprecated Use {@link Shape#extractPoints .extractPoints()} instead.
+   */
+  extractAllPoints(
+    divisions: number
+  ): {
+    shape: Vector2[];
+    holes: Vector2[][];
+  };
+  extractPoints(divisions: number): Vector2[];
+}

src/extras/core/ShapePath.d.ts

@@ -0,0 +1,23 @@
+import { Vector2 } from './../../math/Vector2';
+import { Shape } from './Shape';
+
+export class ShapePath {
+  constructor();
+
+  subPaths: any[];
+  currentPath: any;
+
+  moveTo(x: number, y: number): void;
+  lineTo(x: number, y: number): void;
+  quadraticCurveTo(aCPx: number, aCPy: number, aX: number, aY: number): void;
+  bezierCurveTo(
+    aCP1x: number,
+    aCP1y: number,
+    aCP2x: number,
+    aCP2y: number,
+    aX: number,
+    aY: number
+  ): void;
+  splineThru(pts: Vector2[]): void;
+  toShapes(isCCW: boolean, noHoles: any): Shape[];
+}

src/extras/curves/ArcCurve.d.ts

@@ -0,0 +1,11 @@
+import { EllipseCurve } from './EllipseCurve';
+export class ArcCurve extends EllipseCurve {
+  constructor(
+    aX: number,
+    aY: number,
+    aRadius: number,
+    aStartAngle: number,
+    aEndAngle: number,
+    aClockwise: boolean
+  );
+}

src/extras/curves/CatmullRomCurve3.d.ts

@@ -0,0 +1,46 @@
+import { Vector3 } from './../../math/Vector3';
+import { Curve } from './../core/Curve';
+
+// Extras / Curves /////////////////////////////////////////////////////////////////////
+export namespace CurveUtils {
+  export function tangentQuadraticBezier(
+    t: number,
+    p0: number,
+    p1: number,
+    p2: number
+  ): number;
+  export function tangentCubicBezier(
+    t: number,
+    p0: number,
+    p1: number,
+    p2: number,
+    p3: number
+  ): number;
+  export function tangentSpline(
+    t: number,
+    p0: number,
+    p1: number,
+    p2: number,
+    p3: number
+  ): number;
+  export function interpolate(
+    p0: number,
+    p1: number,
+    p2: number,
+    p3: number,
+    t: number
+  ): number;
+}
+
+export class CatmullRomCurve3 extends Curve<Vector3> {
+  constructor(
+    points?: Vector3[],
+    closed?: boolean,
+    curveType?: string,
+    tension?: number
+  );
+
+  points: Vector3[];
+
+  getPoint(t: number): Vector3;
+}

src/extras/curves/CubicBezierCurve.d.ts

@@ -0,0 +1,11 @@
+import { Vector2 } from './../../math/Vector2';
+import { Curve } from './../core/Curve';
+
+export class CubicBezierCurve extends Curve<Vector2> {
+  constructor(v0: Vector2, v1: Vector2, v2: Vector2, v3: Vector2);
+
+  v0: Vector2;
+  v1: Vector2;
+  v2: Vector2;
+  v3: Vector2;
+}

src/extras/curves/CubicBezierCurve3.d.ts

@@ -0,0 +1,13 @@
+import { Vector3 } from './../../math/Vector3';
+import { Curve } from './../core/Curve';
+
+export class CubicBezierCurve3 extends Curve<Vector3> {
+  constructor(v0: Vector3, v1: Vector3, v2: Vector3, v3: Vector3);
+
+  v0: Vector3;
+  v1: Vector3;
+  v2: Vector3;
+  v3: Vector3;
+
+  getPoint(t: number): Vector3;
+}

src/extras/curves/Curves.d.ts

@@ -0,0 +1,10 @@
+export { ArcCurve } from './ArcCurve.js';
+export { CatmullRomCurve3 } from './CatmullRomCurve3.js';
+export { CubicBezierCurve } from './CubicBezierCurve.js';
+export { CubicBezierCurve3 } from './CubicBezierCurve3.js';
+export { EllipseCurve } from './EllipseCurve.js';
+export { LineCurve } from './LineCurve.js';
+export { LineCurve3 } from './LineCurve3.js';
+export { QuadraticBezierCurve } from './QuadraticBezierCurve.js';
+export { QuadraticBezierCurve3 } from './QuadraticBezierCurve3.js';
+export { SplineCurve } from './SplineCurve.js';

src/extras/curves/EllipseCurve.d.ts

@@ -0,0 +1,24 @@
+import { Curve } from './../core/Curve';
+import { Vector2 } from '../../math/Vector2';
+
+export class EllipseCurve extends Curve<Vector2> {
+  constructor(
+    aX: number,
+    aY: number,
+    xRadius: number,
+    yRadius: number,
+    aStartAngle: number,
+    aEndAngle: number,
+    aClockwise: boolean,
+    aRotation: number
+  );
+
+  aX: number;
+  aY: number;
+  xRadius: number;
+  yRadius: number;
+  aStartAngle: number;
+  aEndAngle: number;
+  aClockwise: boolean;
+  aRotation: number;
+}

src/extras/curves/LineCurve.d.ts

@@ -0,0 +1,9 @@
+import { Vector2 } from './../../math/Vector2';
+import { Curve } from './../core/Curve';
+
+export class LineCurve extends Curve<Vector2> {
+  constructor(v1: Vector2, v2: Vector2);
+
+  v1: Vector2;
+  v2: Vector2;
+}

src/extras/curves/LineCurve3.d.ts

@@ -0,0 +1,11 @@
+import { Vector3 } from './../../math/Vector3';
+import { Curve } from './../core/Curve';
+
+export class LineCurve3 extends Curve<Vector3> {
+  constructor(v1: Vector3, v2: Vector3);
+
+  v1: Vector3;
+  v2: Vector3;
+
+  getPoint(t: number): Vector3;
+}

src/extras/curves/QuadraticBezierCurve.d.ts

@@ -0,0 +1,10 @@
+import { Vector2 } from './../../math/Vector2';
+import { Curve } from './../core/Curve';
+
+export class QuadraticBezierCurve extends Curve<Vector2> {
+  constructor(v0: Vector2, v1: Vector2, v2: Vector2);
+
+  v0: Vector2;
+  v1: Vector2;
+  v2: Vector2;
+}

src/extras/curves/QuadraticBezierCurve3.d.ts

@@ -0,0 +1,12 @@
+import { Vector3 } from './../../math/Vector3';
+import { Curve } from './../core/Curve';
+
+export class QuadraticBezierCurve3 extends Curve<Vector3> {
+  constructor(v0: Vector3, v1: Vector3, v2: Vector3);
+
+  v0: Vector3;
+  v1: Vector3;
+  v2: Vector3;
+
+  getPoint(t: number): Vector3;
+}

src/extras/curves/SplineCurve.d.ts

@@ -0,0 +1,8 @@
+import { Vector2 } from './../../math/Vector2';
+import { Curve } from './../core/Curve';
+
+export class SplineCurve extends Curve<Vector2> {
+  constructor(points?: Vector2[]);
+
+  points: Vector2[];
+}

src/extras/objects/ImmediateRenderObject.d.ts

@@ -0,0 +1,18 @@
+import { Object3D } from './../../core/Object3D';
+import { Material } from './../../materials/Material';
+
+/**
+ * @deprecated Use {@link WireframeGeometry THREE.WireframeGeometry} instead.
+ */
+// export class WireframeHelper extends LineSegments {
+//   constructor(object: Object3D, hex?: number);
+// }
+
+// Extras / Objects /////////////////////////////////////////////////////////////////////
+
+export class ImmediateRenderObject extends Object3D {
+  constructor(material: Material);
+
+  material: Material;
+  render(renderCallback: Function): void;
+}

src/geometries/BoxGeometry.d.ts

@@ -0,0 +1,56 @@
+import { Geometry } from '../core/Geometry.js';
+import { BufferGeometry } from '../core/BufferGeometry.js';
+import { Float32BufferAttribute } from '../core/BufferAttribute.js';
+import { Vector3 } from '../math/Vector3.js';
+
+// Extras / Geometries /////////////////////////////////////////////////////////////////////
+export class BoxBufferGeometry extends BufferGeometry {
+  constructor(
+    width?: number,
+    height?: number,
+    depth?: number,
+    widthSegments?: number,
+    heightSegments?: number,
+    depthSegments?: number
+  );
+
+  parameters: {
+    width: number;
+    height: number;
+    depth: number;
+    widthSegments: number;
+    heightSegments: number;
+    depthSegments: number;
+  };
+}
+
+/**
+ * BoxGeometry is the quadrilateral primitive geometry class. It is typically used for creating a cube or irregular quadrilateral of the dimensions provided within the (optional) 'width', 'height', & 'depth' constructor arguments.
+ */
+export class BoxGeometry extends Geometry {
+  /**
+   * @param width — Width of the sides on the X axis.
+   * @param height — Height of the sides on the Y axis.
+   * @param depth — Depth of the sides on the Z axis.
+   * @param widthSegments — Number of segmented faces along the width of the sides.
+   * @param heightSegments — Number of segmented faces along the height of the sides.
+   * @param depthSegments — Number of segmented faces along the depth of the sides.
+   */
+  constructor(
+    width?: number,
+    height?: number,
+    depth?: number,
+    widthSegments?: number,
+    heightSegments?: number,
+    depthSegments?: number
+  );
+
+  parameters: {
+    width: number;
+    height: number;
+    depth: number;
+    widthSegments: number;
+    heightSegments: number;
+    depthSegments: number;
+  };
+}

src/geometries/CircleGeometry.d.ts

@@ -0,0 +1,37 @@
+import { Geometry } from './../core/Geometry';
+import { BufferGeometry } from '../core/BufferGeometry.js';
+
+/**
+ * @deprecated Use {@link BoxGeometry} instead.
+ */
+export class CircleBufferGeometry extends BufferGeometry {
+  constructor(
+    radius?: number,
+    segments?: number,
+    thetaStart?: number,
+    thetaLength?: number
+  );
+
+  parameters: {
+    radius: number;
+    segments: number;
+    thetaStart: number;
+    thetaLength: number;
+  };
+}
+
+export class CircleGeometry extends Geometry {
+  constructor(
+    radius?: number,
+    segments?: number,
+    thetaStart?: number,
+    thetaLength?: number
+  );
+
+  parameters: {
+    radius: number;
+    segments: number;
+    thetaStart: number;
+    thetaLength: number;
+  };
+}

src/geometries/ConeGeometry.d.ts

@@ -0,0 +1,27 @@
+import { CylinderGeometry } from './CylinderGeometry.js';
+import { CylinderBufferGeometry } from './CylinderGeometry.js';
+import { BufferGeometry } from '../core/BufferGeometry';
+
+export class ConeBufferGeometry extends BufferGeometry {
+  constructor(
+    radius?: number,
+    height?: number,
+    radialSegment?: number,
+    heightSegment?: number,
+    openEnded?: boolean,
+    thetaStart?: number,
+    thetaLength?: number
+  );
+}
+
+export class ConeGeometry extends CylinderGeometry {
+  constructor(
+    radius?: number,
+    height?: number,
+    radialSegment?: number,
+    heightSegment?: number,
+    openEnded?: boolean,
+    thetaStart?: number,
+    thetaLength?: number
+  );
+}

src/geometries/CylinderGeometry.d.ts

@@ -0,0 +1,58 @@
+import { Geometry } from './../core/Geometry';
+import { BufferGeometry } from '../core/BufferGeometry.js';
+
+export class CylinderBufferGeometry extends BufferGeometry {
+  constructor(
+    radiusTop?: number,
+    radiusBottom?: number,
+    height?: number,
+    radialSegments?: number,
+    heightSegments?: number,
+    openEnded?: boolean,
+    thetaStart?: number,
+    thetaLength?: number
+  );
+
+  parameters: {
+    radiusTop: number;
+    radiusBottom: number;
+    height: number;
+    radialSegments: number;
+    heightSegments: number;
+    openEnded: boolean;
+    thetaStart: number;
+    thetaLength: number;
+  };
+}
+
+export class CylinderGeometry extends Geometry {
+  /**
+   * @param radiusTop — Radius of the cylinder at the top.
+   * @param radiusBottom — Radius of the cylinder at the bottom.
+   * @param height — Height of the cylinder.
+   * @param radiusSegments — Number of segmented faces around the circumference of the cylinder.
+   * @param heightSegments — Number of rows of faces along the height of the cylinder.
+   * @param openEnded - A Boolean indicating whether or not to cap the ends of the cylinder.
+   */
+  constructor(
+    radiusTop?: number,
+    radiusBottom?: number,
+    height?: number,
+    radiusSegments?: number,
+    heightSegments?: number,
+    openEnded?: boolean,
+    thetaStart?: number,
+    thetaLength?: number
+  );
+
+  parameters: {
+    radiusTop: number;
+    radiusBottom: number;
+    height: number;
+    radialSegments: number;
+    heightSegments: number;
+    openEnded: boolean;
+    thetaStart: number;
+    thetaLength: number;
+  };
+}

src/geometries/DodecahedronGeometry.d.ts

@@ -0,0 +1,15 @@
+import { Geometry } from './../core/Geometry';
+import { PolyhedronBufferGeometry } from './PolyhedronGeometry.js';
+
+export class DodecahedronBufferGeometry extends PolyhedronBufferGeometry {
+  constructor(radius?: number, detail?: number);
+}
+
+export class DodecahedronGeometry extends Geometry {
+  constructor(radius?: number, detail?: number);
+
+  parameters: {
+    radius: number;
+    detail: number;
+  };
+}

src/geometries/EdgesGeometry.d.ts

@@ -0,0 +1,6 @@
+import { BufferGeometry } from '../core/BufferGeometry';
+import { Geometry } from '../core/Geometry';
+
+export class EdgesGeometry extends BufferGeometry {
+  constructor(geometry: BufferGeometry | Geometry, thresholdAngle?: number);
+}

src/geometries/ExtrudeGeometry.d.ts

@@ -0,0 +1,55 @@
+import { CurvePath } from './../extras/core/CurvePath';
+import { UVGenerator } from './ExtrudeGeometry';
+import { Vector2 } from './../math/Vector2';
+import { Vector3 } from './../math/Vector3';
+import { Shape } from './../extras/core/Shape';
+import { Geometry } from './../core/Geometry';
+import { BufferGeometry } from './../core/BufferGeometry';
+
+export interface ExtrudeGeometryOptions {
+  curveSegments?: number;
+  steps?: number;
+  depth?: number;
+  bevelEnabled?: boolean;
+  bevelThickness?: number;
+  bevelSize?: number;
+  bevelSegments?: number;
+  extrudePath?: CurvePath<Vector3>;
+  UVGenerator?: UVGenerator;
+}
+
+export interface UVGenerator {
+  generateTopUV(
+    geometry: ExtrudeBufferGeometry,
+    vertices: number[],
+    indexA: number,
+    indexB: number,
+    indexC: number
+  ): Vector2[];
+  generateSideWallUV(
+    geometry: ExtrudeBufferGeometry,
+    vertices: number[],
+    indexA: number,
+    indexB: number,
+    indexC: number,
+    indexD: number
+  ): Vector2[];
+}
+
+export class ExtrudeBufferGeometry extends BufferGeometry {
+  constructor(shapes: Shape | Shape[], options?: ExtrudeGeometryOptions);
+
+  static WorldUVGenerator: UVGenerator;
+
+  addShapeList(shapes: Shape[], options?: any): void;
+  addShape(shape: Shape, options?: any): void;
+}
+
+export class ExtrudeGeometry extends Geometry {
+  constructor(shapes: Shape | Shape[], options?: ExtrudeGeometryOptions);
+
+  static WorldUVGenerator: UVGenerator;
+
+  addShapeList(shapes: Shape[], options?: any): void;
+  addShape(shape: Shape, options?: any): void;
+}

src/geometries/Geometries.d.ts

@@ -0,0 +1,46 @@
+export { WireframeGeometry } from './WireframeGeometry.js';
+export {
+  ParametricGeometry,
+  ParametricBufferGeometry,
+} from './ParametricGeometry.js';
+export {
+  TetrahedronGeometry,
+  TetrahedronBufferGeometry,
+} from './TetrahedronGeometry.js';
+export {
+  OctahedronGeometry,
+  OctahedronBufferGeometry,
+} from './OctahedronGeometry.js';
+export {
+  IcosahedronGeometry,
+  IcosahedronBufferGeometry,
+} from './IcosahedronGeometry.js';
+export {
+  DodecahedronGeometry,
+  DodecahedronBufferGeometry,
+} from './DodecahedronGeometry.js';
+export {
+  PolyhedronGeometry,
+  PolyhedronBufferGeometry,
+} from './PolyhedronGeometry.js';
+export { TubeGeometry, TubeBufferGeometry } from './TubeGeometry.js';
+export {
+  TorusKnotGeometry,
+  TorusKnotBufferGeometry,
+} from './TorusKnotGeometry.js';
+export { TorusGeometry, TorusBufferGeometry } from './TorusGeometry.js';
+export { TextGeometry, TextBufferGeometry } from './TextGeometry.js';
+export { SphereGeometry, SphereBufferGeometry } from './SphereGeometry.js';
+export { RingGeometry, RingBufferGeometry } from './RingGeometry.js';
+export { PlaneGeometry, PlaneBufferGeometry } from './PlaneGeometry.js';
+export { LatheGeometry, LatheBufferGeometry } from './LatheGeometry.js';
+export { ShapeGeometry, ShapeBufferGeometry } from './ShapeGeometry.js';
+export { ExtrudeGeometry, ExtrudeBufferGeometry } from './ExtrudeGeometry.js';
+export { EdgesGeometry } from './EdgesGeometry.js';
+export { ConeGeometry, ConeBufferGeometry } from './ConeGeometry.js';
+export {
+  CylinderGeometry,
+  CylinderBufferGeometry,
+} from './CylinderGeometry.js';
+export { CircleGeometry, CircleBufferGeometry } from './CircleGeometry.js';
+export { BoxGeometry, BoxBufferGeometry } from './BoxGeometry.js';

src/geometries/IcosahedronGeometry.d.ts

@@ -0,0 +1,14 @@
+import { Shape } from './../extras/core/Shape';
+import { UVGenerator } from './ExtrudeGeometry';
+import {
+  PolyhedronGeometry,
+  PolyhedronBufferGeometry,
+} from './PolyhedronGeometry';
+
+export class IcosahedronBufferGeometry extends PolyhedronBufferGeometry {
+  constructor(radius?: number, detail?: number);
+}
+
+export class IcosahedronGeometry extends PolyhedronGeometry {
+  constructor(radius?: number, detail?: number);
+}

src/geometries/LatheGeometry.d.ts

@@ -0,0 +1,35 @@
+import { Vector2 } from './../math/Vector2';
+import { Geometry } from './../core/Geometry';
+import { BufferGeometry } from './../core/BufferGeometry';
+
+export class LatheBufferGeometry extends BufferGeometry {
+  constructor(
+    points: Vector2[],
+    segments?: number,
+    phiStart?: number,
+    phiLength?: number
+  );
+
+  parameters: {
+    points: Vector2[];
+    segments: number;
+    phiStart: number;
+    phiLength: number;
+  };
+}
+
+export class LatheGeometry extends Geometry {
+  constructor(
+    points: Vector2[],
+    segments?: number,
+    phiStart?: number,
+    phiLength?: number
+  );
+
+  parameters: {
+    points: Vector2[];
+    segments: number;
+    phiStart: number;
+    phiLength: number;
+  };
+}

src/geometries/OctahedronGeometry.d.ts

@@ -0,0 +1,12 @@
+import {
+  PolyhedronGeometry,
+  PolyhedronBufferGeometry,
+} from './PolyhedronGeometry';
+
+export class OctahedronBufferGeometry extends PolyhedronBufferGeometry {
+  constructor(radius?: number, detail?: number);
+}
+
+export class OctahedronGeometry extends PolyhedronGeometry {
+  constructor(radius?: number, detail?: number);
+}

src/geometries/ParametricGeometry.d.ts

@@ -0,0 +1,31 @@
+import { Vector3 } from './../math/Vector3';
+import { Geometry } from './../core/Geometry';
+import { BufferGeometry } from './../core/BufferGeometry';
+
+export class ParametricBufferGeometry extends BufferGeometry {
+  constructor(
+    func: (u: number, v: number, dest: Vector3) => void,
+    slices: number,
+    stacks: number
+  );
+
+  parameters: {
+    func: (u: number, v: number, dest: Vector3) => void;
+    slices: number;
+    stacks: number;
+  };
+}
+
+export class ParametricGeometry extends Geometry {
+  constructor(
+    func: (u: number, v: number, dest: Vector3) => void,
+    slices: number,
+    stacks: number
+  );
+
+  parameters: {
+    func: (u: number, v: number, dest: Vector3) => void;
+    slices: number;
+    stacks: number;
+  };
+}

src/geometries/PlaneGeometry.d.ts

@@ -0,0 +1,34 @@
+import { Geometry } from './../core/Geometry';
+import { BufferGeometry } from './../core/BufferGeometry';
+
+export class PlaneBufferGeometry extends BufferGeometry {
+  constructor(
+    width?: number,
+    height?: number,
+    widthSegments?: number,
+    heightSegments?: number
+  );
+
+  parameters: {
+    width: number;
+    height: number;
+    widthSegments: number;
+    heightSegments: number;
+  };
+}
+
+export class PlaneGeometry extends Geometry {
+  constructor(
+    width?: number,
+    height?: number,
+    widthSegments?: number,
+    heightSegments?: number
+  );
+
+  parameters: {
+    width: number;
+    height: number;
+    widthSegments: number;
+    heightSegments: number;
+  };
+}

src/geometries/PolyhedronGeometry.d.ts

@@ -0,0 +1,36 @@
+import { Sphere } from './../math/Sphere';
+import { Geometry } from './../core/Geometry';
+import { BufferGeometry } from './../core/BufferGeometry';
+
+export class PolyhedronBufferGeometry extends BufferGeometry {
+  constructor(
+    vertices: number[],
+    indices: number[],
+    radius?: number,
+    detail?: number
+  );
+
+  parameters: {
+    vertices: number[];
+    indices: number[];
+    radius: number;
+    detail: number;
+  };
+}
+
+export class PolyhedronGeometry extends Geometry {
+  constructor(
+    vertices: number[],
+    indices: number[],
+    radius?: number,
+    detail?: number
+  );
+
+  parameters: {
+    vertices: number[];
+    indices: number[];
+    radius: number;
+    detail: number;
+  };
+  boundingSphere: Sphere;
+}

src/geometries/RingGeometry.d.ts

@@ -0,0 +1,42 @@
+import { Geometry } from './../core/Geometry';
+import { BufferGeometry } from './../core/BufferGeometry';
+
+export class RingBufferGeometry extends BufferGeometry {
+  constructor(
+    innerRadius?: number,
+    outerRadius?: number,
+    thetaSegments?: number,
+    phiSegments?: number,
+    thetaStart?: number,
+    thetaLength?: number
+  );
+
+  parameters: {
+    innerRadius: number;
+    outerRadius: number;
+    thetaSegments: number;
+    phiSegments: number;
+    thetaStart: number;
+    thetaLength: number;
+  };
+}
+
+export class RingGeometry extends Geometry {
+  constructor(
+    innerRadius?: number,
+    outerRadius?: number,
+    thetaSegments?: number,
+    phiSegments?: number,
+    thetaStart?: number,
+    thetaLength?: number
+  );
+
+  parameters: {
+    innerRadius: number;
+    outerRadius: number;
+    thetaSegments: number;
+    phiSegments: number;
+    thetaStart: number;
+    thetaLength: number;
+  };
+}

src/geometries/ShapeGeometry.d.ts

@@ -0,0 +1,14 @@
+import { Shape } from './../extras/core/Shape';
+import { Geometry } from './../core/Geometry';
+import { BufferGeometry } from './../core/BufferGeometry';
+
+export class ShapeBufferGeometry extends BufferGeometry {
+  constructor(shapes: Shape | Shape[], curveSegments?: number);
+}
+
+export class ShapeGeometry extends Geometry {
+  constructor(shapes: Shape | Shape[], curveSegments?: number);
+
+  addShapeList(shapes: Shape[], options: any): ShapeGeometry;
+  addShape(shape: Shape, options?: any): void;
+}

src/geometries/SphereGeometry.d.ts

@@ -0,0 +1,61 @@
+import { Shape } from './../extras/core/Shape';
+import { Geometry } from './../core/Geometry';
+import { BufferGeometry } from './../core/BufferGeometry';
+
+export class SphereBufferGeometry extends BufferGeometry {
+  constructor(
+    radius?: number,
+    widthSegments?: number,
+    heightSegments?: number,
+    phiStart?: number,
+    phiLength?: number,
+    thetaStart?: number,
+    thetaLength?: number
+  );
+
+  parameters: {
+    radius: number;
+    widthSegments: number;
+    heightSegments: number;
+    phiStart: number;
+    phiLength: number;
+    thetaStart: number;
+    thetaLength: number;
+  };
+}
+
+/**
+ * A class for generating sphere geometries
+ */
+export class SphereGeometry extends Geometry {
+  /**
+   * The geometry is created by sweeping and calculating vertexes around the Y axis (horizontal sweep) and the Z axis (vertical sweep). Thus, incomplete spheres (akin to 'sphere slices') can be created through the use of different values of phiStart, phiLength, thetaStart and thetaLength, in order to define the points in which we start (or end) calculating those vertices.
+   *
+   * @param radius — sphere radius. Default is 50.
+   * @param widthSegments — number of horizontal segments. Minimum value is 3, and the default is 8.
+   * @param heightSegments — number of vertical segments. Minimum value is 2, and the default is 6.
+   * @param phiStart — specify horizontal starting angle. Default is 0.
+   * @param phiLength — specify horizontal sweep angle size. Default is Math.PI * 2.
+   * @param thetaStart — specify vertical starting angle. Default is 0.
+   * @param thetaLength — specify vertical sweep angle size. Default is Math.PI.
+   */
+  constructor(
+    radius?: number,
+    widthSegments?: number,
+    heightSegments?: number,
+    phiStart?: number,
+    phiLength?: number,
+    thetaStart?: number,
+    thetaLength?: number
+  );
+
+  parameters: {
+    radius: number;
+    widthSegments: number;
+    heightSegments: number;
+    phiStart: number;
+    phiLength: number;
+    thetaStart: number;
+    thetaLength: number;
+  };
+}

src/geometries/TetrahedronGeometry.d.ts

@@ -0,0 +1,11 @@
+import { PolyhedronGeometry } from './PolyhedronGeometry';
+import { BufferGeometry } from './../core/BufferGeometry';
+import { PolyhedronBufferGeometry } from './PolyhedronGeometry';
+
+export class TetrahedronBufferGeometry extends PolyhedronBufferGeometry {
+  constructor(radius?: number, detail?: number);
+}
+
+export class TetrahedronGeometry extends PolyhedronGeometry {
+  constructor(radius?: number, detail?: number);
+}

src/geometries/TextGeometry.d.ts

@@ -0,0 +1,44 @@
+import { Font } from './../extras/core/Font';
+import { ExtrudeGeometry, ExtrudeBufferGeometry } from './ExtrudeGeometry';
+import { BufferGeometry } from './../core/BufferGeometry';
+
+export interface TextGeometryParameters {
+  font?: Font;
+  size?: number;
+  height?: number;
+  curveSegments?: number;
+  bevelEnabled?: boolean;
+  bevelThickness?: number;
+  bevelSize?: number;
+  bevelSegments?: number;
+}
+
+export class TextBufferGeometry extends ExtrudeBufferGeometry {
+  constructor(text: string, parameters?: TextGeometryParameters);
+
+  parameters: {
+    font: Font;
+    size: number;
+    height: number;
+    curveSegments: number;
+    bevelEnabled: boolean;
+    bevelThickness: number;
+    bevelSize: number;
+    bevelSegments: number;
+  };
+}
+
+export class TextGeometry extends ExtrudeGeometry {
+  constructor(text: string, parameters?: TextGeometryParameters);
+
+  parameters: {
+    font: Font;
+    size: number;
+    height: number;
+    curveSegments: number;
+    bevelEnabled: boolean;
+    bevelThickness: number;
+    bevelSize: number;
+    bevelSegments: number;
+  };
+}

src/geometries/TorusGeometry.d.ts

@@ -0,0 +1,40 @@
+import { TextGeometryParameters } from './TextGeometry';
+import { Font } from './../extras/core/Font';
+import { Geometry } from './../core/Geometry';
+import { BufferGeometry } from './../core/BufferGeometry';
+
+export class TorusBufferGeometry extends BufferGeometry {
+  constructor(
+    radius?: number,
+    tube?: number,
+    radialSegments?: number,
+    tubularSegments?: number,
+    arc?: number
+  );
+
+  parameters: {
+    radius: number;
+    tube: number;
+    radialSegments: number;
+    tubularSegments: number;
+    arc: number;
+  };
+}
+
+export class TorusGeometry extends Geometry {
+  constructor(
+    radius?: number,
+    tube?: number,
+    radialSegments?: number,
+    tubularSegments?: number,
+    arc?: number
+  );
+
+  parameters: {
+    radius: number;
+    tube: number;
+    radialSegments: number;
+    tubularSegments: number;
+    arc: number;
+  };
+}

src/geometries/TorusKnotGeometry.d.ts

@@ -0,0 +1,44 @@
+import { Geometry } from './../core/Geometry';
+import { BufferGeometry } from './../core/BufferGeometry';
+
+export class TorusKnotBufferGeometry extends BufferGeometry {
+  constructor(
+    radius?: number,
+    tube?: number,
+    tubularSegments?: number,
+    radialSegments?: number,
+    p?: number,
+    q?: number
+  );
+
+  parameters: {
+    radius: number;
+    tube: number;
+    tubularSegments: number;
+    radialSegments: number;
+    p: number;
+    q: number;
+    heightScale: number;
+  };
+}
+
+export class TorusKnotGeometry extends Geometry {
+  constructor(
+    radius?: number,
+    tube?: number,
+    tubularSegments?: number,
+    radialSegments?: number,
+    p?: number,
+    q?: number
+  );
+
+  parameters: {
+    radius: number;
+    tube: number;
+    tubularSegments: number;
+    radialSegments: number;
+    p: number;
+    q: number;
+    heightScale: number;
+  };
+}

src/geometries/TubeGeometry.d.ts

@@ -0,0 +1,46 @@
+import { Curve } from './../extras/core/Curve';
+import { Vector3 } from './../math/Vector3';
+import { Geometry } from './../core/Geometry';
+import { BufferGeometry } from './../core/BufferGeometry';
+
+export class TubeBufferGeometry extends BufferGeometry {
+  constructor(
+    path: Curve<Vector3>,
+    tubularSegments?: number,
+    radius?: number,
+    radiusSegments?: number,
+    closed?: boolean
+  );
+
+  parameters: {
+    path: Curve<Vector3>;
+    tubularSegments: number;
+    radius: number;
+    radialSegments: number;
+    closed: boolean;
+  };
+  tangents: Vector3[];
+  normals: Vector3[];
+  binormals: Vector3[];
+}
+
+export class TubeGeometry extends Geometry {
+  constructor(
+    path: Curve<Vector3>,
+    tubularSegments?: number,
+    radius?: number,
+    radiusSegments?: number,
+    closed?: boolean
+  );
+
+  parameters: {
+    path: Curve<Vector3>;
+    tubularSegments: number;
+    radius: number;
+    radialSegments: number;
+    closed: boolean;
+  };
+  tangents: Vector3[];
+  normals: Vector3[];
+  binormals: Vector3[];
+}

src/geometries/WireframeGeometry.d.ts

@@ -0,0 +1,8 @@
+import { Curve } from './../extras/core/Curve';
+import { Vector3 } from './../math/Vector3';
+import { Geometry } from './../core/Geometry';
+import { BufferGeometry } from './../core/BufferGeometry';
+
+export class WireframeGeometry extends BufferGeometry {
+  constructor(geometry: Geometry | BufferGeometry);
+}

src/helpers/ArrowHelper.d.ts

@@ -0,0 +1,25 @@
+import { Vector3 } from './../math/Vector3';
+import { Line } from './../objects/Line';
+import { Mesh } from './../objects/Mesh';
+import { Color } from './../math/Color';
+import { Object3D } from './../core/Object3D';
+
+// Extras / Helpers /////////////////////////////////////////////////////////////////////
+
+export class ArrowHelper extends Object3D {
+  constructor(
+    dir: Vector3,
+    origin?: Vector3,
+    length?: number,
+    hex?: number,
+    headLength?: number,
+    headWidth?: number
+  );
+
+  line: Line;
+  cone: Mesh;
+
+  setDirection(dir: Vector3): void;
+  setLength(length: number, headLength?: number, headWidth?: number): void;
+  setColor(color: Color): void;
+}

src/helpers/AxesHelper.d.ts

@@ -0,0 +1,5 @@
+import { LineSegments } from './../objects/LineSegments';
+
+export class AxesHelper extends LineSegments {
+  constructor(size?: number);
+}

src/helpers/BoxHelper.d.ts

@@ -0,0 +1,22 @@
+import { Object3D } from './../core/Object3D';
+import { Box3 } from './../math/Box3';
+import { Color } from './../math/Color';
+import { LineSegments } from './../objects/LineSegments';
+
+/**
+ * @deprecated Use {@link BoxHelper THREE.BoxHelper} instead.
+ */
+// export class BoundingBoxHelper extends Mesh {
+//   constructor(object?: Object3D, hex?: number);
+
+//   object: Object3D;
+//   box: Box3;
+
+//   update(): void;
+// }
+
+export class BoxHelper extends LineSegments {
+  constructor(object?: Object3D, color?: Color);
+
+  update(object?: Object3D): void;
+}

src/helpers/CameraHelper.d.ts

@@ -0,0 +1,11 @@
+import { Camera } from './../cameras/Camera';
+import { LineSegments } from './../objects/LineSegments';
+
+export class CameraHelper extends LineSegments {
+  constructor(camera: Camera);
+
+  camera: Camera;
+  pointMap: { [id: string]: number[] };
+
+  update(): void;
+}

src/helpers/DirectionalLightHelper.d.ts

@@ -0,0 +1,23 @@
+import { DirectionalLight } from './../lights/DirectionalLight';
+import { Color } from './../math/Color';
+import { Line } from './../objects/Line';
+import { Matrix4 } from './../math/Matrix4';
+import { Object3D } from './../core/Object3D';
+
+export class DirectionalLightHelper extends Object3D {
+  constructor(
+    light: DirectionalLight,
+    size?: number,
+    color?: Color | string | number
+  );
+
+  light: DirectionalLight;
+  lightPlane: Line;
+  targetPlane: Line;
+  color: Color | string | number | undefined;
+  matrix: Matrix4;
+  matrixAutoUpdate: boolean;
+
+  dispose(): void;
+  update(): void;
+}

src/helpers/FaceNormalsHelper.d.ts

@@ -0,0 +1,23 @@
+import { Object3D } from './../core/Object3D';
+import { LineSegments } from './../objects/LineSegments';
+
+/**
+ * @deprecated Use {@link EdgesGeometry THREE.EdgesGeometry}
+ */
+// export class EdgesHelper extends LineSegments {
+//   constructor(object: Object3D, hex?: number, thresholdAngle?: number);
+// }
+
+export class FaceNormalsHelper extends LineSegments {
+  constructor(
+    object: Object3D,
+    size?: number,
+    hex?: number,
+    linewidth?: number
+  );
+
+  object: Object3D;
+  size: number;
+
+  update(object?: Object3D): void;
+}

src/helpers/GridHelper.d.ts

@@ -0,0 +1,15 @@
+import { Color } from './../math/Color';
+import { LineSegments } from './../objects/LineSegments';
+
+export class GridHelper extends LineSegments {
+  constructor(
+    size: number,
+    divisions: number,
+    color1?: Color | number,
+    color2?: Color | number
+  );
+  /**
+   * @deprecated Colors should be specified in the constructor.
+   */
+  setColors(color1?: Color | number, color2?: Color | number): void;
+}

src/helpers/HemisphereLightHelper.d.ts

@@ -0,0 +1,23 @@
+import { HemisphereLight } from './../lights/HemisphereLight';
+import { Color } from './../math/Color';
+import { Matrix4 } from './../math/Matrix4';
+import { MeshBasicMaterial } from './../materials/MeshBasicMaterial';
+import { Object3D } from './../core/Object3D';
+
+export class HemisphereLightHelper extends Object3D {
+  constructor(
+    light: HemisphereLight,
+    size: number,
+    color?: Color | number | string
+  );
+
+  light: HemisphereLight;
+  matrix: Matrix4;
+  matrixAutoUpdate: boolean;
+  material: MeshBasicMaterial;
+
+  color: Color | string | number | undefined;
+
+  dispose(): void;
+  update(): void;
+}

src/helpers/PlaneHelper.d.ts

@@ -0,0 +1,11 @@
+import { Plane } from './../math/Plane';
+import { LineSegments } from './../objects/LineSegments';
+
+export class PlaneHelper extends LineSegments {
+  constructor(plane: Plane, size?: number, hex?: number);
+
+  plane: Plane;
+  size: number;
+
+  updateMatrixWorld(force: boolean): void;
+}

src/helpers/PointLightHelper.d.ts

@@ -0,0 +1,20 @@
+import { PointLight } from './../lights/PointLight';
+import { Color } from './../math/Color';
+import { Matrix4 } from './../math/Matrix4';
+import { Object3D } from './../core/Object3D';
+
+export class PointLightHelper extends Object3D {
+  constructor(
+    light: PointLight,
+    sphereSize?: number,
+    color?: Color | string | number
+  );
+
+  light: PointLight;
+  color: Color | string | number | undefined;
+  matrix: Matrix4;
+  matrixAutoUpdate: boolean;
+
+  dispose(): void;
+  update(): void;
+}

src/helpers/SkeletonHelper.d.ts

@@ -0,0 +1,13 @@
+import { Object3D } from './../core/Object3D';
+import { Bone } from './../objects/Bone';
+import { LineSegments } from './../objects/LineSegments';
+
+export class SkeletonHelper extends LineSegments {
+  constructor(bone: Object3D);
+
+  bones: Bone[];
+  root: Object3D;
+
+  getBoneList(object: Object3D): Bone[];
+  update(): void;
+}

src/helpers/SpotLightHelper.d.ts

@@ -0,0 +1,16 @@
+import { Light } from './../lights/Light';
+import { Color } from './../math/Color';
+import { Matrix4 } from './../math/Matrix4';
+import { Object3D } from './../core/Object3D';
+
+export class SpotLightHelper extends Object3D {
+  constructor(light: Light, color?: Color | string | number);
+
+  light: Light;
+  matrix: Matrix4;
+  matrixAutoUpdate: boolean;
+  color: Color | string | number | undefined;
+
+  dispose(): void;
+  update(): void;
+}

src/helpers/VertexNormalsHelper.d.ts

@@ -0,0 +1,16 @@
+import { Object3D } from './../core/Object3D';
+import { LineSegments } from './../objects/LineSegments';
+
+export class VertexNormalsHelper extends LineSegments {
+  constructor(
+    object: Object3D,
+    size?: number,
+    hex?: number,
+    linewidth?: number
+  );
+
+  object: Object3D;
+  size: number;
+
+  update(object?: Object3D): void;
+}