Add @default values to TypeScript declaration files

src/animation/AnimationAction.d.ts

@@ -9,15 +9,55 @@ export class AnimationAction {
 	constructor( mixer: AnimationMixer, clip: AnimationClip, localRoot?: Object3D, blendMode?: AnimationBlendMode );
 
 	blendMode: AnimationBlendMode;
+
+	/**
+	 * @default THREE.LoopRepeat
+	 */
 	loop: AnimationActionLoopStyles;
+
+	/**
+	 * @default 0
+	 */
 	time: number;
+
+	/**
+	 * @default 1
+	 */
 	timeScale: number;
+
+	/**
+	 * @default 1
+	 */
 	weight: number;
+
+	/**
+	 * @default Infinity
+	 */
 	repetitions: number;
+
+	/**
+	 * @default false
+	 */
 	paused: boolean;
+
+	/**
+	 * @default true
+	 */
 	enabled: boolean;
+
+	/**
+	 * @default false
+	 */
 	clampWhenFinished: boolean;
+
+	/**
+	 * @default true
+	 */
 	zeroSlopeAtStart: boolean;
+
+	/**
+	 * @default true
+	 */
 	zeroSlopeAtEnd: boolean;
 
 	play(): AnimationAction;

src/animation/AnimationClip.d.ts

@@ -9,7 +9,15 @@ export class AnimationClip {
 
 	name: string;
 	tracks: KeyframeTrack[];
+
+	/**
+	 * @default THREE.NormalAnimationBlendMode
+	 */
 	blendMode: AnimationBlendMode;
+
+	/**
+	 * @default -1
+	 */
 	duration: number;
 	uuid: string;
 	results: any[];

src/animation/AnimationMixer.d.ts

@@ -9,7 +9,14 @@ export class AnimationMixer extends EventDispatcher {
 
 	constructor( root: Object3D | AnimationObjectGroup );
 
+	/**
+	 * @default 0
+	 */
 	time: number;
+
+	/**
+	 * @default 1.0
+	 */
 	timeScale: number;
 
 	clipAction( clip: AnimationClip, root?: Object3D | AnimationObjectGroup, blendMode?: AnimationBlendMode ): AnimationAction;

src/animation/AnimationUtils.d.ts

@@ -16,6 +16,14 @@ export namespace AnimationUtils {
 		values: any[],
 		valuePropertyName: string
 	): void;
+
+	/**
+	 * @param sourceClip
+	 * @param name
+	 * @param startFrame
+	 * @param endFrame
+	 * @param [fps=30]
+	 */
 	export function subclip(
 		sourceClip: AnimationClip,
 		name: string,
@@ -23,6 +31,13 @@ export namespace AnimationUtils {
 		endFrame: number,
 		fps?: number
 	): AnimationClip;
+
+	/**
+	 * @param targetClip
+	 * @param [referenceFrame=0]
+	 * @param [referenceClip=targetClip]
+	 * @param [fps=30]
+	 */
 	export function makeClipAdditive(
 		targetClip: AnimationClip,
 		referenceFrame?: number,

src/animation/KeyframeTrack.d.ts

@@ -5,6 +5,12 @@ import { InterpolationModes } from '../constants';
 
 export class KeyframeTrack {
 
+	/**
+	 * @param name
+	 * @param times
+	 * @param values
+	 * @param [interpolation=THREE.InterpolateLinear]
+	 */
 	constructor(
 		name: string,
 		times: any[],
@@ -20,6 +26,9 @@ export class KeyframeTrack {
 	TimeBufferType: Float32Array;
 	ValueBufferType: Float32Array;
 
+	/**
+	 * @default THREE.InterpolateLinear
+	 */
 	DefaultInterpolation: InterpolationModes;
 
 	InterpolantFactoryMethodDiscrete( result: any ): DiscreteInterpolant;

src/animation/tracks/BooleanKeyframeTrack.d.ts

@@ -4,4 +4,9 @@ export class BooleanKeyframeTrack extends KeyframeTrack {
 
 	constructor( name: string, times: any[], values: any[] );
 
+	/**
+	 * @default 'bool'
+	 */
+	ValueTypeName: string;
+
 }

src/animation/tracks/ColorKeyframeTrack.d.ts

@@ -10,4 +10,9 @@ export class ColorKeyframeTrack extends KeyframeTrack {
 		interpolation?: InterpolationModes
 	);
 
+	/**
+	 * @default 'color'
+	 */
+	ValueTypeName: string;
+
 }

src/animation/tracks/NumberKeyframeTrack.d.ts

@@ -10,4 +10,9 @@ export class NumberKeyframeTrack extends KeyframeTrack {
 		interpolation?: InterpolationModes
 	);
 
+	/**
+	 * @default 'number'
+	 */
+	ValueTypeName: string;
+
 }

src/animation/tracks/QuaternionKeyframeTrack.d.ts

@@ -10,4 +10,9 @@ export class QuaternionKeyframeTrack extends KeyframeTrack {
 		interpolation?: InterpolationModes
 	);
 
+	/**
+	 * @default 'quaternion'
+	 */
+	ValueTypeName: string;
+
 }

src/animation/tracks/StringKeyframeTrack.d.ts

@@ -10,4 +10,9 @@ export class StringKeyframeTrack extends KeyframeTrack {
 		interpolation?: InterpolationModes
 	);
 
+	/**
+	 * @default 'string'
+	 */
+	ValueTypeName: string;
+
 }

src/animation/tracks/VectorKeyframeTrack.d.ts

@@ -10,4 +10,9 @@ export class VectorKeyframeTrack extends KeyframeTrack {
 		interpolation?: InterpolationModes
 	);
 
+	/**
+	 * @default 'vector'
+	 */
+	ValueTypeName: string;
+
 }

src/audio/Audio.d.ts

@@ -12,19 +12,67 @@ export class Audio<NodeType extends AudioNode = GainNode> extends Object3D {
 	listener: AudioListener;
 	context: AudioContext;
 	gain: GainNode;
+
+	/**
+	 * @default false
+	 */
 	autoplay: boolean;
 	buffer: null | AudioBuffer;
+
+	/**
+	 * @default 0
+	 */
 	detune: number;
+
+	/**
+	 * @default false
+	 */
 	loop: boolean;
+
+	/**
+	 * @default 0
+	 */
 	loopStart: number;
+
+	/**
+	 * @default 0
+	 */
 	loopEnd: number;
+
+	/**
+	 * @default 0
+	 */
 	offset: number;
+
+	/**
+	 * @default undefined
+	 */
 	duration: number | undefined;
+
+	/**
+	 * @default 1
+	 */
 	playbackRate: number;
+
+	/**
+	 * @default false
+	 */
 	isPlaying: boolean;
+
+	/**
+	 * @default true
+	 */
 	hasPlaybackControl: boolean;
+
+	/**
+	 * @default 'empty'
+	 */
 	sourceType: string;
 	source: AudioBufferSourceNode;
+
+	/**
+	 * @default []
+	 */
 	filters: any[];
 
 	getOutput(): NodeType;

src/audio/AudioAnalyser.d.ts

@@ -2,7 +2,11 @@ import { Audio } from './Audio';
 
 export class AudioAnalyser {
 
-	constructor( audio: Audio<AudioNode>, fftSize: number );
+	/**
+	 * @param audio
+	 * @param [fftSize=2048]
+	 */
+	constructor( audio: Audio<AudioNode>, fftSize?: number );
 
 	analyser: AnalyserNode;
 	data: Uint8Array;

src/audio/AudioListener.d.ts

@@ -8,7 +8,15 @@ export class AudioListener extends Object3D {
 	type: 'AudioListener';
 	context: AudioContext;
 	gain: GainNode;
+
+	/**
+	 * @default null
+	 */
 	filter: null | any;
+
+	/**
+	 * @default 0
+	 */
 	timeDelta: number;
 
 	getInput(): GainNode;

src/cameras/ArrayCamera.d.ts

@@ -4,6 +4,9 @@ export class ArrayCamera extends PerspectiveCamera {
 
 	constructor( cameras?: PerspectiveCamera[] );
 
+	/**
+	 * @default []
+	 */
 	cameras: PerspectiveCamera[];
 	readonly isArrayCamera: true;
 

src/cameras/Camera.d.ts

@@ -16,16 +16,19 @@ export class Camera extends Object3D {
 
 	/**
 	 * This is the inverse of matrixWorld. MatrixWorld contains the Matrix which has the world transform of the Camera.
+	 * @default new THREE.Matrix4()
 	 */
 	matrixWorldInverse: Matrix4;
 
 	/**
 	 * This is the matrix which contains the projection.
+	 * @default new THREE.Matrix4()
 	 */
 	projectionMatrix: Matrix4;
 
 	/**
 	 * This is the inverse of projectionMatrix.
+	 * @default new THREE.Matrix4()
 	 */
 	projectionMatrixInverse: Matrix4;
 

src/cameras/OrthographicCamera.d.ts

@@ -16,8 +16,8 @@ export class OrthographicCamera extends Camera {
 	 * @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.
+	 * @param [near=0.1] Camera frustum near plane.
+	 * @param [far=2000] Camera frustum far plane.
 	 */
 	constructor(
 		left: number,
@@ -32,7 +32,14 @@ export class OrthographicCamera extends Camera {
 
 	readonly isOrthographicCamera: true;
 
+	/**
+	 * @default 1
+	 */
 	zoom: number;
+
+	/**
+	 * @default null
+	 */
 	view: null | {
 		enabled: boolean;
 		fullWidth: number;
@@ -45,31 +52,37 @@ export class OrthographicCamera extends Camera {
 
 	/**
 	 * Camera frustum left plane.
+	 * @default -1
 	 */
 	left: number;
 
 	/**
 	 * Camera frustum right plane.
+	 * @default 1
 	 */
 	right: number;
 
 	/**
 	 * Camera frustum top plane.
+	 * @default 1
 	 */
 	top: number;
 
 	/**
 	 * Camera frustum bottom plane.
+	 * @default -1
 	 */
 	bottom: number;
 
 	/**
 	 * Camera frustum near plane.
+	 * @default 0.1
 	 */
 	near: number;
 
 	/**
 	 * Camera frustum far plane.
+	 * @default 2000
 	 */
 	far: number;
 

src/cameras/PerspectiveCamera.d.ts

@@ -8,10 +8,10 @@ import { Camera } from './Camera';
 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.
+	 * @param [fov=50] Camera frustum vertical field of view. Default value is 50.
+	 * @param [aspect=1] Camera frustum aspect ratio. Default value is 1.
+	 * @param [near=0.1] Camera frustum near plane. Default value is 0.1.
+	 * @param [far=2000] Camera frustum far plane. Default value is 2000.
 	 */
 	constructor( fov?: number, aspect?: number, near?: number, far?: number );
 
@@ -19,29 +19,43 @@ export class PerspectiveCamera extends Camera {
 
 	readonly isPerspectiveCamera: true;
 
+	/**
+	 * @default 1
+	 */
 	zoom: number;
 
 	/**
 	 * Camera frustum vertical field of view, from bottom to top of view, in degrees.
+	 * @default 50
 	 */
 	fov: number;
 
 	/**
 	 * Camera frustum aspect ratio, window width divided by window height.
+	 * @default 1
 	 */
 	aspect: number;
 
 	/**
 	 * Camera frustum near plane.
+	 * @default 0.1
 	 */
 	near: number;
 
 	/**
 	 * Camera frustum far plane.
+	 * @default 2000
 	 */
 	far: number;
 
+	/**
+	 * @default 10
+	 */
 	focus: number;
+
+	/**
+	 * @default null
+	 */
 	view: null | {
 		enabled: boolean;
 		fullWidth: number;
@@ -51,7 +65,15 @@ export class PerspectiveCamera extends Camera {
 		width: number;
 		height: number;
 	};
+
+	/**
+	 * @default 35
+	 */
 	filmGauge: number;
+
+	/**
+	 * @default 0
+	 */
 	filmOffset: number;
 
 	setFocalLength( focalLength: number ): void;

src/cameras/StereoCamera.d.ts

@@ -7,8 +7,16 @@ export class StereoCamera extends Camera {
 
 	type: 'StereoCamera';
 
+	/**
+	 * @default 1
+	 */
 	aspect: number;
+
+	/**
+	 * @default 0.064
+	 */
 	eyeSep: number;
+
 	cameraL: PerspectiveCamera;
 	cameraR: PerspectiveCamera;
 

src/core/BufferAttribute.d.ts

@@ -9,13 +9,36 @@ export class BufferAttribute {
 
 	constructor( array: ArrayLike<number>, itemSize: number, normalized?: boolean ); // array parameter should be TypedArray.
 
+	/**
+	 * @default ''
+	 */
 	name: string;
 	array: ArrayLike<number>;
 	itemSize: number;
+
+	/**
+	 * @default THREE.StaticDrawUsage
+	 */
 	usage: Usage;
+
+	/**
+	 * @default { offset: number; count: number }
+	 */
 	updateRange: { offset: number; count: number };
+
+	/**
+	 * @default 0
+	 */
 	version: number;
+
+	/**
+	 * @default false
+	 */
 	normalized: boolean;
+
+	/**
+	 * @default 0
+	 */
 	count: number;
 
 	set needsUpdate( value: boolean );

src/core/BufferGeometry.d.ts

@@ -31,20 +31,64 @@ export class BufferGeometry extends EventDispatcher {
 	 */
 	id: number;
 	uuid: string;
+
+	/**
+	 * @default ''
+	 */
 	name: string;
+
+	/**
+	 * @default 'BufferGeometry'
+	 */
 	type: string;
+
+	/**
+	 * @default null
+	 */
 	index: BufferAttribute | null;
+
+	/**
+	 * @default {}
+	 */
 	attributes: {
 		[name: string]: BufferAttribute | InterleavedBufferAttribute;
 	};
+
+	/**
+	 * @default {}
+	 */
 	morphAttributes: {
 		[name: string]: ( BufferAttribute | InterleavedBufferAttribute )[];
 	};
+
+	/**
+	 * @default false
+	 */
 	morphTargetsRelative: boolean;
+
+	/**
+	 * @default []
+	 */
 	groups: { start: number; count: number; materialIndex?: number }[];
+
+	/**
+	 * @default null
+	 */
 	boundingBox: Box3 | null;
+
+	/**
+	 * @default null
+	 */
 	boundingSphere: Sphere | null;
+
+	/**
+	 * @default { start: 0, count: Infinity }
+	 */
 	drawRange: { start: number; count: number };
+
+	/**
+	 * @default {}
+	 */
 	userData: {[key: string]: any};
 	readonly isBufferGeometry: true;
 

src/core/Clock.d.ts

@@ -6,35 +6,40 @@
 export class Clock {
 
 	/**
-	 * @param autoStart Automatically start the clock.
+	 * @param [autoStart=true] Automatically start the clock.
 	 */
 	constructor( autoStart?: boolean );
 
 	/**
 	 * If set, starts the clock automatically when the first update is called.
+	 * @default true
 	 */
 	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.
+	 * @default 0
 	 */
 	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.
+	 * @default 0
 	 */
 	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.
+	 * @default 0
 	 */
 	elapsedTime: number;
 
 	/**
 	 * This property keeps track whether the clock is running or not.
+	 * @default false
 	 */
 	running: boolean;
 

src/core/DirectGeometry.d.ts

@@ -18,22 +18,90 @@ export class DirectGeometry {
 	uuid: string;
 	name: string;
 	type: string;
+
+	/**
+	 * @default []
+	 */
 	indices: number[];
+
+	/**
+	 * @default []
+	 */
 	vertices: Vector3[];
+
+	/**
+	 * @default []
+	 */
 	normals: Vector3[];
+
+	/**
+	 * @default []
+	 */
 	colors: Color[];
+
+	/**
+	 * @default []
+	 */
 	uvs: Vector2[];
+
+	/**
+	 * @default []
+	 */
 	uvs2: Vector2[];
+
+	/**
+	 * @default []
+	 */
 	groups: { start: number; materialIndex: number }[];
+
+	/**
+	 * @default {}
+	 */
 	morphTargets: MorphTarget[];
+
+	/**
+	 * @default []
+	 */
 	skinWeights: Vector4[];
+
+	/**
+	 * @default []
+	 */
 	skinIndices: Vector4[];
+
+	/**
+	 * @default null
+	 */
 	boundingBox: Box3 | null;
+
+	/**
+	 * @default null
+	 */
 	boundingSphere: Sphere | null;
+
+	/**
+	 * @default false
+	 */
 	verticesNeedUpdate: boolean;
+
+	/**
+	 * @default false
+	 */
 	normalsNeedUpdate: boolean;
+
+	/**
+	 * @default false
+	 */
 	colorsNeedUpdate: boolean;
+
+	/**
+	 * @default false
+	 */
 	uvsNeedUpdate: boolean;
+
+	/**
+	 * @default false
+	 */
 	groupsNeedUpdate: boolean;
 
 	computeBoundingBox(): void;

src/core/Face3.d.ts

@@ -66,26 +66,31 @@ export class Face3 {
 
 	/**
 	 * Face normal.
+	 * @default new THREE.Vector3()
 	 */
 	normal: Vector3;
 
 	/**
 	 * Array of 3 vertex normals.
+	 * @default []
 	 */
 	vertexNormals: Vector3[];
 
 	/**
 	 * Face color.
+	 * @default new THREE.Color()
 	 */
 	color: Color;
 
 	/**
 	 * Array of 3 vertex colors.
+	 * @default []
 	 */
 	vertexColors: Color[];
 
 	/**
 	 * Material index (points to {@link Geometry.materials}).
+	 * @default 0
 	 */
 	materialIndex: number;
 

src/core/Geometry.d.ts

@@ -54,14 +54,19 @@ export class Geometry extends EventDispatcher {
 
 	/**
 	 * Name for this geometry. Default is an empty string.
+	 * @default ''
 	 */
 	name: string;
 
+	/**
+	 * @default 'Geometry'
+	 */
 	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.
+	 * @default []
 	 */
 	vertices: Vector3[];
 
@@ -70,6 +75,7 @@ export class Geometry extends EventDispatcher {
 	 * 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.
+	 * @default []
 	 */
 	colors: Color[];
 
@@ -77,6 +83,7 @@ export class Geometry extends EventDispatcher {
 	 * 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.
+	 * @default []
 	 */
 	faces: Face3[];
 
@@ -84,6 +91,7 @@ export class Geometry extends EventDispatcher {
 	 * 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.
+	 * @default [[]]
 	 */
 	faceVertexUvs: Vector2[][][];
 
@@ -93,6 +101,7 @@ export class Geometry extends EventDispatcher {
 	 *		 { name: "targetName", vertices: [ new THREE.Vector3(), ... ] }
 	 *
 	 * Morph vertices match number and order of primary vertices.
+	 * @default []
 	 */
 	morphTargets: MorphTarget[];
 
@@ -100,66 +109,78 @@ export class Geometry extends EventDispatcher {
 	 * 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(), ... ] }
+	 * @default []
 	 */
 	morphNormals: MorphNormals[];
 
 	/**
 	 * Array of skinning weights, matching number and order of vertices.
+	 * @default []
 	 */
 	skinWeights: Vector4[];
 
 	/**
 	 * Array of skinning indices, matching number and order of vertices.
+	 * @default []
 	 */
 	skinIndices: Vector4[];
 
 	/**
-	 *
+	 * @default []
 	 */
 	lineDistances: number[];
 
 	/**
 	 * Bounding box.
+	 * @default null
 	 */
 	boundingBox: Box3 | null;
 
 	/**
 	 * Bounding sphere.
+	 * @default null
 	 */
 	boundingSphere: Sphere | null;
 
 	/**
 	 * Set to true if the vertices array has been updated.
+	 * @default false
 	 */
 	verticesNeedUpdate: boolean;
 
 	/**
 	 * Set to true if the faces array has been updated.
+	 * @default false
 	 */
 	elementsNeedUpdate: boolean;
 
 	/**
 	 * Set to true if the uvs array has been updated.
+	 * @default false
 	 */
 	uvsNeedUpdate: boolean;
 
 	/**
 	 * Set to true if the normals array has been updated.
+	 * @default false
 	 */
 	normalsNeedUpdate: boolean;
 
 	/**
 	 * Set to true if the colors array has been updated.
+	 * @default false
 	 */
 	colorsNeedUpdate: boolean;
 
 	/**
 	 * Set to true if the linedistances array has been updated.
+	 * @default false
 	 */
 	lineDistancesNeedUpdate: boolean;
 
 	/**
 	 *
+	 * @default false
 	 */
 	groupsNeedUpdate: boolean;
 

src/core/InstancedBufferAttribute.d.ts

@@ -44,6 +44,9 @@ export class InstancedBufferAttribute extends BufferAttribute {
 		meshPerAttribute?: number
 	);
 
+	/**
+	 * @default 1
+	 */
 	meshPerAttribute: number;
 
 }

src/core/InstancedBufferGeometry.d.ts

@@ -7,7 +7,16 @@ export class InstancedBufferGeometry extends BufferGeometry {
 
 	constructor();
 
+	/**
+	 * @default 'InstancedBufferGeometry
+	 */
+	type: string;
+
 	groups: { start: number; count: number; instances: number }[];
+
+	/**
+	 * @default Infinity
+	 */
 	instanceCount: number;
 
 	addGroup( start: number, count: number, instances: number ): void;

src/core/InstancedInterleavedBuffer.d.ts

@@ -11,6 +11,9 @@ export class InstancedInterleavedBuffer extends InterleavedBuffer {
 		meshPerAttribute?: number
 	);
 
+	/**
+	 * @default 1
+	 */
 	meshPerAttribute: number;
 
 }

src/core/InterleavedBuffer.d.ts

@@ -10,10 +10,27 @@ export class InterleavedBuffer {
 
 	array: ArrayLike<number>;
 	stride: number;
+
+	/**
+	 * @default THREE.StaticDrawUsage
+	 */
 	usage: Usage;
+
+	/**
+	 * @default { offset: number; count: number }
+	 */
 	updateRange: { offset: number; count: number };
+
+	/**
+	 * @default 0
+	 */
 	version: number;
+
 	length: number;
+
+	/**
+	 * @default 0
+	 */
 	count: number;
 	needsUpdate: boolean;
 	uuid: string;

src/core/InterleavedBufferAttribute.d.ts

@@ -13,10 +13,17 @@ export class InterleavedBufferAttribute {
 		normalized?: boolean
 	);
 
+	/**
+	 * @default ''
+	 */
 	name: string;
 	data: InterleavedBuffer;
 	itemSize: number;
 	offset: number;
+
+	/**
+	 * @default false
+	 */
 	normalized: boolean;
 
 	get count(): number;

src/core/Layers.d.ts

@@ -2,6 +2,9 @@ export class Layers {
 
 	constructor();
 
+	/**
+	 * @default 1 | 0
+	 */
 	mask: number;
 
 	set( channel: number ): void;

src/core/Object3D.d.ts

@@ -36,98 +36,128 @@ export class Object3D extends EventDispatcher {
 
 	/**
 	 * Optional name of the object (doesn't need to be unique).
+	 * @default ''
 	 */
 	name: string;
 
+	/**
+	 * @default 'Object3D'
+	 */
 	type: string;
 
 	/**
 	 * Object's parent in the scene graph.
+	 * @default null
 	 */
 	parent: Object3D | null;
 
 	/**
 	 * Array with object's children.
+	 * @default []
 	 */
 	children: Object3D[];
 
 	/**
 	 * Up direction.
+	 * @default THREE.Object3D.DefaultUp.clone()
 	 */
 	up: Vector3;
 
 	/**
 	 * Object's local position.
+	 * @default new THREE.Vector3()
 	 */
 	readonly position: Vector3;
 
 	/**
 	 * Object's local rotation (Euler angles), in radians.
+	 * @default new THREE.Euler()
 	 */
 	readonly rotation: Euler;
 
 	/**
 	 * Global rotation.
+	 * @default new THREE.Quaternion()
 	 */
 	readonly quaternion: Quaternion;
 
 	/**
 	 * Object's local scale.
+	 * @default new THREE.Vector3()
 	 */
 	readonly scale: Vector3;
 
+	/**
+	 * @default new THREE.Matrix4()
+	 */
 	readonly modelViewMatrix: Matrix4;
 
+	/**
+	 * @default new THREE.Matrix3()
+	 */
 	readonly normalMatrix: Matrix3;
 
 	/**
 	 * Local transform.
+	 * @default new THREE.Matrix4()
 	 */
 	matrix: Matrix4;
 
 	/**
 	 * The global transform of the object. If the Object3d has no parent, then it's identical to the local transform.
+	 * @default new THREE.Matrix4()
 	 */
 	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.
+	 * @default THREE.Object3D.DefaultMatrixAutoUpdate
 	 */
 	matrixAutoUpdate: boolean;
 
 	/**
 	 * When this is set, it calculates the matrixWorld in that frame and resets this property to false.
+	 * @default false
 	 */
 	matrixWorldNeedsUpdate: boolean;
 
+	/**
+	 * @default new THREE.Layers()
+	 */
 	layers: Layers;
 	/**
 	 * Object gets rendered if true.
+	 * @default true
 	 */
 	visible: boolean;
 
 	/**
 	 * Gets rendered into shadow map.
+	 * @default false
 	 */
 	castShadow: boolean;
 
 	/**
 	 * Material gets baked in shadow receiving.
+	 * @default false
 	 */
 	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.
+	 * @default true
 	 */
 	frustumCulled: boolean;
 
 	/**
 	 * Overrides the default rendering order of scene graph objects, from lowest to highest renderOrder. Opaque and transparent objects remain sorted independently though. When this property is set for an instance of Group, all descendants objects will be sorted and rendered together.
+	 * @default 0
 	 */
 	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.
+	 * @default {}
 	 */
 	userData: { [key: string]: any };
 

src/core/Raycaster.d.ts

@@ -48,12 +48,14 @@ export class Raycaster {
 	/**
 	 * 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.
+	 * @default 0
 	 */
 	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.
+	 * @default Infinity
 	 */
 	far: number;
 
@@ -65,9 +67,13 @@ export class Raycaster {
 
 	/**
 	 * Used by Raycaster to selectively ignore 3D objects when performing intersection tests.
+	 * @default new THREE.Layers()
 	 */
 	layers: Layers;
 
+	/**
+	 * @default { Mesh: {}, Line: { threshold: 1 }, LOD: {}, Points: { threshold: 1 }, Sprite: {} }
+	 */
 	params: RaycasterParameters;
 
 	/**

src/extras/core/Curve.d.ts

@@ -8,10 +8,15 @@ import { Vector } from './../../math/Vector2';
  */
 export class Curve<T extends Vector> {
 
+	/**
+	 * @default 'Curve'
+	 */
+	type: string;
+
 	/**
 	 * 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.
+	 * @default 200
 	 */
 	arcLengthDivisions: number;
 

src/extras/core/CurvePath.d.ts

@@ -6,7 +6,19 @@ export class CurvePath<T extends Vector> extends Curve<T> {
 
 	constructor();
 
+	/**
+	 * @default 'CurvePath'
+	 */
+	type: string;
+
+	/**
+	 * @default []
+	 */
 	curves: Curve<T>[];
+
+	/**
+	 * @default false
+	 */
 	autoClose: boolean;
 
 	add( curve: Curve<T> ): void;

src/extras/core/Font.d.ts

@@ -4,6 +4,11 @@ export class Font {
 
 	constructor( jsondata: any );
 
+	/**
+	 * @default 'Font'
+	 */
+	type: string;
+
 	data: string;
 
 	generateShapes( text: string, size: number ): Shape[];

src/extras/core/Path.d.ts

@@ -8,6 +8,14 @@ export class Path extends CurvePath<Vector2> {
 
 	constructor( points?: Vector2[] );
 
+	/**
+	 * @default 'Path'
+	 */
+	type: string;
+
+	/**
+	 * @default new THREE.Vector2()
+	 */
 	currentPoint: Vector2;
 
 	/**

src/extras/core/Shape.d.ts

@@ -10,6 +10,14 @@ export class Shape extends Path {
 
 	constructor( points?: Vector2[] );
 
+	/**
+	 * @default 'Shape'
+	 */
+	type: string;
+
+	/**
+	 * @default []
+	 */
 	holes: Path[];
 
 	/**

src/extras/core/ShapePath.d.ts

@@ -1,11 +1,29 @@
 import { Vector2 } from './../../math/Vector2';
 import { Shape } from './Shape';
+import { Color } from '../../math/Color';
 
 export class ShapePath {
 
 	constructor();
 
+	/**
+	 * @default 'ShapePath'
+	 */
+	type: string;
+
+	/**
+	 * @default new THREE.Color()
+	 */
+	color: Color;
+
+	/**
+	 * @default []
+	 */
 	subPaths: any[];
+
+	/**
+	 * @default null
+	 */
 	currentPath: any;
 
 	moveTo( x: number, y: number ): this;

src/extras/curves/ArcCurve.d.ts

@@ -10,4 +10,9 @@ export class ArcCurve extends EllipseCurve {
 		aClockwise: boolean
 	);
 
+	/**
+	 * @default 'ArcCurve'
+	 */
+	type: string;
+
 }

src/extras/curves/CatmullRomCurve3.d.ts

@@ -34,6 +34,12 @@ export namespace CurveUtils {
 
 export class CatmullRomCurve3 extends Curve<Vector3> {
 
+	/**
+	 * @param [points=[]]
+	 * @param [closed=false]
+	 * @param [curveType='centripetal']
+	 * @param [tension=0.5]
+	 */
 	constructor(
 		points?: Vector3[],
 		closed?: boolean,
@@ -41,6 +47,14 @@ export class CatmullRomCurve3 extends Curve<Vector3> {
 		tension?: number
 	);
 
+	/**
+	 * @default 'CatmullRomCurve3'
+	 */
+	type: string;
+
+	/**
+	 * @default []
+	 */
 	points: Vector3[];
 
 }

src/extras/curves/CubicBezierCurve.d.ts

@@ -5,9 +5,29 @@ export class CubicBezierCurve extends Curve<Vector2> {
 
 	constructor( v0: Vector2, v1: Vector2, v2: Vector2, v3: Vector2 );
 
+	/**
+	 * @default 'CubicBezierCurve'
+	 */
+	type: string;
+
+	/**
+	 * @default new THREE.Vector2()
+	 */
 	v0: Vector2;
+
+	/**
+	 * @default new THREE.Vector2()
+	 */
 	v1: Vector2;
+
+	/**
+	 * @default new THREE.Vector2()
+	 */
 	v2: Vector2;
+
+	/**
+	 * @default new THREE.Vector2()
+	 */
 	v3: Vector2;
 
 }

src/extras/curves/CubicBezierCurve3.d.ts

@@ -5,9 +5,29 @@ export class CubicBezierCurve3 extends Curve<Vector3> {
 
 	constructor( v0: Vector3, v1: Vector3, v2: Vector3, v3: Vector3 );
 
+	/**
+	 * @default 'CubicBezierCurve3'
+	 */
+	type: string;
+
+	/**
+	 * @default new THREE.Vector3()
+	 */
 	v0: Vector3;
+
+	/**
+	 * @default new THREE.Vector3()
+	 */
 	v1: Vector3;
+
+	/**
+	 * @default new THREE.Vector3()
+	 */
 	v2: Vector3;
+
+	/**
+	 * @default new THREE.Vector3()
+	 */
 	v3: Vector3;
 
 }

src/extras/curves/EllipseCurve.d.ts

@@ -14,13 +14,49 @@ export class EllipseCurve extends Curve<Vector2> {
 		aRotation: number
 	);
 
+	/**
+	 * @default 'EllipseCurve'
+	 */
+	type: string;
+
+	/**
+	 * @default 0
+	 */
 	aX: number;
+
+	/**
+	 * @default 0
+	 */
 	aY: number;
+
+	/**
+	 * @default 1
+	 */
 	xRadius: number;
+
+	/**
+	 * @default 1
+	 */
 	yRadius: number;
+
+	/**
+	 * @default 0
+	 */
 	aStartAngle: number;
+
+	/**
+	 * @default 2 * Math.PI
+	 */
 	aEndAngle: number;
+
+	/**
+	 * @default false
+	 */
 	aClockwise: boolean;
+
+	/**
+	 * @default 0
+	 */
 	aRotation: number;
 
 }

src/extras/curves/LineCurve.d.ts

@@ -5,7 +5,20 @@ export class LineCurve extends Curve<Vector2> {
 
 	constructor( v1: Vector2, v2: Vector2 );
 
+	/**
+	 * @default 'LineCurve'
+	 */
+	type: string;
+
+
+	/**
+	 * @default new THREE.Vector2()
+	 */
 	v1: Vector2;
+
+	/**
+	 * @default new THREE.Vector2()
+	 */
 	v2: Vector2;
 
 }

src/extras/curves/LineCurve3.d.ts

@@ -5,7 +5,20 @@ export class LineCurve3 extends Curve<Vector3> {
 
 	constructor( v1: Vector3, v2: Vector3 );
 
+	/**
+	 * @default 'LineCurve3'
+	 */
+	type: string;
+
+
+	/**
+	 * @default new THREE.Vector3()
+	 */
 	v1: Vector3;
+
+	/**
+	 * @default new THREE.Vector3()
+	 */
 	v2: Vector3;
 
 }

src/extras/curves/QuadraticBezierCurve.d.ts

@@ -5,8 +5,24 @@ export class QuadraticBezierCurve extends Curve<Vector2> {
 
 	constructor( v0: Vector2, v1: Vector2, v2: Vector2 );
 
+	/**
+	 * @default 'QuadraticBezierCurve'
+	 */
+	type: string;
+
+	/**
+	 * @default new THREE.Vector2()
+	 */
 	v0: Vector2;
+
+	/**
+	 * @default new THREE.Vector2()
+	 */
 	v1: Vector2;
+
+	/**
+	 * @default new THREE.Vector2()
+	 */
 	v2: Vector2;
 
 }

src/extras/curves/QuadraticBezierCurve3.d.ts

@@ -5,8 +5,24 @@ export class QuadraticBezierCurve3 extends Curve<Vector3> {
 
 	constructor( v0: Vector3, v1: Vector3, v2: Vector3 );
 
+	/**
+	 * @default 'QuadraticBezierCurve3'
+	 */
+	type: string;
+
+	/**
+	 * @default new THREE.Vector3()
+	 */
 	v0: Vector3;
+
+	/**
+	 * @default new THREE.Vector3()
+	 */
 	v1: Vector3;
+
+	/**
+	 * @default new THREE.Vector3()
+	 */
 	v2: Vector3;
 
 }

src/extras/curves/SplineCurve.d.ts

@@ -5,6 +5,14 @@ export class SplineCurve extends Curve<Vector2> {
 
 	constructor( points?: Vector2[] );
 
+	/**
+	 * @default 'SplineCurve'
+	 */
+	type: string;
+
+	/**
+	 * @default []
+	 */
 	points: Vector2[];
 
 }

src/extras/objects/ImmediateRenderObject.d.ts

@@ -11,16 +11,49 @@ export class ImmediateRenderObject extends Object3D {
 
 	material: Material;
 
+	/**
+	 * @default false
+	 */
 	hasPositions: boolean;
+
+	/**
+	 * @default false
+	 */
 	hasNormals: boolean;
+
+	/**
+	 * @default false
+	 */
 	hasColors: boolean;
+
+	/**
+	 * @default false
+	 */
 	hasUvs: boolean;
 
+	/**
+	 * @default null
+	 */
 	positionArray: null | Float32Array;
+
+	/**
+	 * @default null
+	 */
 	normalArray: null | Float32Array;
+
+	/**
+	 * @default null
+	 */
 	colorArray: null | Float32Array;
+
+	/**
+	 * @default null
+	 */
 	uvArray: null | Float32Array;
 
+	/**
+	 * @default 0
+	 */
 	count: number;
 
 	render( renderCallback: Function ): void;

src/geometries/BoxGeometry.d.ts

@@ -4,6 +4,14 @@ import { BufferGeometry } from '../core/BufferGeometry';
 // Extras / Geometries /////////////////////////////////////////////////////////////////////
 export class BoxBufferGeometry extends BufferGeometry {
 
+	/**
+	 * @param [width=1] — Width of the sides on the X axis.
+	 * @param [height=1] — Height of the sides on the Y axis.
+	 * @param [depth=1] — Depth of the sides on the Z axis.
+	 * @param [widthSegments=1] — Number of segmented faces along the width of the sides.
+	 * @param [heightSegments=1] — Number of segmented faces along the height of the sides.
+	 * @param [depthSegments=1] — Number of segmented faces along the depth of the sides.
+	 */
 	constructor(
 		width?: number,
 		height?: number,
@@ -13,6 +21,11 @@ export class BoxBufferGeometry extends BufferGeometry {
 		depthSegments?: number
 	);
 
+	/**
+	 * @default 'BoxBufferGeometry'
+	 */
+	type: string;
+
 	parameters: {
 		width: number;
 		height: number;
@@ -30,12 +43,12 @@ export class BoxBufferGeometry extends BufferGeometry {
 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.
+	 * @param [width=1] — Width of the sides on the X axis.
+	 * @param [height=1] — Height of the sides on the Y axis.
+	 * @param [depth=1] — Depth of the sides on the Z axis.
+	 * @param [widthSegments=1] — Number of segmented faces along the width of the sides.
+	 * @param [heightSegments=1] — Number of segmented faces along the height of the sides.
+	 * @param [depthSegments=1] — Number of segmented faces along the depth of the sides.
 	 */
 	constructor(
 		width?: number,
@@ -46,6 +59,11 @@ export class BoxGeometry extends Geometry {
 		depthSegments?: number
 	);
 
+	/**
+	 * @default 'BoxGeometry'
+	 */
+	type: string;
+
 	parameters: {
 		width: number;
 		height: number;

src/geometries/CircleGeometry.d.ts

@@ -3,6 +3,12 @@ import { BufferGeometry } from '../core/BufferGeometry';
 
 export class CircleBufferGeometry extends BufferGeometry {
 
+	/**
+	 * @param [radius=1]
+	 * @param [segments=8]
+	 * @param [thetaStart=0]
+	 * @param [widthSegments=Math.PI * 2]
+	 */
 	constructor(
 		radius?: number,
 		segments?: number,
@@ -10,6 +16,11 @@ export class CircleBufferGeometry extends BufferGeometry {
 		thetaLength?: number
 	);
 
+	/**
+	 * @default 'CircleBufferGeometry'
+	 */
+	type: string;
+
 	parameters: {
 		radius: number;
 		segments: number;
@@ -21,6 +32,12 @@ export class CircleBufferGeometry extends BufferGeometry {
 
 export class CircleGeometry extends Geometry {
 
+	/**
+	 * @param [radius=1]
+	 * @param [segments=8]
+	 * @param [thetaStart=0]
+	 * @param [widthSegments=Math.PI * 2]
+	 */
 	constructor(
 		radius?: number,
 		segments?: number,
@@ -28,6 +45,11 @@ export class CircleGeometry extends Geometry {
 		thetaLength?: number
 	);
 
+	/**
+	 * @default 'CircleGeometry'
+	 */
+	type: string;
+
 	parameters: {
 		radius: number;
 		segments: number;

src/geometries/ConeGeometry.d.ts

@@ -3,6 +3,16 @@ import { CylinderBufferGeometry } from './CylinderGeometry';
 
 export class ConeBufferGeometry extends CylinderBufferGeometry {
 
+	/**
+	 * @param [radiusTop=0] — Radius of the cylinder at the top.
+	 * @param [radiusBottom=1] — Radius of the cylinder at the bottom.
+	 * @param [height=1] — Height of the cylinder.
+	 * @param [radiusSegments=8] — Number of segmented faces around the circumference of the cylinder.
+	 * @param [heightSegments=1] — Number of rows of faces along the height of the cylinder.
+	 * @param [openEnded=false] - A Boolean indicating whether or not to cap the ends of the cylinder.
+	 * @param [thetaStart=0]
+	 * @param [widthSegments=Math.PI * 2]
+	 */
 	constructor(
 		radius?: number,
 		height?: number,
@@ -13,10 +23,25 @@ export class ConeBufferGeometry extends CylinderBufferGeometry {
 		thetaLength?: number
 	);
 
+	/**
+	 * @default 'ConeBufferGeometry'
+	 */
+	type: string;
+
 }
 
 export class ConeGeometry extends CylinderGeometry {
 
+	/**
+	 * @param [radiusTop=0] — Radius of the cylinder at the top.
+	 * @param [radiusBottom=1] — Radius of the cylinder at the bottom.
+	 * @param [height=1] — Height of the cylinder.
+	 * @param [radiusSegments=8] — Number of segmented faces around the circumference of the cylinder.
+	 * @param [heightSegments=1] — Number of rows of faces along the height of the cylinder.
+	 * @param [openEnded=false] - A Boolean indicating whether or not to cap the ends of the cylinder.
+	 * @param [thetaStart=0]
+	 * @param [widthSegments=Math.PI * 2]
+	 */
 	constructor(
 		radius?: number,
 		height?: number,
@@ -27,4 +52,9 @@ export class ConeGeometry extends CylinderGeometry {
 		thetaLength?: number
 	);
 
+	/**
+	 * @default 'ConeGeometry'
+	 */
+	type: string;
+
 }

src/geometries/CylinderGeometry.d.ts

@@ -3,6 +3,16 @@ import { BufferGeometry } from '../core/BufferGeometry';
 
 export class CylinderBufferGeometry extends BufferGeometry {
 
+	/**
+	 * @param [radiusTop=1] — Radius of the cylinder at the top.
+	 * @param [radiusBottom=1] — Radius of the cylinder at the bottom.
+	 * @param [height=1] — Height of the cylinder.
+	 * @param [radiusSegments=8] — Number of segmented faces around the circumference of the cylinder.
+	 * @param [heightSegments=1] — Number of rows of faces along the height of the cylinder.
+	 * @param [openEnded=false] - A Boolean indicating whether or not to cap the ends of the cylinder.
+	 * @param [thetaStart=0]
+	 * @param [widthSegments=Math.PI * 2]
+	 */
 	constructor(
 		radiusTop?: number,
 		radiusBottom?: number,
@@ -14,6 +24,11 @@ export class CylinderBufferGeometry extends BufferGeometry {
 		thetaLength?: number
 	);
 
+	/**
+	 * @default 'CylinderBufferGeometry'
+	 */
+	type: string;
+
 	parameters: {
 		radiusTop: number;
 		radiusBottom: number;
@@ -30,12 +45,14 @@ export class CylinderBufferGeometry extends BufferGeometry {
 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.
+	 * @param [radiusTop=1] — Radius of the cylinder at the top.
+	 * @param [radiusBottom=1] — Radius of the cylinder at the bottom.
+	 * @param [height=1] — Height of the cylinder.
+	 * @param [radiusSegments=8] — Number of segmented faces around the circumference of the cylinder.
+	 * @param [heightSegments=1] — Number of rows of faces along the height of the cylinder.
+	 * @param [openEnded=false] - A Boolean indicating whether or not to cap the ends of the cylinder.
+	 * @param [thetaStart=0]
+	 * @param [widthSegments=Math.PI * 2]
 	 */
 	constructor(
 		radiusTop?: number,
@@ -48,6 +65,11 @@ export class CylinderGeometry extends Geometry {
 		thetaLength?: number
 	);
 
+	/**
+	 * @default 'CylinderGeometry'
+	 */
+	type: string;
+
 	parameters: {
 		radiusTop: number;
 		radiusBottom: number;

src/geometries/DodecahedronGeometry.d.ts

@@ -3,14 +3,32 @@ import { PolyhedronBufferGeometry } from './PolyhedronGeometry';
 
 export class DodecahedronBufferGeometry extends PolyhedronBufferGeometry {
 
+	/**
+	 * @param [radius=1]
+	 * @param [detail=0]
+	 */
 	constructor( radius?: number, detail?: number );
 
+	/**
+	 * @default 'DodecahedronBufferGeometry'
+	 */
+	type: string;
+
 }
 
 export class DodecahedronGeometry extends Geometry {
 
+	/**
+	 * @param [radius=1]
+	 * @param [detail=0]
+	 */
 	constructor( radius?: number, detail?: number );
 
+	/**
+	 * @default 'DodecahedronGeometry'
+	 */
+	type: string;
+
 	parameters: {
 		radius: number;
 		detail: number;

src/geometries/EdgesGeometry.d.ts

@@ -3,6 +3,19 @@ import { Geometry } from '../core/Geometry';
 
 export class EdgesGeometry extends BufferGeometry {
 
+	/**
+	 * @param geometry
+	 * @param [thresholdAngle=1]
+	 */
 	constructor( geometry: BufferGeometry | Geometry, thresholdAngle?: number );
 
+	/**
+	 * @default 'EdgesGeometry'
+	 */
+	type: string;
+
+	parameters: {
+		thresholdAngle: number;
+	};
+
 }

src/geometries/ExtrudeGeometry.d.ts

@@ -6,13 +6,34 @@ import { Geometry } from './../core/Geometry';
 import { BufferGeometry } from './../core/BufferGeometry';
 
 export interface ExtrudeGeometryOptions {
+	/**
+	 * @default 12
+	 */
 	curveSegments?: number;
+	/**
+	 * @default 1
+	 */
 	steps?: number;
+	/**
+	 * @default 100
+	 */
 	depth?: number;
+	/**
+	 * @default true
+	 */
 	bevelEnabled?: boolean;
+	/**
+	 * @default 6
+	 */
 	bevelThickness?: number;
 	bevelSize?: number;
+	/**
+	 * @default 0
+	 */
 	bevelOffset?: number;
+	/**
+	 * @default 3
+	 */
 	bevelSegments?: number;
 	extrudePath?: Curve<Vector3>;
 	UVGenerator?: UVGenerator;
@@ -42,6 +63,11 @@ export class ExtrudeBufferGeometry extends BufferGeometry {
 
 	static WorldUVGenerator: UVGenerator;
 
+	/**
+	 * @default 'ExtrudeBufferGeometry'
+	 */
+	type: string;
+
 	addShapeList( shapes: Shape[], options?: any ): void;
 	addShape( shape: Shape, options?: any ): void;
 
@@ -53,6 +79,11 @@ export class ExtrudeGeometry extends Geometry {
 
 	static WorldUVGenerator: UVGenerator;
 
+	/**
+	 * @default 'ExtrudeGeometry'
+	 */
+	type: string;
+
 	addShapeList( shapes: Shape[], options?: any ): void;
 	addShape( shape: Shape, options?: any ): void;
 

src/geometries/IcosahedronGeometry.d.ts

@@ -5,12 +5,30 @@ import {
 
 export class IcosahedronBufferGeometry extends PolyhedronBufferGeometry {
 
+	/**
+	 * @param [radius=1]
+	 * @param [detail=0]
+	 */
 	constructor( radius?: number, detail?: number );
 
+	/**
+	 * @default 'IcosahedronBufferGeometry'
+	 */
+	type: string;
+
 }
 
 export class IcosahedronGeometry extends PolyhedronGeometry {
 
+	/**
+	 * @param [radius=1]
+	 * @param [detail=0]
+	 */
 	constructor( radius?: number, detail?: number );
 
+	/**
+	 * @default 'IcosahedronGeometry'
+	 */
+	type: string;
+
 }

src/geometries/LatheGeometry.d.ts

@@ -4,6 +4,12 @@ import { BufferGeometry } from './../core/BufferGeometry';
 
 export class LatheBufferGeometry extends BufferGeometry {
 
+	/**
+	 * @param points
+	 * @param [segments=12]
+	 * @param [phiStart=0]
+	 * @param [phiLength=Math.PI * 2]
+	 */
 	constructor(
 		points: Vector2[],
 		segments?: number,
@@ -11,6 +17,11 @@ export class LatheBufferGeometry extends BufferGeometry {
 		phiLength?: number
 	);
 
+	/**
+	 * @default 'LatheBufferGeometry'
+	 */
+	type: string;
+
 	parameters: {
 		points: Vector2[];
 		segments: number;
@@ -22,6 +33,12 @@ export class LatheBufferGeometry extends BufferGeometry {
 
 export class LatheGeometry extends Geometry {
 
+	/**
+	 * @param points
+	 * @param [segments=12]
+	 * @param [phiStart=0]
+	 * @param [phiLength=Math.PI * 2]
+	 */
 	constructor(
 		points: Vector2[],
 		segments?: number,
@@ -29,6 +46,12 @@ export class LatheGeometry extends Geometry {
 		phiLength?: number
 	);
 
+
+	/**
+	 * @default 'LatheGeometry'
+	 */
+	type: string;
+
 	parameters: {
 		points: Vector2[];
 		segments: number;

src/geometries/OctahedronGeometry.d.ts

@@ -5,12 +5,30 @@ import {
 
 export class OctahedronBufferGeometry extends PolyhedronBufferGeometry {
 
+	/**
+	 * @param [radius=1]
+	 * @param [detail=0]
+	 */
 	constructor( radius?: number, detail?: number );
 
+	/**
+	 * @default 'OctahedronBufferGeometry'
+	 */
+	type: string;
+
 }
 
 export class OctahedronGeometry extends PolyhedronGeometry {
 
+	/**
+	 * @param [radius=1]
+	 * @param [detail=0]
+	 */
 	constructor( radius?: number, detail?: number );
 
+	/**
+	 * @default 'OctahedronGeometry'
+	 */
+	type: string;
+
 }

src/geometries/ParametricGeometry.d.ts

@@ -10,6 +10,11 @@ export class ParametricBufferGeometry extends BufferGeometry {
 		stacks: number
 	);
 
+	/**
+	 * @default 'ParametricBufferGeometry'
+	 */
+	type: string;
+
 	parameters: {
 		func: ( u: number, v: number, dest: Vector3 ) => void;
 		slices: number;
@@ -26,6 +31,11 @@ export class ParametricGeometry extends Geometry {
 		stacks: number
 	);
 
+	/**
+	 * @default 'ParametricGeometry'
+	 */
+	type: string;
+
 	parameters: {
 		func: ( u: number, v: number, dest: Vector3 ) => void;
 		slices: number;

src/geometries/PlaneGeometry.d.ts

@@ -3,6 +3,12 @@ import { BufferGeometry } from './../core/BufferGeometry';
 
 export class PlaneBufferGeometry extends BufferGeometry {
 
+	/**
+	 * @param [width=1] — Width of the sides on the X axis.
+	 * @param [height=1] — Height of the sides on the Y axis.
+	 * @param [widthSegments=1] — Number of segmented faces along the width of the sides.
+	 * @param [heightSegments=1] — Number of segmented faces along the height of the sides.
+	 */
 	constructor(
 		width?: number,
 		height?: number,
@@ -10,6 +16,11 @@ export class PlaneBufferGeometry extends BufferGeometry {
 		heightSegments?: number
 	);
 
+	/**
+	 * @default 'PlaneBufferGeometry'
+	 */
+	type: string;
+
 	parameters: {
 		width: number;
 		height: number;
@@ -21,6 +32,12 @@ export class PlaneBufferGeometry extends BufferGeometry {
 
 export class PlaneGeometry extends Geometry {
 
+	/**
+	 * @param [width=1] — Width of the sides on the X axis.
+	 * @param [height=1] — Height of the sides on the Y axis.
+	 * @param [widthSegments=1] — Number of segmented faces along the width of the sides.
+	 * @param [heightSegments=1] — Number of segmented faces along the height of the sides.
+	 */
 	constructor(
 		width?: number,
 		height?: number,
@@ -28,6 +45,11 @@ export class PlaneGeometry extends Geometry {
 		heightSegments?: number
 	);
 
+	/**
+	 * @default 'PlaneGeometry'
+	 */
+	type: string;
+
 	parameters: {
 		width: number;
 		height: number;

src/geometries/PolyhedronGeometry.d.ts

@@ -4,6 +4,12 @@ import { BufferGeometry } from './../core/BufferGeometry';
 
 export class PolyhedronBufferGeometry extends BufferGeometry {
 
+	/**
+	 * @param vertices
+	 * @param indices
+	 * @param [radius=1]
+	 * @param [detail=0]
+	 */
 	constructor(
 		vertices: number[],
 		indices: number[],
@@ -11,6 +17,11 @@ export class PolyhedronBufferGeometry extends BufferGeometry {
 		detail?: number
 	);
 
+	/**
+	 * @default 'PolyhedronBufferGeometry'
+	 */
+	type: string;
+
 	parameters: {
 		vertices: number[];
 		indices: number[];
@@ -22,6 +33,12 @@ export class PolyhedronBufferGeometry extends BufferGeometry {
 
 export class PolyhedronGeometry extends Geometry {
 
+	/**
+	 * @param vertices
+	 * @param indices
+	 * @param [radius=1]
+	 * @param [detail=0]
+	 */
 	constructor(
 		vertices: number[],
 		indices: number[],
@@ -29,6 +46,11 @@ export class PolyhedronGeometry extends Geometry {
 		detail?: number
 	);
 
+	/**
+	 * @default 'PolyhedronGeometry'
+	 */
+	type: string;
+
 	parameters: {
 		vertices: number[];
 		indices: number[];

src/geometries/RingGeometry.d.ts

@@ -3,6 +3,14 @@ import { BufferGeometry } from './../core/BufferGeometry';
 
 export class RingBufferGeometry extends BufferGeometry {
 
+	/**
+	 * @param [innerRadius=0.5]
+	 * @param [outerRadius=1]
+	 * @param [thetaSegments=8]
+	 * @param [phiSegments=1]
+	 * @param [thetaStart=0]
+	 * @param [thetaLength=Math.PI * 2]
+	 */
 	constructor(
 		innerRadius?: number,
 		outerRadius?: number,
@@ -12,6 +20,11 @@ export class RingBufferGeometry extends BufferGeometry {
 		thetaLength?: number
 	);
 
+	/**
+	 * @default 'RingBufferGeometry'
+	 */
+	type: string;
+
 	parameters: {
 		innerRadius: number;
 		outerRadius: number;
@@ -25,6 +38,14 @@ export class RingBufferGeometry extends BufferGeometry {
 
 export class RingGeometry extends Geometry {
 
+	/**
+	 * @param [innerRadius=0.5]
+	 * @param [outerRadius=1]
+	 * @param [thetaSegments=8]
+	 * @param [phiSegments=1]
+	 * @param [thetaStart=0]
+	 * @param [thetaLength=Math.PI * 2]
+	 */
 	constructor(
 		innerRadius?: number,
 		outerRadius?: number,
@@ -34,6 +55,11 @@ export class RingGeometry extends Geometry {
 		thetaLength?: number
 	);
 
+	/**
+	 * @default 'RingGeometry'
+	 */
+	type: string;
+
 	parameters: {
 		innerRadius: number;
 		outerRadius: number;

src/geometries/ShapeGeometry.d.ts

@@ -4,14 +4,28 @@ import { BufferGeometry } from './../core/BufferGeometry';
 
 export class ShapeBufferGeometry extends BufferGeometry {
 
+	/**
+	 * @default 'ShapeBufferGeometry'
+	 */
+	type: string;
+
 	constructor( shapes: Shape | Shape[], curveSegments?: number );
 
 }
 
 export class ShapeGeometry extends Geometry {
 
+	/**
+	 * @param shapes
+	 * @param [curveSegments=12]
+	 */
 	constructor( shapes: Shape | Shape[], curveSegments?: number );
 
+	/**
+	 * @default 'ShapeGeometry'
+	 */
+	type: string;
+
 	addShapeList( shapes: Shape[], options: any ): ShapeGeometry;
 	addShape( shape: Shape, options?: any ): void;
 

src/geometries/SphereGeometry.d.ts

@@ -3,6 +3,17 @@ import { BufferGeometry } from './../core/BufferGeometry';
 
 export class SphereBufferGeometry extends BufferGeometry {
 
+	/**
+	 * 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=50] — sphere radius. Default is 50.
+	 * @param [widthSegments=8] — number of horizontal segments. Minimum value is 3, and the default is 8.
+	 * @param [heightSegments=6] — number of vertical segments. Minimum value is 2, and the default is 6.
+	 * @param [phiStart=0] — specify horizontal starting angle. Default is 0.
+	 * @param [phiLength=Math.PI * 2] — specify horizontal sweep angle size. Default is Math.PI * 2.
+	 * @param [thetaStart=0] — specify vertical starting angle. Default is 0.
+	 * @param [thetaLength=Math.PI * 2] — specify vertical sweep angle size. Default is Math.PI.
+	 */
 	constructor(
 		radius?: number,
 		widthSegments?: number,
@@ -13,6 +24,11 @@ export class SphereBufferGeometry extends BufferGeometry {
 		thetaLength?: number
 	);
 
+	/**
+	 * @default 'SphereBufferGeometry'
+	 */
+	type: string;
+
 	parameters: {
 		radius: number;
 		widthSegments: number;
@@ -33,13 +49,13 @@ 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.
+	 * @param [radius=50] — sphere radius. Default is 50.
+	 * @param [widthSegments=8] — number of horizontal segments. Minimum value is 3, and the default is 8.
+	 * @param [heightSegments=6] — number of vertical segments. Minimum value is 2, and the default is 6.
+	 * @param [phiStart=0] — specify horizontal starting angle. Default is 0.
+	 * @param [phiLength=Math.PI * 2] — specify horizontal sweep angle size. Default is Math.PI * 2.
+	 * @param [thetaStart=0] — specify vertical starting angle. Default is 0.
+	 * @param [thetaLength=Math.PI * 2] — specify vertical sweep angle size. Default is Math.PI.
 	 */
 	constructor(
 		radius?: number,
@@ -51,6 +67,11 @@ export class SphereGeometry extends Geometry {
 		thetaLength?: number
 	);
 
+	/**
+	 * @default 'SphereGeometry'
+	 */
+	type: string;
+
 	parameters: {
 		radius: number;
 		widthSegments: number;

src/geometries/TetrahedronGeometry.d.ts

@@ -2,12 +2,30 @@ import { PolyhedronGeometry, PolyhedronBufferGeometry } from './PolyhedronGeomet
 
 export class TetrahedronBufferGeometry extends PolyhedronBufferGeometry {
 
+	/**
+	 * @param [radius=1]
+	 * @param [detail=0]
+	 */
 	constructor( radius?: number, detail?: number );
 
+	/**
+	 * @default 'TetrahedronBufferGeometry'
+	 */
+	type: string;
+
 }
 
 export class TetrahedronGeometry extends PolyhedronGeometry {
 
+	/**
+	 * @param [radius=1]
+	 * @param [detail=0]
+	 */
 	constructor( radius?: number, detail?: number );
 
+	/**
+	 * @default 'TetrahedronGeometry'
+	 */
+	type: string;
+
 }

src/geometries/TextGeometry.d.ts

@@ -15,6 +15,11 @@ export interface TextGeometryParameters {
 
 export class TextBufferGeometry extends ExtrudeBufferGeometry {
 
+	/**
+	 * @default 'TextBufferGeometry'
+	 */
+	type: string;
+
 	constructor( text: string, parameters: TextGeometryParameters );
 
 	parameters: {
@@ -35,13 +40,30 @@ export class TextGeometry extends ExtrudeGeometry {
 
 	constructor( text: string, parameters: TextGeometryParameters );
 
+	/**
+	 * @default 'TextGeometry'
+	 */
+	type: string;
+
 	parameters: {
 		font: Font;
 		size: number;
+		/**
+		 * @default 50
+		 */
 		height: number;
 		curveSegments: number;
+		/**
+		 * @default false
+		 */
 		bevelEnabled: boolean;
+		/**
+		 * @default 10
+		 */
 		bevelThickness: number;
+		/**
+		 * @default 8
+		 */
 		bevelSize: number;
 		bevelOffset: number;
 		bevelSegments: number;

src/geometries/TorusGeometry.d.ts

@@ -3,6 +3,13 @@ import { BufferGeometry } from './../core/BufferGeometry';
 
 export class TorusBufferGeometry extends BufferGeometry {
 
+	/**
+	 * @param [radius=1]
+	 * @param [tube=0.4]
+	 * @param [radialSegments=8]
+	 * @param [tubularSegments=6]
+	 * @param [arc=Math.PI * 2]
+	 */
 	constructor(
 		radius?: number,
 		tube?: number,
@@ -11,6 +18,11 @@ export class TorusBufferGeometry extends BufferGeometry {
 		arc?: number
 	);
 
+	/**
+	 * @default 'TorusBufferGeometry'
+	 */
+	type: string;
+
 	parameters: {
 		radius: number;
 		tube: number;
@@ -23,6 +35,13 @@ export class TorusBufferGeometry extends BufferGeometry {
 
 export class TorusGeometry extends Geometry {
 
+	/**
+	 * @param [radius=1]
+	 * @param [tube=0.4]
+	 * @param [radialSegments=8]
+	 * @param [tubularSegments=6]
+	 * @param [arc=Math.PI * 2]
+	 */
 	constructor(
 		radius?: number,
 		tube?: number,
@@ -31,6 +50,11 @@ export class TorusGeometry extends Geometry {
 		arc?: number
 	);
 
+	/**
+	 * @default 'TorusGeometry'
+	 */
+	type: string;
+
 	parameters: {
 		radius: number;
 		tube: number;

src/geometries/TorusKnotGeometry.d.ts

@@ -3,6 +3,14 @@ import { BufferGeometry } from './../core/BufferGeometry';
 
 export class TorusKnotBufferGeometry extends BufferGeometry {
 
+	/**
+	 * @param [radius=1]
+	 * @param [tube=0.4]
+	 * @param [radialSegments=64]
+	 * @param [tubularSegments=8]
+	 * @param [p=2]
+	 * @param [q=3]
+	 */
 	constructor(
 		radius?: number,
 		tube?: number,
@@ -12,6 +20,11 @@ export class TorusKnotBufferGeometry extends BufferGeometry {
 		q?: number
 	);
 
+	/**
+	 * @default 'TorusKnotBufferGeometry'
+	 */
+	type: string;
+
 	parameters: {
 		radius: number;
 		tube: number;
@@ -25,6 +38,14 @@ export class TorusKnotBufferGeometry extends BufferGeometry {
 
 export class TorusKnotGeometry extends Geometry {
 
+	/**
+	 * @param [radius=1]
+	 * @param [tube=0.4]
+	 * @param [radialSegments=64]
+	 * @param [tubularSegments=8]
+	 * @param [p=2]
+	 * @param [q=3]
+	 */
 	constructor(
 		radius?: number,
 		tube?: number,
@@ -34,6 +55,11 @@ export class TorusKnotGeometry extends Geometry {
 		q?: number
 	);
 
+	/**
+	 * @default 'TorusKnotGeometry'
+	 */
+	type: string;
+
 	parameters: {
 		radius: number;
 		tube: number;

src/geometries/TubeGeometry.d.ts

@@ -5,6 +5,13 @@ import { BufferGeometry } from './../core/BufferGeometry';
 
 export class TubeBufferGeometry extends BufferGeometry {
 
+	/**
+	 * @param path
+	 * @param [tubularSegments=64]
+	 * @param [radius=1]
+	 * @param [radiusSegments=8]
+	 * @param [closed=false]
+	 */
 	constructor(
 		path: Curve<Vector3>,
 		tubularSegments?: number,
@@ -28,6 +35,13 @@ export class TubeBufferGeometry extends BufferGeometry {
 
 export class TubeGeometry extends Geometry {
 
+	/**
+	 * @param path
+	 * @param [tubularSegments=64]
+	 * @param [radius=1]
+	 * @param [radiusSegments=8]
+	 * @param [closed=false]
+	 */
 	constructor(
 		path: Curve<Vector3>,
 		tubularSegments?: number,

src/geometries/WireframeGeometry.d.ts

@@ -5,4 +5,9 @@ export class WireframeGeometry extends BufferGeometry {
 
 	constructor( geometry: Geometry | BufferGeometry );
 
+	/**
+	 * @default 'WireframeGeometry'
+	 */
+	type: string;
+
 }

src/helpers/ArrowHelper.d.ts

@@ -8,6 +8,14 @@ import { Object3D } from './../core/Object3D';
 
 export class ArrowHelper extends Object3D {
 
+	/**
+	 * @param [dir=new THREE.Vector3( 0, 0, 1 )]
+	 * @param [origin=new THREE.Vector3( 0, 0, 0 )]
+	 * @param [length=1]
+	 * @param [color=0xffff00]
+	 * @param headLength
+	 * @param headWidth
+	 */
 	constructor(
 		dir: Vector3,
 		origin?: Vector3,
@@ -17,6 +25,11 @@ export class ArrowHelper extends Object3D {
 		headWidth?: number
 	);
 
+	/**
+	 * @default 'ArrowHelper'
+	 */
+	type: string;
+
 	line: Line;
 	cone: Mesh;
 

src/helpers/AxesHelper.d.ts

@@ -2,6 +2,14 @@ import { LineSegments } from './../objects/LineSegments';
 
 export class AxesHelper extends LineSegments {
 
+	/**
+	 * @param [size=1]
+	 */
 	constructor( size?: number );
 
+	/**
+	 * @default 'AxesHelper'
+	 */
+	type: string;
+
 }

src/helpers/Box3Helper.d.ts

@@ -4,8 +4,17 @@ import { LineSegments } from './../objects/LineSegments';
 
 export class Box3Helper extends LineSegments {
 
+	/**
+	 * @param box
+	 * @param [color=0xffff00]
+	 */
 	constructor( box: Box3, color?: Color );
 
+	/**
+	 * @default 'Box3Helper'
+	 */
+	type: string;
+
 	box: Box3;
 
 }

src/helpers/BoxHelper.d.ts

@@ -4,8 +4,17 @@ import { LineSegments } from './../objects/LineSegments';
 
 export class BoxHelper extends LineSegments {
 
+	/**
+	 * @param object
+	 * @param [color=0xffff00]
+	 */
 	constructor( object: Object3D, color?: Color | string | number );
 
+	/**
+	 * @default 'BoxHelper'
+	 */
+	type: string;
+
 	update( object?: Object3D ): void;
 
 	setFromObject( object: Object3D ): this;

src/helpers/CameraHelper.d.ts

@@ -8,6 +8,11 @@ export class CameraHelper extends LineSegments {
 	camera: Camera;
 	pointMap: { [id: string]: number[] };
 
+	/**
+	 * @default 'CameraHelper'
+	 */
+	type: string;
+
 	update(): void;
 
 }

src/helpers/DirectionalLightHelper.d.ts

@@ -6,6 +6,11 @@ import { Object3D } from './../core/Object3D';
 
 export class DirectionalLightHelper extends Object3D {
 
+	/**
+	 * @param light
+	 * @param [size=1]
+	 * @param color
+	 */
 	constructor(
 		light: DirectionalLight,
 		size?: number,
@@ -15,8 +20,16 @@ export class DirectionalLightHelper extends Object3D {
 	light: DirectionalLight;
 	lightPlane: Line;
 	targetLine: Line;
+
+	/**
+	 * @default undefined
+	 */
 	color: Color | string | number | undefined;
 	matrix: Matrix4;
+
+	/**
+	 * @default false
+	 */
 	matrixAutoUpdate: boolean;
 
 	dispose(): void;

src/helpers/GridHelper.d.ts

@@ -3,12 +3,24 @@ import { LineSegments } from './../objects/LineSegments';
 
 export class GridHelper extends LineSegments {
 
+	/**
+	 * @param [size=10]
+	 * @param [divisions=10]
+	 * @param [color1=0x444444]
+	 * @param [color2=0x888888]
+	 */
 	constructor(
-		size: number,
-		divisions: number,
+		size?: number,
+		divisions?: number,
 		color1?: Color | string | number,
 		color2?: Color | string | number
 	);
+
+	/**
+	 * @default 'GridHelper'
+	 */
+	type: string;
+
 	/**
 	 * @deprecated Colors should be specified in the constructor.
 	 */

src/helpers/PlaneHelper.d.ts

@@ -3,9 +3,23 @@ import { LineSegments } from './../objects/LineSegments';
 
 export class PlaneHelper extends LineSegments {
 
+	/**
+	 * @param plane
+	 * @param [size=1]
+	 * @param [hex=0xffff00]
+	 */
 	constructor( plane: Plane, size?: number, hex?: number );
 
+	/**
+	 * @default 'PlaneHelper'
+	 */
+	type: string;
+
 	plane: Plane;
+
+	/**
+	 * @default 1
+	 */
 	size: number;
 
 	updateMatrixWorld( force?: boolean ): void;

src/helpers/PointLightHelper.d.ts

@@ -11,9 +11,18 @@ export class PointLightHelper extends Object3D {
 		color?: Color | string | number
 	);
 
+	/**
+	 * @default 'PointLightHelper'
+	 */
+	type: string;
+
 	light: PointLight;
 	color: Color | string | number | undefined;
 	matrix: Matrix4;
+
+	/**
+	 * @default false
+	 */
 	matrixAutoUpdate: boolean;
 
 	dispose(): void;

src/helpers/PolarGridHelper.d.ts

@@ -3,6 +3,14 @@ import { Color } from '../math/Color';
 
 export class PolarGridHelper extends LineSegments {
 
+	/**
+	 * @param [radius=10]
+	 * @param [radials=16]
+	 * @param [circles=8]
+	 * @param [divisions=64]
+	 * @param [color1=0x444444]
+	 * @param [color2=0x888888]
+	 */
 	constructor(
 		radius: number,
 		radials: number,
@@ -12,4 +20,9 @@ export class PolarGridHelper extends LineSegments {
 		color2: Color | string | number | undefined
 	);
 
+	/**
+	 * @default 'PolarGridHelper'
+	 */
+	type: string;
+
 }

src/helpers/SkeletonHelper.d.ts

@@ -1,4 +1,5 @@
 import { Object3D } from './../core/Object3D';
+import { Matrix4 } from './../math/Matrix4';
 import { Bone } from './../objects/Bone';
 import { LineSegments } from './../objects/LineSegments';
 
@@ -6,11 +7,23 @@ export class SkeletonHelper extends LineSegments {
 
 	constructor( object: Object3D );
 
+	/**
+	 * @default 'SkeletonHelper'
+	 */
+	type: string;
+
 	bones: Bone[];
 	root: Object3D;
 
 	readonly isSkeletonHelper: true;
 
+	matrix: Matrix4;
+
+	/**
+	 * @default false
+	 */
+	matrixAutoUpdate: boolean;
+
 	getBoneList( object: Object3D ): Bone[];
 	update(): void;
 

src/helpers/SpotLightHelper.d.ts

@@ -10,6 +10,10 @@ export class SpotLightHelper extends Object3D {
 
 	light: Light;
 	matrix: Matrix4;
+
+	/**
+	 * @default false
+	 */
 	matrixAutoUpdate: boolean;
 	color: Color | string | number | undefined;
 	cone: LineSegments;

src/lights/AmbientLight.d.ts

@@ -11,9 +11,18 @@ export class AmbientLight extends Light {
 	/**
 	 * This creates a Ambientlight with a color.
 	 * @param color Numeric value of the RGB component of the color or a Color instance.
+	 * @param [intensity=1]
 	 */
 	constructor( color?: Color | string | number, intensity?: number );
 
+	/**
+	 * @default 'AmbientLight'
+	 */
+	type: string;
+
+	/**
+	 * @default undefined
+	 */
 	castShadow: boolean;
 	readonly isAmbientLight: true;
 

src/lights/DirectionalLight.d.ts

@@ -2,6 +2,7 @@ import { Color } from './../math/Color';
 import { Object3D } from './../core/Object3D';
 import { DirectionalLightShadow } from './DirectionalLightShadow';
 import { Light } from './Light';
+import { Vector3 } from '../math/Vector3';
 
 /**
  * @example
@@ -16,17 +17,31 @@ export class DirectionalLight extends Light {
 
 	constructor( color?: Color | string | number, intensity?: number );
 
+	/**
+	 * @default 'DirectionalLight'
+	 */
+	type: string;
+
+	/**
+	 * @default THREE.Object3D.DefaultUp
+	 */
+	position: Vector3;
+
 	/**
 	 * Target used for shadow camera orientation.
+	 * @default new THREE.Object3D()
 	 */
 	target: Object3D;
 
 	/**
 	 * Light's intensity.
-	 * Default — 1.0.
+	 * @default 1
 	 */
 	intensity: number;
 
+	/**
+	 * @default new THREE.DirectionalLightShadow()
+	 */
 	shadow: DirectionalLightShadow;
 	readonly isDirectionalLight: true;
 

src/lights/HemisphereLight.d.ts

@@ -1,17 +1,37 @@
 import { Color } from './../math/Color';
+import { Vector3 } from '../math/Vector3';
 import { Light } from './Light';
 
 export class HemisphereLight extends Light {
 
+	/**
+	 * @param skyColor
+	 * @param groundColor
+	 * @param [intensity=1]
+	 */
 	constructor(
 		skyColor?: Color | string | number,
 		groundColor?: Color | string | number,
 		intensity?: number
 	);
 
-	skyColor: Color;
+	/**
+	 * @default 'HemisphereLight'
+	 */
+	type: string;
+
+	/**
+	 * @default THREE.Object3D.DefaultUp
+	 */
+	position: Vector3;
+
+	/**
+	 * @default undefined
+	 */
+	castShadow: boolean;
+
 	groundColor: Color;
-	intensity: number;
+
 	readonly isHemisphereLight: true;
 
 }

src/lights/Light.d.ts

@@ -11,9 +11,22 @@ export class Light extends Object3D {
 
 	constructor( hex?: number | string, intensity?: number );
 
+	/**
+	 * @default 'Light'
+	 */
+	type: string;
+
 	color: Color;
+
+	/**
+	 * @default 1
+	 */
 	intensity: number;
 	readonly isLight: true;
+
+	/**
+	 * @default undefined
+	 */
 	receiveShadow: boolean;
 	shadow: LightShadow;
 	/**

src/lights/LightProbe.d.ts

@@ -5,7 +5,16 @@ export class LightProbe extends Light {
 
 	constructor( sh?: SphericalHarmonics3, intensity?: number );
 
+	/**
+	 * @default 'LightProbe'
+	 */
+	type: string;
+
 	readonly isLightProbe: true;
+
+	/**
+	 * @default new THREE.SphericalHarmonics3()
+	 */
 	sh: SphericalHarmonics3;
 
 	fromJSON( json: object ): LightProbe;

src/lights/LightShadow.d.ts

@@ -10,14 +10,50 @@ export class LightShadow {
 	constructor( camera: Camera );
 
 	camera: Camera;
+
+	/**
+	 * @default 0
+	 */
 	bias: number;
+
+	/**
+	 * @default 0
+	 */
 	normalBias: number;
+
+	/**
+	 * @default 1
+	 */
 	radius: number;
+
+	/**
+	 * @default new THREE.Vector2( 512, 512 )
+	 */
 	mapSize: Vector2;
+
+	/**
+	 * @default null
+	 */
 	map: RenderTarget;
+
+	/**
+	 * @default null
+	 */
 	mapPass: RenderTarget;
+
+	/**
+	 * @default new THREE.Matrix4()
+	 */
 	matrix: Matrix4;
+
+	/**
+	 * @default true
+	 */
 	autoUpdate: boolean;
+
+	/**
+	 * @default false
+	 */
 	needsUpdate: boolean;
 
 	copy( source: LightShadow ): this;

src/lights/PointLight.d.ts

@@ -17,20 +17,33 @@ export class PointLight extends Light {
 		decay?: number
 	);
 
-	/*
+	/**
+	 * @default 'PointLight'
+	 */
+	type: string;
+
+	/**
 	 * Light's intensity.
-	 * Default - 1.0.
+	 * @default 1
 	 */
 	intensity: number;
 
 	/**
 	 * If non-zero, light will attenuate linearly from maximum intensity at light position down to zero at distance.
-	 * Default - 0.0.
+	 * @default 0
 	 */
 	distance: number;
 
+	/**
+	 * @default 1
+	 */
 	decay: number;
+
+	/**
+	 * @default new THREE.PointLightShadow()
+	 */
 	shadow: PointLightShadow;
+
 	power: number;
 
 }

src/lights/RectAreaLight.d.ts

@@ -10,10 +10,26 @@ export class RectAreaLight extends Light {
 		height?: number
 	);
 
+	/**
+	 * @default 'RectAreaLight'
+	 */
 	type: string;
+
+	/**
+	 * @default 10
+	 */
 	width: number;
+
+	/**
+	 * @default 10
+	 */
 	height: number;
+
+	/**
+	 * @default 1
+	 */
 	intensity: number;
+
 	readonly isRectAreaLight: true;
 
 }

src/lights/SpotLight.d.ts

@@ -1,4 +1,5 @@
 import { Color } from './../math/Color';
+import { Vector3 } from '../math/Vector3';
 import { Object3D } from './../core/Object3D';
 import { SpotLightShadow } from './SpotLightShadow';
 import { Light } from './Light';
@@ -17,34 +18,56 @@ export class SpotLight extends Light {
 		decay?: number
 	);
 
+	/**
+	 * @default 'SpotLight'
+	 */
+	type: string;
+
+	/**
+	 * @default THREE.Object3D.DefaultUp
+	 */
+	position: Vector3;
+
 	/**
 	 * Spotlight focus points at target.position.
-	 * Default position — (0,0,0).
+	 * @default new THREE.Object3D()
 	 */
 	target: Object3D;
 
 	/**
 	 * Light's intensity.
-	 * Default — 1.0.
+	 * @default 1
 	 */
 	intensity: number;
 
 	/**
 	 * If non-zero, light will attenuate linearly from maximum intensity at light position down to zero at distance.
-	 * Default — 0.0.
+	 * @default 0
 	 */
 	distance: number;
 
-	/*
+	/**
 	 * Maximum extent of the spotlight, in radians, from its direction.
-	 * Default — Math.PI/2.
+	 * @default Math.PI / 3.
 	 */
 	angle: number;
 
+	/**
+	 * @default 1
+	 */
 	decay: number;
+
+	/**
+	 * @default new THREE.SpotLightShadow()
+	 */
 	shadow: SpotLightShadow;
 	power: number;
+
+	/**
+	 * @default 0
+	 */
 	penumbra: number;
+
 	readonly isSpotLight: true;
 
 }

src/loaders/Cache.d.ts

@@ -1,5 +1,12 @@
 export namespace Cache {
+	/**
+	 * @default false
+	 */
 	export let enabled: boolean;
+
+	/**
+	 * @default {}
+	 */
 	export let files: any;
 
 	export function add( key: string, file: any ): void;

src/loaders/ImageBitmapLoader.d.ts

@@ -5,6 +5,9 @@ export class ImageBitmapLoader extends Loader {
 
 	constructor( manager?: LoadingManager );
 
+	/**
+	 * @default { premultiplyAlpha: 'none' }
+	 */
 	options: undefined | object;
 
 	readonly isImageBitmapLoader: true;

src/loaders/Loader.d.ts

@@ -7,10 +7,25 @@ export class Loader {
 
 	constructor( manager?: LoadingManager );
 
+	/**
+	 * @default 'anonymous'
+	 */
 	crossOrigin: string;
+
+	/**
+	 * @default ''
+	 */
 	path: string;
+
+	/**
+	 * @default ''
+	 */
 	resourcePath: string;
 	manager: LoadingManager;
+
+	/**
+	 * @default {}
+	 */
 	requestHeader: { [header: string]: string };
 
 	/*

src/loaders/MaterialLoader.d.ts

@@ -7,6 +7,9 @@ export class MaterialLoader extends Loader {
 
 	constructor( manager?: LoadingManager );
 
+	/**
+	 * @default {}
+	 */
 	textures: { [key: string]: Texture };
 
 	load(

src/materials/LineBasicMaterial.d.ts

@@ -13,10 +13,34 @@ export class LineBasicMaterial extends Material {
 
 	constructor( parameters?: LineBasicMaterialParameters );
 
-	color: Color;
+	/**
+	 * @default 'LineBasicMaterial'
+	 */
+	type: string;
+
+	/**
+	 * @default 0xffffff
+	 */
+	color: Color | string | number;
+
+	/**
+	 * @default 1
+	 */
 	linewidth: number;
+
+	/**
+	 * @default 'round'
+	 */
 	linecap: string;
+
+	/**
+	 * @default 'round'
+	 */
 	linejoin: string;
+
+	/**
+	 * @default false
+	 */
 	morphTargets: boolean;
 
 	setValues( parameters: LineBasicMaterialParameters ): void;

src/materials/LineDashedMaterial.d.ts

@@ -10,8 +10,24 @@ export class LineDashedMaterial extends LineBasicMaterial {
 
 	constructor( parameters?: LineDashedMaterialParameters );
 
+	/**
+	 * @default 'LineDashedMaterial'
+	 */
+	type: string;
+
+	/**
+	 * @default 1
+	 */
 	scale: number;
+
+	/**
+	 * @default 1
+	 */
 	dashSize: number;
+
+	/**
+	 * @default 1
+	 */
 	gapSize: number;
 	readonly isLineDashedMaterial: true;
 

src/materials/Material.d.ts

@@ -67,88 +67,105 @@ export class Material extends EventDispatcher {
 
 	/**
 	 * Sets the alpha value to be used when running an alpha test. Default is 0.
+	 * @default 0
 	 */
 	alphaTest: number;
 
 	/**
 	 * Blending destination. It's one of the blending mode constants defined in Three.js. Default is {@link OneMinusSrcAlphaFactor}.
+	 * @default THREE.OneMinusSrcAlphaFactor
 	 */
 	blendDst: BlendingDstFactor;
 
 	/**
 	 * The tranparency of the .blendDst. Default is null.
+	 * @default null
 	 */
 	blendDstAlpha: number | null;
 
 	/**
 	 * Blending equation to use when applying blending. It's one of the constants defined in Three.js. Default is {@link AddEquation}.
+	 * @default THREE.AddEquation
 	 */
 	blendEquation: BlendingEquation;
 
 	/**
 	 * The tranparency of the .blendEquation. Default is null.
+	 * @default null
 	 */
 	blendEquationAlpha: number | null;
 
 	/**
 	 * Which blending to use when displaying objects with this material. Default is {@link NormalBlending}.
+	 * @default THREE.NormalBlending
 	 */
 	blending: Blending;
 
 	/**
 	 * Blending source. It's one of the blending mode constants defined in Three.js. Default is {@link SrcAlphaFactor}.
+	 * @default THREE.SrcAlphaFactor
 	 */
 	blendSrc: BlendingSrcFactor | BlendingDstFactor;
 
 	/**
 	 * The tranparency of the .blendSrc. Default is null.
+	 * @default null
 	 */
 	blendSrcAlpha: number | null;
 
 	/**
 	 * Changes the behavior of clipping planes so that only their intersection is clipped, rather than their union. Default is false.
+	 * @default false
 	 */
 	clipIntersection: boolean;
 
 	/**
 	 * User-defined clipping planes specified as THREE.Plane objects in world space. These planes apply to the objects this material is attached to. Points in space whose signed distance to the plane is negative are clipped (not rendered). See the WebGL / clipping /intersection example. Default is null.
+	 * @default null
 	 */
 	clippingPlanes: any;
 
 	/**
 	 * Defines whether to clip shadows according to the clipping planes specified on this material. Default is false.
+	 * @default false
 	 */
 	clipShadows: boolean;
 
 	/**
 	 * Whether to render the material's color. This can be used in conjunction with a mesh's .renderOrder property to create invisible objects that occlude other objects. Default is true.
+	 * @default true
 	 */
 	colorWrite: boolean;
 
 	/**
 	 * Custom defines to be injected into the shader. These are passed in form of an object literal, with key/value pairs. { MY_CUSTOM_DEFINE: '' , PI2: Math.PI * 2 }.
 	 * The pairs are defined in both vertex and fragment shaders. Default is undefined.
+	 * @default undefined
 	 */
-	defines: any;
+	defines: { [key: string]: any };
 
 	/**
 	 * Which depth function to use. Default is {@link LessEqualDepth}. See the depth mode constants for all possible values.
+	 * @default THREE.LessEqualDepth
 	 */
 	depthFunc: DepthModes;
 
 	/**
 	 * Whether to have depth test enabled when rendering this material. Default is true.
+	 * @default true
 	 */
 	depthTest: boolean;
 
 	/**
 	 * Whether rendering this material has any effect on the depth buffer. Default is true.
 	 * When drawing 2D overlays it can be useful to disable the depth writing in order to layer several things together without creating z-index artifacts.
+	 * @default true
 	 */
 	depthWrite: boolean;
 
 	/**
 	 * Whether the material is affected by fog. Default is true.
+	 * @default fog
 	 */
 	fog: boolean;
 
@@ -159,36 +176,43 @@ export class Material extends EventDispatcher {
 
 	/**
    * Whether rendering this material has any effect on the stencil buffer. Default is *false*.
+	 * @default false
    */
 	stencilWrite: boolean;
 
 	/**
    * The stencil comparison function to use. Default is {@link AlwaysStencilFunc}. See stencil operation constants for all possible values.
+	 * @default THREE.AlwaysStencilFunc
    */
 	stencilFunc: StencilFunc;
 
 	/**
    * The value to use when performing stencil comparisons or stencil operations. Default is *0*.
+	 * @default 0
    */
 	stencilRef: number;
 
 	/**
    * The bit mask to use when comparing against or writing to the stencil buffer. Default is *0xFF*.
+	 * @default 0xff
    */
 	stencilMask: number;
 
 	/**
    * Which stencil operation to perform when the comparison function returns false. Default is {@link KeepStencilOp}. See the stencil operation constants for all possible values.
+	 * @default THREE.KeepStencilOp
    */
 	stencilFail: StencilOp;
 
 	/**
    * Which stencil operation to perform when the comparison function returns true but the depth test fails. Default is {@link KeepStencilOp}. See the stencil operation constants for all possible values.
+	 * @default THREE.KeepStencilOp
    */
 	stencilZFail: StencilOp;
 
 	/**
    * Which stencil operation to perform when the comparison function returns true and the depth test passes. Default is {@link KeepStencilOp}. See the stencil operation constants for all possible values.
+	 * @default THREE.KeepStencilOp
    */
 	stencilZPass: StencilOp;
 
@@ -200,70 +224,83 @@ export class Material extends EventDispatcher {
 
 	/**
 	 * Material name. Default is an empty string.
+	 * @default ''
 	 */
 	name: string;
 
 	/**
 	 * Specifies that the material needs to be updated, WebGL wise. Set it to true if you made changes that need to be reflected in WebGL.
 	 * This property is automatically set to true when instancing a new material.
+	 * @default false
 	 */
 	needsUpdate: boolean;
 
 	/**
 	 * Opacity. Default is 1.
+	 * @default 1
 	 */
 	opacity: number;
 
 	/**
 	 * Whether to use polygon offset. Default is false. This corresponds to the POLYGON_OFFSET_FILL WebGL feature.
+	 * @default false
 	 */
 	polygonOffset: boolean;
 
 	/**
 	 * Sets the polygon offset factor. Default is 0.
+	 * @default 0
 	 */
 	polygonOffsetFactor: number;
 
 	/**
 	 * Sets the polygon offset units. Default is 0.
+	 * @default 0
 	 */
 	polygonOffsetUnits: number;
 
 	/**
 	 * Override the renderer's default precision for this material. Can be "highp", "mediump" or "lowp". Defaults is null.
+	 * @default null
 	 */
 	precision: 'highp' | 'mediump' | 'lowp' | null;
 
 	/**
 	 * Whether to premultiply the alpha (transparency) value. See WebGL / Materials / Transparency for an example of the difference. Default is false.
+	 * @default false
 	 */
 	premultipliedAlpha: boolean;
 
 	/**
 	 * Whether to apply dithering to the color to remove the appearance of banding. Default is false.
+	 * @default false
 	 */
 	dithering: boolean;
 
 	/**
 	 * Define whether the material is rendered with flat shading. Default is false.
+	 * @default false
 	 */
 	flatShading: boolean;
 
 	/**
 	 * Defines which of the face sides will be rendered - front, back or both.
 	 * Default is THREE.FrontSide. Other options are THREE.BackSide and THREE.DoubleSide.
+	 * @default THREE.FrontSide
 	 */
 	side: Side;
 
 	/**
 	 * Defines which of the face sides will cast shadows. Default is *null*.
 	 * If *null*, the value is opposite that of side, above.
+	 * @default null
 	 */
 	shadowSide: Side;
 
 	/**
 	 * Defines whether this material is tone mapped according to the renderer's toneMapping setting.
 	 * Default is true.
+	 * @default true
 	 */
 	toneMapped: boolean;
 
@@ -271,11 +308,13 @@ export class Material extends EventDispatcher {
 	 * Defines whether this material is transparent. This has an effect on rendering as transparent objects need special treatment and are rendered after non-transparent objects.
 	 * When set to true, the extent to which the material is transparent is controlled by setting it's .opacity property.
 	 * Default is false.
+	 * @default false
 	 */
 	transparent: boolean;
 
 	/**
 	 * Value is the string 'Material'. This shouldn't be changed, and can be used to find all objects of this type in a scene.
+	 * @default 'Material'
 	 */
 	type: string;
 
@@ -286,21 +325,25 @@ export class Material extends EventDispatcher {
 
 	/**
 	 * Defines whether vertex coloring is used. Default is false.
+	 * @default false
 	 */
 	vertexColors: boolean;
 
 	/**
 	 * Defines whether this material is visible. Default is true.
+	 * @default true
 	 */
 	visible: boolean;
 
 	/**
 	 * An object that can be used to store custom data about the Material. It should not hold references to functions as these will not be cloned.
+	 * @default {}
 	 */
 	userData: any;
 
 	/**
 	 * This starts at 0 and counts how many times .needsUpdate is set to true.
+	 * @default 0
 	 */
 	version: number;