third_party/d3/src/externs.js

/**
 * @fileoverview Definitions for the D3.js library, based on the D3 API
 * reference at https://github.com/d3/d3/blob/master/API.md
 *
 * Some definitions were dumbed down, because JSCompiler has limited support for
 * function properties, overloads and tuples. A complete list of TypeScript
 * definitions is available at
 * https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/d3
 *
 * Usage examples can be found at http://blockbuilder.org/search#d3version=v4
 *
 * @externs
 */

/**
 * @const
 * @suppress {checkTypes} Prevents a mysterious compiler error triggered by the
 *     `const` annotation:
 *     "ERROR - initializing variable"
 *     found: {Arc: None, Arc_: ..., ...}
 *     required: {active: ..., arc: ..., ...}
 *     var d3 = {};
 */
var d3 = {};

/**
 * @type {string}
 */
d3.version;

////////////////////////////////////////////////////////////////////////////////
// Arrays
// https://github.com/d3/d3-array
////////////////////////////////////////////////////////////////////////////////

// API Reference

// Statistics

/**
 * TODO(pallosp): Narrow down accessor's type when
 *     https://github.com/google/closure-compiler/issues/2052 is fixed.
 * @param {!Array} array
 * @param {?Function=} accessor
 */
d3.min = function(array, accessor) {};

/**
 * @param {!Array} array
 * @param {?Function=} accessor
 */
d3.max = function(array, accessor) {};

/**
 * @param {!Array} array
 * @param {?Function=} accessor
 */
d3.extent = function(array, accessor) {};

/**
 * @param {!Array} array
 * @param {?Function=} accessor
 * @return {number}
 */
d3.sum = function(array, accessor) {};

/**
 * @param {!Array} array
 * @param {?Function=} accessor
 * @return {number | undefined}
 */
d3.mean = function(array, accessor) {};

/**
 * @param {!Array} array
 * @param {?Function=} accessor
 * @return {number | undefined}
 */
d3.median = function(array, accessor) {};

/**
 * @param {!Array} array
 * @param {number} p
 * @param {?Function=} accessor
 * @return {number | undefined}
 */
d3.quantile = function(array, p, accessor) {};

/**
 * @param {!Array} array
 * @param {?Function=} accessor
 * @return {number | undefined}
 */
d3.variance = function(array, accessor) {};

/**
 * @param {!Array} array
 * @param {?Function=} accessor
 * @return {number | undefined}
 */
d3.deviation = function(array, accessor) {};

// Search

/**
 * @param {!Array<T>} array
 * @param {function(T, T): number=} comparator
 * @return {number}
 * @template T
 */
d3.scan = function(array, comparator) {};

/**
 * @param {!Array<T>} array
 * @param {T} x
 * @param {number=} lo
 * @param {number=} hi
 * @return {number}
 * @template T
 */
d3.bisectLeft = function(array, x, lo, hi) {};

/**
 * @param {!Array<T>} array
 * @param {T} x
 * @param {number=} lo
 * @param {number=} hi
 * @return {number}
 * @template T
 */
d3.bisect = function(array, x, lo, hi) {};

/**
 * @param {!Array<T>} array
 * @param {T} x
 * @param {number=} lo
 * @param {number=} hi
 * @return {number}
 * @template T
 */
d3.bisectRight = function(array, x, lo, hi) {};

/**
 * @param {!Function} accessorOrComparator
 * @return {{
 *   left: function(!Array, ?, number=, number=): number,
 *   right: function(!Array, ?, number=, number=): number
 * }}
 */
d3.bisector = function(accessorOrComparator) {};

/**
 * @param {?} a
 * @param {?} b
 * @return {number}
 */
d3.ascending = function(a, b) {};

/**
 * @param {?} a
 * @param {?} b
 * @return {number}
 */
d3.descending = function(a, b) {};

// Transformations

/**
 * @param {!Array<T>} a
 * @param {!Array<U>} b
 * @param {function(T, U)=} reducer
 * @return {!Array}
 * @template T, U
 */
d3.cross = function(a, b, reducer) {};

/**
 * @param {!Array<!Array<T>>} arrays
 * @return {!Array<T>}
 * @template T
 */
d3.merge = function(arrays) {};

/**
 * @param {!Array<T>} array
 * @param {function(T, T)=} reducer
 * @return {!Array<!Array>}
 * @template T
 */
d3.pairs = function(array, reducer) {};

/**
 * @param {!Object<K, V>} arrayOrMap
 * @param {!Array<K>} indexes
 * @return {!Array<V>}
 * @template K, V
 */
d3.permute = function(arrayOrMap, indexes) {};

/**
 * @param {!Array<T>} array
 * @param {number=} lo
 * @param {number=} hi
 * @return {!Array<T>}
 * @template T
 */
d3.shuffle = function(array, lo, hi) {};

/**
 * @param {number} start
 * @param {number} stop
 * @param {number} count
 * @return {!Array<number>}
 */
d3.ticks = function(start, stop, count) {};

/**
 * @param {number} start
 * @param {number} stop
 * @param {number} count
 * @return {number}
 */
d3.tickIncrement = function(start, stop, count) {};

/**
 * @param {number} start
 * @param {number} stop
 * @param {number} count
 * @return {number}
 */
d3.tickStep = function(start, stop, count) {};

/**
 * @param {number} startOrStop
 * @param {number=} stop
 * @param {number=} step
 * @return {!Array<number>}
 */
d3.range = function(startOrStop, stop, step) {};

/**
 * @param {!Array<!Array<T>>} matrix
 * @return {!Array<!Array<T>>}
 * @template T
 */
d3.transpose = function(matrix) {};

/**
 * @param {...!Array<T>} var_args
 * @return {!Array<!Array<T>>}
 * @template T
 */
d3.zip = function(var_args) {};

// Histograms

/**
 * @return {!d3.Histogram}
 */
d3.histogram = function() {};

/**
 * @typedef {function(!Array<number>): !Array<!Array<number>>}
 */
d3.Histogram;

/**
 * @private {!d3.Histogram}
 */
d3.Histogram_;

/**
 * @param {function(T, number, !Array<T>): (number | !Date)=} value
 * @template T
 */
d3.Histogram_.value = function(value) {};

/**
 * @param {!Array<number | !Date> |
 *     function(!Array): !Array<number | !Date>=} domain
 */
d3.Histogram_.domain = function(domain) {};

/**
 * @param {number | !Array<number | !Date> | function(!Array, ?, ?)=}
 *     countOrThresholds
 */
d3.Histogram_.thresholds = function(countOrThresholds) {};

// Histogram Thresholds

/**
 * @param {!Array<number>} values
 * @param {number} min
 * @param {number} max
 * @return {number}
 */
d3.thresholdFreedmanDiaconis = function(values, min, max) {};

/**
 * @param {!Array<number>} values
 * @param {number} min
 * @param {number} max
 * @return {number}
 */
d3.thresholdScott = function(values, min, max) {};

/**
 * @param {!Array<number>} values
 * @return {number}
 */
d3.thresholdSturges = function(values) {};

////////////////////////////////////////////////////////////////////////////////
// Axes
// https://github.com/d3/d3-axis
////////////////////////////////////////////////////////////////////////////////

/**
 * @param {function(?): ?} scale
 * @return {!d3.Axis}
 */
d3.axisTop = function(scale) {};

/**
 * @param {function(?): ?} scale
 * @return {!d3.Axis}
 */
d3.axisRight = function(scale) {};

/**
 * @param {function(?): ?} scale
 * @return {!d3.Axis}
 */
d3.axisBottom = function(scale) {};

/**
 * @param {function(?): ?} scale
 * @return {!d3.Axis}
 */
d3.axisLeft = function(scale) {};

/**
 * @typedef {function(!(d3.selection | d3.transition))}
 */
d3.Axis;

/**
 * @private {!d3.Axis}
 */
d3.Axis_;

/**
 * @param {function(?): ?=} scale
 */
d3.Axis_.scale = function(scale) {};

/**
 * @param {?} countOrIntervalOrAny
 * @param {...?} var_args
 * @return {!d3.Axis}
 */
d3.Axis_.ticks = function(countOrIntervalOrAny, var_args) {};

/**
 * @param {!Array=} args
 */
d3.Axis_.tickArguments = function(args) {};

/**
 * @param {?Array=} values
 */
d3.Axis_.tickValues = function(values) {};

/**
 * @param {?function(?): string=} format
 */
d3.Axis_.tickFormat = function(format) {};

/**
 * @param {number=} size
 */
d3.Axis_.tickSize = function(size) {};

/**
 * @param {number=} size
 */
d3.Axis_.tickSizeInner = function(size) {};

/**
 * @param {number=} size
 */
d3.Axis_.tickSizeOuter = function(size) {};

/**
 * @param {number=} padding
 */
d3.Axis_.tickPadding = function(padding) {};

////////////////////////////////////////////////////////////////////////////////
// Brushes
// https://github.com/d3/d3-brush
////////////////////////////////////////////////////////////////////////////////

// API Reference

/**
 * @return {!d3.Brush}
 */
d3.brush = function() {};

/**
 * @return {!d3.Brush}
 */
d3.brushX = function() {};

/**
 * @return {!d3.Brush}
 */
d3.brushY = function() {};

/**
 * @typedef {function(!d3.selection)}
 */
d3.Brush;

/**
 * @private {!d3.Brush}
 */
d3.Brush_;

/**
 * @param {!(d3.selection | d3.transition)} group
 * @param {!d3.BrushSelection |
 *     function(this:Element, T, number, !Array<T>): !d3.BrushSelection |
 *     null}
 *     selection
 * @return {void}
 * @template T
 */
d3.Brush_.move = function(group, selection) {};

/**
 * @param {!Array<!Array<number>> |
 *     function(this:Element, T, number, !Array<T>): !Array<!Array<number>>=}
 *     extent
 * @template T
 */
d3.Brush_.extent = function(extent) {};

/**
 * @param {function(this:Element, T, number, !Array<T>): boolean=} filter
 * @template T
 */
d3.Brush_.filter = function(filter) {};

/**
 * @param {number=} size
 */
d3.Brush_.handleSize = function(size) {};

/**
 * @param {string} typenames
 * @param {?function(this:Element, T, number, !Array<T>): void=} listener
 * @template T
 */
d3.Brush_.on = function(typenames, listener) {};

/**
 * @param {!Element} node
 * @return {?d3.BrushSelection}
 */
d3.brushSelection = function(node) {};

/**
 * @typedef {!Array<number> | !Array<!Array<number>>}
 */
d3.BrushSelection;

// Brush Events

/**
 * @record
 */
d3.BrushEvent = function() {};

/**
 * @type {!d3.Brush}
 */
d3.BrushEvent.prototype.target;

/**
 * @type {string}
 */
d3.BrushEvent.prototype.type;

/**
 * @type {!d3.BrushSelection}
 */
d3.BrushEvent.prototype.selection;

/**
 * @type {!Event}
 */
d3.BrushEvent.prototype.sourceEvent;

////////////////////////////////////////////////////////////////////////////////
// Chords
// https://github.com/d3/d3-chord
////////////////////////////////////////////////////////////////////////////////

// API Reference

/**
 * @record
 */
d3.ChordGroup = function() {};

/**
 * @type {number}
 */
d3.ChordGroup.prototype.startAngle;

/**
 * @type {number}
 */
d3.ChordGroup.prototype.endAngle;

/**
 * @type {number}
 */
d3.ChordGroup.prototype.value;

/**
 * @type {number}
 */
d3.ChordGroup.prototype.index;

/**
 * @record
 * @extends {d3.ChordGroup}
 */
d3.ChordSubgroup = function() {};

/**
 * @type {number}
 */
d3.ChordSubgroup.prototype.subindex;

/**
 * @record
 * @extends {IArrayLike<{source: !d3.ChordSubgroup, target: !d3.ChordSubgroup}>}
 */
d3.ChordList = function() {};

/**
 * @type {!Array<!d3.ChordGroup>}
 */
d3.ChordList.prototype.groups;

/**
 * @return {!d3.Chord}
 */
d3.chord = function() {};

/**
 * @typedef {function(!Array<!Array<number>>): !d3.ChordList}
 */
d3.Chord;

/**
 * @private {!d3.Chord}
 */
d3.Chord_;

/**
 * @param {number=} angle
 */
d3.Chord_.padAngle = function(angle) {};

/**
 * @param {?function(number, number): number=} compare
 */
d3.Chord_.sortGroups = function(compare) {};

/**
 * @param {?function(number, number): number=} compare
 */
d3.Chord_.sortSubgroups = function(compare) {};

/**
 * @param {?function(number, number): number=} compare
 */
d3.Chord_.sortChords = function(compare) {};

/**
 * @return {!d3.Ribbon}
 */
d3.ribbon = function() {};

/**
 * @typedef {function(...?)}
 */
d3.Ribbon;

/**
 * @private {!d3.Ribbon}
 */
d3.Ribbon_;

/**
 * @param {!Function=} source
 */
d3.Ribbon_.source = function(source) {};

/**
 * @param {!Function=} target
 */
d3.Ribbon_.target = function(target) {};

/**
 * @param {number | function(...?): number=} radius
 */
d3.Ribbon_.radius = function(radius) {};

/**
 * @param {number | function(...?): number=} angle
 */
d3.Ribbon_.startAngle = function(angle) {};

/**
 * @param {number | function(...?): number=} angle
 */
d3.Ribbon_.endAngle = function(angle) {};

/**
 * @param {?CanvasPathMethods=} context
 */
d3.Ribbon_.context = function(context) {};

////////////////////////////////////////////////////////////////////////////////
// Collections
// https://github.com/d3/d3-collection
////////////////////////////////////////////////////////////////////////////////

// API Reference

// Objects

/**
 * @param {!Object<?, ?>} object
 * @return {!Array<string>}
 */
d3.keys = function(object) {};

/**
 * @param {!Object<?, V>} object
 * @return {!Array<V>}
 * @template V
 */
d3.values = function(object) {};

/**
 * @param {!Object<K, V>} object
 * @return {!Array<!Object<K, V>>}
 * @template K, V
 */
d3.entries = function(object) {};

// Maps

/**
 * @param {!(d3.map<V> | Object<?, V> | Array<V>)=} object
 * @param {function(V, number): (string | number | boolean)=} keyFunction
 * @return {!d3.map<V>}
 * @constructor
 * @template V
 */
d3.map = function(object, keyFunction) {};

/**
 * @param {string | number | boolean} key
 * @return {boolean}
 */
d3.map.prototype.has = function(key) {};

/**
 * @param {string | number | boolean} key
 * @return {V | undefined}
 */
d3.map.prototype.get = function(key) {};

/**
 * @param {string | number | boolean} key
 * @param {V} value
 * @return {!d3.map<V>}
 */
d3.map.prototype.set = function(key, value) {};

/**
 * @param {string | number | boolean} key
 * @return {boolean}
 */
d3.map.prototype.remove = function(key) {};

/**
 * @return {void}
 */
d3.map.prototype.clear = function() {};

/**
 * @return {!Array<string>}
 */
d3.map.prototype.keys = function() {};

/**
 * @return {!Array<V>}
 */
d3.map.prototype.values = function() {};

/**
 * @return {!Array<{key: string, value: V}>}
 */
d3.map.prototype.entries = function() {};

/**
 * @param {function(string, V)} callback
 * @return {void}
 */
d3.map.prototype.each = function(callback) {};

/**
 * @return {boolean}
 */
d3.map.prototype.empty = function() {};

/**
 * @return {number}
 */
d3.map.prototype.size = function() {};

// Sets

/**
 * @param {!(Array | d3.set)=} arrayOrSet
 * @param {function(?, number): (string | number | boolean)=} mapper
 * @return {!d3.set}
 * @constructor
 */
d3.set = function(arrayOrSet, mapper) {};

/**
 * @param {string | number | boolean} value
 * @return {boolean}
 */
d3.set.prototype.has = function(value) {};

/**
 * @param {string | number | boolean} value
 * @return {!d3.set}
 */
d3.set.prototype.add = function(value) {};

/**
 * @param {string | number | boolean} value
 * @return {boolean}
 */
d3.set.prototype.remove = function(value) {};

/**
 * @return {void}
 */
d3.set.prototype.clear = function() {};

/**
 * @return {!Array<string>}
 */
d3.set.prototype.values = function() {};

/**
 * @param {function(string)} callback
 * @return {void}
 */
d3.set.prototype.each = function(callback) {};

/**
 * @return {boolean}
 */
d3.set.prototype.empty = function() {};

/**
 * @return {number}
 */
d3.set.prototype.size = function() {};

// Nests

/**
 * @return {!d3.Nest}
 */
d3.nest = function() {};

/**
 * @interface
 * @template T, R
 */
d3.Nest = function() {};

/**
 * @param {function(T): ?} keyFunction
 * @return {!d3.Nest}
 */
d3.Nest.prototype.key = function(keyFunction) {};

/**
 * @param {function(string, string): number} comparator
 * @return {!d3.Nest}
 */
d3.Nest.prototype.sortKeys = function(comparator) {};

/**
 * @param {function(T, T): number} comparator
 * @return {!d3.Nest}
 */
d3.Nest.prototype.sortValues = function(comparator) {};

/**
 * @param {function(!Array<T>): R} rollupFunction
 * @return {!d3.Nest}
 */
d3.Nest.prototype.rollup = function(rollupFunction) {};

/**
 * @param {!Array<T>} array
 * @return {!d3.map<!Array<T>> | !d3.map<R>}
 */
d3.Nest.prototype.map = function(array) {};

/**
 * @param {!Array<T>} array
 * @return {!Object<string, !Array<T>> | !Object<string, R>}
 */
d3.Nest.prototype.object = function(array) {};

/**
 * @param {!Array<T>} array
 * @return {!Array<{key: string, values: !Array<T>}> |
 *          !Array<{key: string, value: R}>}
 */
d3.Nest.prototype.entries = function(array) {};

////////////////////////////////////////////////////////////////////////////////
// Colors
// https://github.com/d3/d3-color
////////////////////////////////////////////////////////////////////////////////

// API Reference

/**
 * @param {string} specifier
 * @return {?d3.color}
 * @constructor
 */
d3.color = function(specifier) {};

/**
 * @type {number}
 */
d3.color.prototype.opacity;

/**
 * @return {!d3.rgb}
 */
d3.color.prototype.rgb = function() {};

/**
 * @param {number=} k
 * @return {!d3.color}
 */
d3.color.prototype.brighter = function(k) {};

/**
 * @param {number=} k
 * @return {!d3.color}
 */
d3.color.prototype.darker = function(k) {};

/**
 * @return {boolean}
 */
d3.color.prototype.displayable = function() {};

/**
 * @override
 * @return {string}
 */
d3.color.prototype.toString = function() {};

/**
 * @param {number | string | !d3.color} redOrSpecifierOrColor
 * @param {number=} green
 * @param {number=} blue
 * @param {number=} opacity
 * @return {!d3.rgb}
 * @constructor
 * @extends {d3.color}
 */
d3.rgb = function(redOrSpecifierOrColor, green, blue, opacity) {};

/**
 * @type {number}
 */
d3.rgb.prototype.r;

/**
 * @type {number}
 */
d3.rgb.prototype.g;

/**
 * @type {number}
 */
d3.rgb.prototype.b;

/**
 * @param {number | string | !d3.color} hueOrSpecifierOrColor
 * @param {number=} saturation
 * @param {number=} lightness
 * @param {number=} opacity
 * @return {!d3.hsl}
 * @constructor
 * @extends {d3.color}
 */
d3.hsl = function(hueOrSpecifierOrColor, saturation, lightness,
    opacity) {};

/**
 * @type {number}
 */
d3.hsl.prototype.h;

/**
 * @type {number}
 */
d3.hsl.prototype.s;

/**
 * @type {number}
 */
d3.hsl.prototype.l;

/**
 * @param {number | string | !d3.color} lightnessOrSpecifierOrColor
 * @param {number=} a
 * @param {number=} b
 * @param {number=} opacity
 * @return {!d3.lab}
 * @constructor
 * @extends {d3.color}
 */
d3.lab = function(lightnessOrSpecifierOrColor, a, b, opacity) {};

/**
 * @type {number}
 */
d3.lab.prototype.l;

/**
 * @type {number}
 */
d3.lab.prototype.a;

/**
 * @type {number}
 */
d3.lab.prototype.b;

/**
 * @param {number} l
 * @param {number=} opacity
 * @return {!d3.lab}
 */
d3.gray = function(l, opacity) {};

/**
 * @param {number | string | !d3.color} hueOrSpecifierOrColor
 * @param {number=} chroma
 * @param {number=} luminance
 * @param {number=} opacity
 * @return {!d3.hcl}
 * @constructor
 * @extends {d3.color}
 */
d3.hcl = function(hueOrSpecifierOrColor, chroma, luminance, opacity) {};

/**
 * @type {number}
 */
d3.hcl.prototype.h;

/**
 * @type {number}
 */
d3.hcl.prototype.c;

/**
 * @type {number}
 */
d3.hcl.prototype.l;

/**
 * @param {number | string | !d3.color} luminanceOrSpecifierOrColor
 * @param {number=} chroma
 * @param {number=} hue
 * @param {number=} opacity
 * @return {!d3.hcl}
 */
d3.lch = function(luminanceOrSpecifierOrColor, chroma, hue, opacity) {};

/**
 * @param {number | string | !d3.color} hueOrSpecifierOrColor
 * @param {number=} saturation
 * @param {number=} lightness
 * @param {number=} opacity
 * @return {!d3.cubehelix}
 * @constructor
 * @extends {d3.color}
 */
d3.cubehelix = function(hueOrSpecifierOrColor, saturation, lightness,
    opacity) {};

/**
 * @type {number}
 */
d3.cubehelix.prototype.h;

/**
 * @type {number}
 */
d3.cubehelix.prototype.s;

/**
 * @type {number}
 */
d3.cubehelix.prototype.l;

////////////////////////////////////////////////////////////////////////////////
// Contours
// https://github.com/d3/d3-contour
////////////////////////////////////////////////////////////////////////////////

/**
 * @record
 * @extends {GeoJSON.MultiPolygon}
 */
d3.ContourMultiPolygon = function() {};

/**
 * @type {number}
 */
d3.ContourMultiPolygon.prototype.value;

// API reference

/**
 * @return {!d3.Contours}
 */
d3.contours = function() {};

/**
 * @typedef {function(!Array<number>): !Array<!d3.ContourMultiPolygon>}
 */
d3.Contours;

/**
 * @private {!d3.Contours}
 */
d3.Contours_;

/**
 * @param {!Array<number>} values
 * @param {number} threshold
 * @return {!d3.ContourMultiPolygon}
 */
d3.Contours_.contour = function(values, threshold) {};

/**
 * @param {!Array<number>=} size
 * @return {?}
 */
d3.Contours_.size = function(size) {};

/**
 * @param {boolean=} smooth
 * @return {?}
 */
d3.Contours_.smooth = function(smooth) {};

/**
 * @param {!(number | Array<number> | Function)=} thresholds
 * @return {?}
 */
d3.Contours_.thresholds = function(thresholds) {};

/**
 * @return {!d3.ContourDensity}
 */
d3.contourDensity = function() {};

/**
 * @typedef {function(!Array): !Array<!d3.ContourMultiPolygon>}
 */
d3.ContourDensity;

/**
 * @private {!d3.ContourDensity}
 */
d3.ContourDensity_;

/**
 * @param {number | function(T, number, !Array<T>): number=} x
 * @return {?}
 * @template T
 */
d3.ContourDensity_.x = function(x) {};

/**
 * @param {number | function(T, number, !Array<T>): number=} y
 * @return {?}
 * @template T
 */
d3.ContourDensity_.y = function(y) {};

/**
 * @param {number | function(T, number, !Array<T>): number=} weight
 * @return {?}
 * @template T
 */
d3.ContourDensity_.weight = function(weight) {};

/**
 * @param {!Array<number>=} size
 * @return {?}
 */
d3.ContourDensity_.size = function(size) {};

/**
 * @param {number=} cellSize
 * @return {?}
 */
d3.ContourDensity_.cellSize = function(cellSize) {};

/**
 * @param {!(number | Array<number> | Function)=} thresholds
 * @return {?}
 */
d3.ContourDensity_.thresholds = function(thresholds) {};

/**
 * @param {number=} bandwidth
 * @return {?}
 */
d3.ContourDensity_.bandwidth = function(bandwidth) {};

////////////////////////////////////////////////////////////////////////////////
// Dispatches
// https://github.com/d3/d3-dispatch
////////////////////////////////////////////////////////////////////////////////

// API Reference

/**
 * @param {...string} var_args
 * @return {!d3.dispatch}
 * @constructor
 */
d3.dispatch = function(var_args) {};

/**
 * @param {string} typenames
 * @param {?Function=} listener
 */
d3.dispatch.prototype.on = function(typenames, listener) {};

/**
 * @return {!d3.dispatch}
 */
d3.dispatch.prototype.copy = function() {};

/**
 * @param {string} type
 * @param {?Object=} that
 * @param {...?} var_args
 * @return {void}
 */
d3.dispatch.prototype.call = function(type, that, var_args) {};

/**
 * @param {string} type
 * @param {?Object=} that
 * @param {!(Arguments | Array<?>)=} args
 * @return {void}
 */
d3.dispatch.prototype.apply = function(type, that, args) {};

////////////////////////////////////////////////////////////////////////////////
// Dragging
// https://github.com/d3/d3-drag
////////////////////////////////////////////////////////////////////////////////

// API Reference

/**
 * @return {!d3.Drag}
 */
d3.drag = function() {};

/**
 * @typedef {function(!d3.selection)}
 */
d3.Drag;

/**
 * @private {!d3.Drag}
 */
d3.Drag_;

/**
 * @param {!Element | function(this:Element, T, !Array<T>): !Element=}
 *     container
 * @template T
 */
d3.Drag_.container = function(container) {};

/**
 * @param {function(this:Element, T, !Array<T>): boolean=} filter
 * @template T
 */
d3.Drag_.filter = function(filter) {};

/**
 * @param {function(this:Element): boolean=} touchable
 * @return {!Function}
 */
d3.Drag_.touchable = function(touchable) {};

/**
 * @param {function(this:Element, T, !Array<T>)=} subject
 * @template T
 */
d3.Drag_.subject = function(subject) {};

/**
 * @param {number=} distance
 * @return {?} Distance (0 arguments) or this (1 argument).
 */
d3.Drag_.clickDistance = function(distance) {};

/**
 * @param {?function(this:Element, T, number, !Array<T>): void=}
 *     listener
 * @template T
 */
d3.Drag_.on = function(typenames, listener) {};

/**
 * @param {!Window} window
 * @return {void}
 */
d3.dragDisable = function(window) {};

/**
 * @param {!Window} window
 * @param {boolean=} noclick
 * @return {void}
 */
d3.dragEnable = function(window, noclick) {};

// Drag Events

/**
 * @interface
 */
d3.DragEvent = function() {};

/**
 * @type {!d3.Drag}
 */
d3.DragEvent.prototype.target;

/**
 * @type {string}
 */
d3.DragEvent.prototype.type;

/**
 * @type {?}
 */
d3.DragEvent.prototype.subject;

/**
 * @type {number}
 */
d3.DragEvent.prototype.x;

/**
 * @type {number}
 */
d3.DragEvent.prototype.y;

/**
 * @type {number}
 */
d3.DragEvent.prototype.dx;

/**
 * @type {number}
 */
d3.DragEvent.prototype.dy;

/**
 * @type {number | string}
 */
d3.DragEvent.prototype.identifier;

/**
 * @type {number}
 */
d3.DragEvent.prototype.active;

/**
 * @type {!Event}
 */
d3.DragEvent.prototype.sourceEvent;

/**
 * @param {string} typenames
 * @param {?function(this:Element, ?, number, !IArrayLike<!Element>)=}
 *     listener
 */
d3.DragEvent.prototype.on = function(typenames, listener) {};

////////////////////////////////////////////////////////////////////////////////
// Delimiter-Separated Values
// https://github.com/d3/d3-dsv
////////////////////////////////////////////////////////////////////////////////

/**
 * @constructor
 * @extends {Array}
 */
d3.DsvParseResult = function() {};

/**
 * @type {!Array<string>}
 */
d3.DsvParseResult.prototype.columns;

/**
 * @typedef {function(
 *             !Object<string, (string | undefined)>,
 *             number,
 *             !Array<string>
 *           ): ?}
 */
d3.DsvRowConverter;

// API Reference

/**
 * @param {string} string
 * @param {!d3.DsvRowConverter=} rowConverter
 * @return {!d3.DsvParseResult}
 */
d3.csvParse = function(string, rowConverter) {};

/**
 * @param {string} string
 * @param {function(!Array<string>, number)=} rowMapper
 * @return {!Array}
 */
d3.csvParseRows = function(string, rowMapper) {};

/**
 * @param {!Array<!Object>} rows
 * @param {!Array<string>=} columnsToInclude
 * @return {string}
 */
d3.csvFormat = function(rows, columnsToInclude) {};

/**
 * @param {!Array<!Array>} rows
 * @return {string}
 */
d3.csvFormatRows = function(rows) {};

/**
 * @param {string} string
 * @param {!d3.DsvRowConverter=} rowConverter
 * @return {!d3.DsvParseResult}
 */
d3.tsvParse = function(string, rowConverter) {};

/**
 * @param {string} string
 * @param {function(!Array<string>, number)=} rowMapper
 * @return {!Array}
 */
d3.tsvParseRows = function(string, rowMapper) {};

/**
 * @param {!Array<!Object>} rows
 * @param {!Array<string>=} columnsToInclude
 * @return {string}
 */
d3.tsvFormat = function(rows, columnsToInclude) {};

/**
 * @param {!Array<!Array>} rows
 * @return {string}
 */
d3.tsvFormatRows = function(rows) {};

/**
 * @param {string} delimiter
 * @return {!d3.Dsv}
 */
d3.dsvFormat = function(delimiter) {};

/**
 * @interface
 */
d3.Dsv = function() {};

/**
 * @param {string} string
 * @param {!d3.DsvRowConverter=} rowConverter
 * @return {!d3.DsvParseResult}
 */
d3.Dsv.prototype.parse = function(string, rowConverter) {};

/**
 * @param {string} string
 * @param {function(!Array<string>, number)=} rowMapper
 * @return {!Array}
 */
d3.Dsv.prototype.parseRows = function(string, rowMapper) {};

/**
 * @param {!Array<!Object>} rows
 * @param {!Array<string>=} columns
 * @return {string}
 */
d3.Dsv.prototype.format = function(rows, columns) {};

/**
 * @param {!Array<!Array>} rows
 * @return {string}
 */
d3.Dsv.prototype.formatRows = function(rows) {};

////////////////////////////////////////////////////////////////////////////////
// Easings
// https://github.com/d3/d3-ease
////////////////////////////////////////////////////////////////////////////////

// API Reference

/**
 * @param {number} t
 * @return {number}
 */
d3.easeLinear = function(t) {};

/**
 * @param {number} t
 * @return {number}
 */
d3.easePolyIn = function(t) {};

/**
 * @param {number} t
 * @return {number}
 */
d3.easePolyOut = function(t) {};

/**
 * @param {number} t
 * @return {number}
 */
d3.easePoly = function(t) {};

/**
 * @param {number} t
 * @return {number}
 */
d3.easePolyInOut = function(t) {};

/**
 * This declaration is not completely correct. It disallows the call pattern
 * d3.easePolyIn.exponent(e1).exponent(e2) which is technially valid, but not
 * very useful in practice. The alternative would be a typedef like
 * d3.ElasticEasing, but it would degrade type checking, because JSCompiler
 * doesn't understand function properties.
 *
 * @param {number} e
 * @return {function(number): number}
 */
d3.easePolyIn.exponent = function(e) {};

/**
 * @param {number} e
 * @return {function(number): number}
 */
d3.easePolyOut.exponent = function(e) {};

/**
 * @param {number} e
 * @return {function(number): number}
 */
d3.easePoly.exponent = function(e) {};

/**
 * @param {number} e
 * @return {function(number): number}
 */
d3.easePolyInOut.exponent = function(e) {};

/**
 * @param {number} t
 * @return {number}
 */
d3.easeQuadIn = function(t) {};

/**
 * @param {number} t
 * @return {number}
 */
d3.easeQuadOut = function(t) {};

/**
 * @param {number} t
 * @return {number}
 */
d3.easeQuad = function(t) {};

/**
 * @param {number} t
 * @return {number}
 */
d3.easeQuadInOut = function(t) {};

/**
 * @param {number} t
 * @return {number}
 */
d3.easeCubicIn = function(t) {};

/**
 * @param {number} t
 * @return {number}
 */
d3.easeCubicOut = function(t) {};

/**
 * @param {number} t
 * @return {number}
 */
d3.easeCubic = function(t) {};

/**
 * @param {number} t
 * @return {number}
 */
d3.easeCubicInOut = function(t) {};

/**
 * @param {number} t
 * @return {number}
 */
d3.easeSinIn = function(t) {};

/**
 * @param {number} t
 * @return {number}
 */
d3.easeSinOut = function(t) {};

/**
 * @param {number} t
 * @return {number}
 */
d3.easeSin = function(t) {};

/**
 * @param {number} t
 * @return {number}
 */
d3.easeSinInOut = function(t) {};

/**
 * @param {number} t
 * @return {number}
 */
d3.easeExpIn = function(t) {};

/**
 * @param {number} t
 * @return {number}
 */
d3.easeExpOut = function(t) {};

/**
 * @param {number} t
 * @return {number}
 */
d3.easeExp = function(t) {};

/**
 * @param {number} t
 * @return {number}
 */
d3.easeExpInOut = function(t) {};

/**
 * @param {number} t
 * @return {number}
 */
d3.easeCircleIn = function(t) {};

/**
 * @param {number} t
 * @return {number}
 */
d3.easeCircleOut = function(t) {};

/**
 * @param {number} t
 * @return {number}
 */
d3.easeCircle = function(t) {};

/**
 * @param {number} t
 * @return {number}
 */
d3.easeCircleInOut = function(t) {};

/**
 * @type {!d3.ElasticEasing}
 */
d3.easeElasticIn;

/**
 * @type {!d3.ElasticEasing}
 */
d3.easeElastic;

/**
 * @type {!d3.ElasticEasing}
 */
d3.easeElasticOut;

/**
 * @type {!d3.ElasticEasing}
 */
d3.easeElasticInOut;

/**
 * @typedef {function(number): number}
 */
d3.ElasticEasing;

/**
 * @private {!d3.ElasticEasing}
 */
d3.ElasticEasing_;

/**
 * @param {number} a
 * @return {!d3.ElasticEasing}
 */
d3.ElasticEasing_.amplitude = function(a) {};

/**
 * @param {number} p
 * @return {!d3.ElasticEasing}
 */
d3.ElasticEasing_.period = function(p) {};

/**
 * @param {number} t
 * @return {number}
 */
d3.easeBackIn = function(t) {};

/**
 * @param {number} t
 * @return {number}
 */
d3.easeBackOut = function(t) {};

/**
 * @param {number} t
 * @return {number}
 */
d3.easeBack = function(t) {};

/**
 * @param {number} t
 * @return {number}
 */
d3.easeBackInOut = function(t) {};

/**
 * @param {number} s
 * @return {function(number): number}
 */
d3.easeBackIn.overshoot = function(s) {};

/**
 * @param {number} s
 * @return {function(number): number}
 */
d3.easeBackOut.overshoot = function(s) {};

/**
 * @param {number} s
 * @return {function(number): number}
 */
d3.easeBack.overshoot = function(s) {};

/**
 * @param {number} s
 * @return {function(number): number}
 */
d3.easeBackInOut.overshoot = function(s) {};

/**
 * @param {number} t
 * @return {number}
 */
d3.easeBounceIn = function(t) {};

/**
 * @param {number} t
 * @return {number}
 */
d3.easeBounceOut = function(t) {};

/**
 * @param {number} t
 * @return {number}
 */
d3.easeBounce = function(t) {};

/**
 * @param {number} t
 * @return {number}
 */
d3.easeBounceInOut = function(t) {};

////////////////////////////////////////////////////////////////////////////////
// Fetch
// https://github.com/d3/d3-fetch
////////////////////////////////////////////////////////////////////////////////

/**
 * @param {string} url
 * @param {!RequestInit=} init
 * @return {!Promise<!Blob>}
 */
d3.blob = function(url, init) {};

/**
 * @param {string} url
 * @param {!RequestInit=} init
 * @return {!Promise<!ArrayBuffer>}
 */
d3.buffer = function(url, init) {};

/**
 * @param {string} url
 * @param {?(RequestInit | d3.DsvRowConverter)=} initOrRowConverter
 * @param {?d3.DsvRowConverter=} rowConverter
 * @return {!Promise<!d3.DsvParseResult>}
 */
d3.csv = function(url, initOrRowConverter, rowConverter) {};

/**
 * @param {string} delimiter
 * @param {string} url
 * @param {?(RequestInit | d3.DsvRowConverter)=} initOrRowConverter
 * @param {?d3.DsvRowConverter=} rowConverter
 * @return {!Promise<!d3.DsvParseResult>}
 */
d3.dsv = function(delimiter, url, initOrRowConverter, rowConverter) {};

/**
 * @param {string} url
 * @param {?RequestInit=} init
 * @return {!Promise<!Document>}
 */
d3.html = function(url, init) {};

/**
 * @param {string} url
 * @param {?Object=} init
 * @return {!Promise<!HTMLImageElement>}
 */
d3.image = function(url, init) {};

/**
 * @param {string} url
 * @param {?RequestInit=} init
 * @return {!Promise<R>}
 * @template R
 */
d3.json = function(url, init) {};

/**
 * @param {string} url
 * @param {?RequestInit=} init
 * @return {!Promise<!Document>}
 */
d3.svg = function(url, init) {};

/**
 * @param {string} url
 * @param {?RequestInit=} init
 * @return {!Promise<string>}
 */
d3.text = function(url, init) {};

/**
 * @param {string} url
 * @param {?(RequestInit | d3.DsvRowConverter)=} initOrRowConverter
 * @param {?d3.DsvRowConverter=} rowConverter
 * @return {!Promise<!d3.DsvParseResult>}
 */
d3.tsv = function(url, initOrRowConverter, rowConverter) {};

/**
 * @param {string} url
 * @param {?RequestInit=} init
 * @return {!Promise<!Document>}
 */
d3.xml = function(url, init) {};

////////////////////////////////////////////////////////////////////////////////
// Forces
// https://github.com/d3/d3-force
////////////////////////////////////////////////////////////////////////////////

// Simulation

/**
 * @param {!Array<!d3.ForceNode>=} nodes
 * @return {!d3.ForceSimulation}
 */
d3.forceSimulation = function(nodes) {};

/**
 * @interface
 */
d3.ForceSimulation = function() {};

/**
 * @return {!d3.ForceSimulation}
 */
d3.ForceSimulation.prototype.restart = function() {};

/**
 * @return {!d3.ForceSimulation}
 */
d3.ForceSimulation.prototype.stop = function() {};

/**
 * @return {void}
 */
d3.ForceSimulation.prototype.tick = function() {};

/**
 * @param {!Array<!d3.ForceNode>=} nodes
 */
d3.ForceSimulation.prototype.nodes = function(nodes) {};

/**
 * @param {number=} alpha
 */
d3.ForceSimulation.prototype.alpha = function(alpha) {};

/**
 * @param {number=} min
 */
d3.ForceSimulation.prototype.alphaMin = function(min) {};

/**
 * @param {number=} decay
 */
d3.ForceSimulation.prototype.alphaDecay = function(decay) {};

/**
 * @param {number=} target
 */
d3.ForceSimulation.prototype.alphaTarget = function(target) {};

/**
 * @param {number=} decay
 */
d3.ForceSimulation.prototype.velocityDecay = function(decay) {};

/**
 * @param {string} name
 * @param {!d3.Force=} force
 */
d3.ForceSimulation.prototype.force = function(name, force) {};

/**
 * @param {number} x
 * @param {number} y
 * @param {number=} radius
 * @return {!d3.ForceNode | undefined}
 */
d3.ForceSimulation.prototype.find = function(x, y, radius) {};

/**
 * @param {string} typenames
 * @param {?function(this:d3.ForceSimulation): void=} listener
 */
d3.ForceSimulation.prototype.on = function(typenames, listener) {};

/**
 * @record
 */
d3.ForceNode = function() {};

/**
 * @type {number | undefined}
 */
d3.ForceNode.prototype.index;

/**
 * @type {number | undefined}
 */
d3.ForceNode.prototype.x;

/**
 * @type {number | undefined}
 */
d3.ForceNode.prototype.y;

/**
 * @type {number | undefined}
 */
d3.ForceNode.prototype.vx;

/**
 * @type {number | undefined}
 */
d3.ForceNode.prototype.vy;

/**
 * @type {?number | undefined}
 */
d3.ForceNode.prototype.fx;

/**
 * @type {?number | undefined}
 */
d3.ForceNode.prototype.fy;

// Forces

/**
 * @typedef {function(number): void}
 */
d3.Force;

/**
 * @type {!d3.Force}
 */
d3.Force_;

/**
 * @param {!Array<!d3.ForceNode>} nodes
 * @return {void}
 */
d3.Force_.initialize = function(nodes) {};

// Centering

/**
 * @param {number=} x
 * @param {number=} y
 * @return {!d3.CenterForce}
 */
d3.forceCenter = function(x, y) {};

/**
 * @typedef {function(number): void}
 */
d3.CenterForce;

/**
 * @private {!d3.CenterForce}
 */
d3.CenterForce_;

/**
 * @param {!Array<!d3.ForceNode>} nodes
 * @return {void}
 */
d3.CenterForce_.initialize = function(nodes) {};

/**
 * @param {number=} x
 */
d3.CenterForce_.x = function(x) {};

/**
 * @param {number=} y
 */
d3.CenterForce_.y = function(y) {};

// Collision

/**
 * @param {number=} radius
 * @return {!d3.CollideForce}
 */
d3.forceCollide = function(radius) {};

/**
 * @typedef {function(number): void}
 */
d3.CollideForce;

/**
 * @private {!d3.CollideForce}
 */
d3.CollideForce_;

/**
 * @param {!Array<!d3.ForceNode>} nodes
 * @return {void}
 */
d3.CollideForce_.initialize = function(nodes) {};

/**
 * @param {number |
 *     function(!d3.ForceNode, number, !Array<!d3.ForceNode>): number=}
 *     radius
 * @return {!Function} Radius accessor or this.
 */
d3.CollideForce_.radius = function(radius) {};

/**
 * @param {number=} strength
 */
d3.CollideForce_.strength = function(strength) {};

/**
 * @param {number=} iterations
 */
d3.CollideForce_.iterations = function(iterations) {};

// Links

/**
 * @record
 */
d3.ForceLink = function() {};

/**
 * @type {!d3.ForceNode | string | number}
 */
d3.ForceLink.prototype.source;

/**
 * @type {!d3.ForceNode | string | number}
 */
d3.ForceLink.prototype.target;

/**
 * @type {number | undefined}
 */
d3.ForceLink.prototype.index;

/**
 * @param {!Array<!d3.ForceLink>=} links
 * @return {!d3.LinkForce}
 */
d3.forceLink = function(links) {};

/**
 * @typedef {function(number): void}
 */
d3.LinkForce;

/**
 * @private {!d3.LinkForce}
 */
d3.LinkForce_;

/**
 * @param {!Array<!d3.ForceNode>} nodes
 * @return {void}
 */
d3.LinkForce_.initialize = function(nodes) {};

/**
 * @param {!Array<!d3.ForceLink>=} links
 */
d3.LinkForce_.links = function(links) {};

/**
 * @param {function(!d3.ForceNode, number, !Array<!d3.ForceNode>): string=}
 *     id
 * @return {!Function} ID accessor or this.
 */
d3.LinkForce_.id = function(id) {};

/**
 * @param {number |
 *     function(!d3.ForceLink, number, !Array<!d3.ForceLink>): number=}
 *     distance
 * @return {!Function} Distance accessor or this.
 */
d3.LinkForce_.distance = function(distance) {};

/**
 * @param {number |
 *     function(!d3.ForceLink, number, !Array<!d3.ForceLink>): number=}
 *     strength
 * @return {!Function} Strength accessor or this.
 */
d3.LinkForce_.strength = function(strength) {};

/**
 * @param {number=} iterations
 */
d3.LinkForce_.iterations = function(iterations) {};

// Many-Body

/**
 * @return {!d3.ManyBodyForce}
 */
d3.forceManyBody = function() {};

/**
 * @typedef {function(number): void}
 */
d3.ManyBodyForce;

/**
 * @private {!d3.ManyBodyForce}
 */
d3.ManyBodyForce_;

/**
 * @param {!Array<!d3.ForceNode>} nodes
 * @return {void}
 */
d3.ManyBodyForce_.initialize = function(nodes) {};

/**
 * @param {number |
 *     function(!d3.ForceNode, number, !Array<!d3.ForceNode>): number=}
 *     strength
 * @return {!Function} Strength accessor or this.
 */
d3.ManyBodyForce_.strength = function(strength) {};

/**
 * @param {number=} theta
 */
d3.ManyBodyForce_.theta = function(theta) {};

/**
 * @param {number=} distance
 */
d3.ManyBodyForce_.distanceMin = function(distance) {};

/**
 * @param {number=} distance
 */
d3.ManyBodyForce_.distanceMax = function(distance) {};

// Positioning

/**
 * @return {!d3.XForce}
 */
d3.forceX = function() {};

/**
 * @typedef {function(number): void}
 */
d3.XForce;

/**
 * @private {!d3.XForce}
 */
d3.XForce_;

/**
 * @param {!Array<!d3.ForceNode>} nodes
 * @return {void}
 */
d3.XForce_.initialize = function(nodes) {};

/**
 * @param {number |
 *     function(!d3.ForceNode, number, !Array<!d3.ForceNode>): number=}
 *     strength
 * @return {!Function} Strength accessor or this.
 */
d3.XForce_.strength = function(strength) {};

/**
 * @param {number |
 *     function(!d3.ForceNode, number, !Array<!d3.ForceNode>): number=} x
 * @return {!Function} x accessor or this.
 */
d3.XForce_.x = function(x) {};

/**
 * @return {!d3.YForce}
 */
d3.forceY = function() {};

/**
 * @typedef {function(number): void}
 */
d3.YForce;

/**
 * @private {!d3.YForce}
 */
d3.YForce_;

/**
 * @param {!Array<!d3.ForceNode>} nodes
 * @return {void}
 */
d3.YForce_.initialize = function(nodes) {};

/**
 * @param {number |
 *     function(!d3.ForceNode, number, !Array<!d3.ForceNode>): number=}
 *     strength
 * @return {!Function} Strength accessor or this.
 */
d3.YForce_.strength = function(strength) {};

/**
 * @param {number |
 *     function(!d3.ForceNode, number, !Array<!d3.ForceNode>): number=} y
 * @return {!Function} y accessor or this.
 */
d3.YForce_.y = function(y) {};

/**
 * @param {number} radius
 * @param {number=} x
 * @param {number=} y
 * @return {!d3.RadialForce}
 */
d3.forceRadial = function(radius, x, y) {};

/**
 * @typedef {function(number): void}
 */
d3.RadialForce;

/**
 * @private {!d3.RadialForce}
 */
d3.RadialForce_;

/**
 * @param {!Array<!d3.ForceNode>} nodes
 * @return {void}
 */
d3.RadialForce_.initialize = function(nodes) {};

/**
 * @param {number |
 *     function(!d3.ForceNode, number, !Array<!d3.ForceNode>): number=}
 *     strength
 * @return {?} Strength accessor function or this.
 */
d3.RadialForce_.strength = function(strength) {};

/**
 * @param {number |
 *     function(!d3.ForceNode, number, !Array<!d3.ForceNode>): number=}
 *     radius
 * @return {?} Radius accessor function or this.
 */
d3.RadialForce_.radius = function(radius) {};

/**
 * @param {number=} x
 */
d3.RadialForce_.x = function(x) {};

/**
 * @param {number=} y
 */
d3.RadialForce_.y = function(y) {};

////////////////////////////////////////////////////////////////////////////////
// Number Formats
// https://github.com/d3/d3-format
////////////////////////////////////////////////////////////////////////////////

// API Reference

/**
 * @param {string} specifier
 * @return {function(number): string}
 */
d3.format = function(specifier) {};

/**
 * @param {string} specifier
 * @param {number} value
 * @return {function(number): string}
 */
d3.formatPrefix = function(specifier, value) {};

/**
 * @param {string} specifier
 * @return {!d3.formatSpecifier}
 * @constructor
 */
d3.formatSpecifier = function(specifier) {};

/**
 * @type {string}
 */
d3.formatSpecifier.prototype.fill;

/**
 * @type {string}
 */
d3.formatSpecifier.prototype.align;

/**
 * @type {string}
 */
d3.formatSpecifier.prototype.sign;

/**
 * @type {string}
 */
d3.formatSpecifier.prototype.symbol;

/**
 * @type {boolean}
 */
d3.formatSpecifier.prototype.zero;

/**
 * @type {number | undefined}
 */
d3.formatSpecifier.prototype.width;

/**
 * @type {boolean}
 */
d3.formatSpecifier.prototype.comma;

/**
 * @type {number | undefined}
 */
d3.formatSpecifier.prototype.precision;

/**
 * @type {string}
 */
d3.formatSpecifier.prototype.type;

/**
 * @param {number} step
 * @return {number}
 */
d3.precisionFixed = function(step) {};

/**
 * @param {number} step
 * @param {number} value
 * @return {number}
 */
d3.precisionPrefix = function(step, value) {};

/**
 * @param {number} step
 * @param {number} max
 * @return {number}
 */
d3.precisionRound = function(step, max) {};

// Locales

/**
 * @record
 */
d3.FormatLocaleDefinition = function() {};

/**
 * @type {string}
 */
d3.FormatLocaleDefinition.prototype.decimal;

/**
 * @type {string}
 */
d3.FormatLocaleDefinition.prototype.thousands;

/**
 * @type {!Array<number>}
 */
d3.FormatLocaleDefinition.prototype.grouping;

/**
 * @type {!Array<string>}
 */
d3.FormatLocaleDefinition.prototype.currency;

/**
 * @type {!Array<string> | undefined}
 */
d3.FormatLocaleDefinition.prototype.numerals;

/**
 * @type {string | undefined}
 */
d3.FormatLocaleDefinition.prototype.percent;

/**
 * @interface
 */
d3.FormatLocale = function() {};

/**
 * @param {string} specifier
 * @return {function(number): string}
 */
d3.FormatLocale.prototype.format = function(specifier) {};

/**
 * @param {string} specifier
 * @param {number} value
 * @return {function(number): string}
 */
d3.FormatLocale.prototype.formatPrefix = function(specifier, value) {};

/**
 * @param {!d3.FormatLocaleDefinition} definition
 * @return {!d3.FormatLocale}
 */
d3.formatLocale = function(definition) {};

/**
 * @param {!d3.FormatLocaleDefinition} definition
 * @return {!d3.FormatLocale}
 */
d3.formatDefaultLocale = function(definition) {};

////////////////////////////////////////////////////////////////////////////////
// Geographies
// https://github.com/d3/d3-geo
////////////////////////////////////////////////////////////////////////////////

// GeoJSON (http://geojson.org/geojson-spec.html)

/** @record */
var GeoJSON = function() {};

/** @type {string} */
GeoJSON.prototype.type;

/** @type {?GeoJSON.NamedCRS | GeoJSON.LinkedCRS | undefined} */
GeoJSON.prototype.crs;

/** @type {?Array<number> | undefined} */
GeoJSON.prototype.bbox;


/** @record */
GeoJSON.NamedCRS = function() {};

/** @type {string} */
GeoJSON.NamedCRS.prototype.type;

/** @type {{name: string}} */
GeoJSON.NamedCRS.prototype.properties;


/** @record */
GeoJSON.LinkedCRS = function() {};

/** @type {string} */
GeoJSON.LinkedCRS.prototype.type;

/** @type {{href: string, type: (string | undefined)}} */
GeoJSON.LinkedCRS.prototype.properties;


/** @record @extends {GeoJSON} */
GeoJSON.Geometry = function() {};


/** @record @extends {GeoJSON.Geometry} */
GeoJSON.Point = function() {};

/** @type {!Array<number>} */
GeoJSON.Point.prototype.coordinates;


/** @record @extends {GeoJSON.Geometry} */
GeoJSON.LineString = function() {};

/** @type {!Array<!Array<number>>} */
GeoJSON.LineString.prototype.coordinates;


/** @record @extends {GeoJSON.Geometry} */
GeoJSON.Polygon = function() {};

/** @type {!Array<!Array<!Array<number>>>} */
GeoJSON.Polygon.prototype.coordinates;


/** @record @extends {GeoJSON.Geometry} */
GeoJSON.MultiPoint = function() {};

/** @type {!Array<!Array<number>>} */
GeoJSON.MultiPoint.prototype.coordinates;


/** @record @extends {GeoJSON.Geometry} */
GeoJSON.MultiLineString = function() {};

/** @type {!Array<!Array<!Array<number>>>} */
GeoJSON.MultiLineString.prototype.coordinates;


/** @record @extends {GeoJSON.Geometry} */
GeoJSON.MultiPolygon = function() {};

/** @type {!Array<!Array<!Array<!Array<number>>>>} */
GeoJSON.MultiPolygon.prototype.coordinates;


/** @record @extends {GeoJSON.Geometry} */
GeoJSON.GeometryCollection = function() {};

/** @type {!Array<!GeoJSON.Geometry>} */
GeoJSON.GeometryCollection.prototype.geometries;


/** @record @extends {GeoJSON} */
GeoJSON.Feature = function() {};

/** @type {?GeoJSON.Geometry} */
GeoJSON.Feature.prototype.geometry;

/** @type {?Object} */
GeoJSON.Feature.prototype.properties;


/** @record @extends {GeoJSON} */
GeoJSON.FeatureCollection = function() {};

/** @type {!Array<!GeoJSON.Feature>} */
GeoJSON.FeatureCollection.prototype.features;

// Spherical Math

/**
 * [longitude in degrees, latitude in degrees]
 * @typedef {!Array<number>}
 */
d3.LngLat;

/**
 * @param {!GeoJSON.Feature} feature
 * @return {number}
 */
d3.geoArea = function(feature) {};

/**
 * @param {!GeoJSON.Feature} feature
 * @return {!Array<!d3.LngLat>}
 */
d3.geoBounds = function(feature) {};

/**
 * @param {!GeoJSON.Feature} feature
 * @return {!d3.LngLat}
 */
d3.geoCentroid = function(feature) {};

/**
 * @param {!d3.LngLat} a
 * @param {!d3.LngLat} b
 * @return {number}
 */
d3.geoDistance = function(a, b) {};

/**
 * @param {!GeoJSON.Feature} feature
 * @return {number}
 */
d3.geoLength = function(feature) {};

/**
 * @param {!d3.LngLat} a
 * @param {!d3.LngLat} b
 * @return {function(number): !d3.LngLat}
 */
d3.geoInterpolate = function(a, b) {};

/**
 * @param {!GeoJSON} object
 * @param {!d3.LngLat} point
 * @return {boolean}
 */
d3.geoContains = function(object, point) {};

/**
 * @param {!Array<number>} angles [yaw, pitch] or [yaw, pitch, roll]
 * @return {!d3.GeoRotation}
 */
d3.geoRotation = function(angles) {};

/**
 * @typedef {function(!d3.LngLat): !d3.LngLat}
 */
d3.GeoRotation;

/**
 * @private {!d3.GeoRotation}
 */
d3.GeoRotation_;

/**
 * @param {!d3.LngLat} point
 * @return {!d3.LngLat}
 */
d3.GeoRotation_.invert = function(point) {};

// Spherical Shapes

/**
 * @return {!d3.GeoCircle}
 */
d3.geoCircle = function() {};

/**
 * @typedef {function(...?): !GeoJSON.Polygon}
 */
d3.GeoCircle;

/**
 * @private {!d3.GeoCircle}
 */
d3.GeoCircle_;

/**
 * @param {!d3.LngLat | function(): !d3.LngLat=} center
 */
d3.GeoCircle_.center = function(center) {};

/**
 * @param {number | function(): number=} radius
 */
d3.GeoCircle_.radius = function(radius) {};

/**
 * @param {number | function(): number=} angle
 */
d3.GeoCircle_.precision = function(angle) {};

/**
 * @return {!d3.GeoGraticule}
 */
d3.geoGraticule = function() {};

/**
 * @typedef {function(...?): !GeoJSON.MultiLineString}
 */
d3.GeoGraticule;

/**
 * @private {!d3.GeoGraticule}
 */
d3.GeoGraticule_;

/**
 * @return {!Array<!GeoJSON.LineString>}
 */
d3.GeoGraticule_.lines = function() {};

/**
 * @return {!GeoJSON.Polygon}
 */
d3.GeoGraticule_.outline = function() {};

/**
 * @param {!Array<!d3.LngLat>=} extent
 */
d3.GeoGraticule_.extent = function(extent) {};

/**
 * @param {!Array<!d3.LngLat>=} extent
 */
d3.GeoGraticule_.extentMajor = function(extent) {};

/**
 * @param {!Array<!d3.LngLat>=} extent
 */
d3.GeoGraticule_.extentMinor = function(extent) {};

/**
 * @param {!Array<number>=} step
 */
d3.GeoGraticule_.step = function(step) {};

/**
 * @param {!Array<number>=} step
 */
d3.GeoGraticule_.stepMajor = function(step) {};

/**
 * @param {!Array<number>=} step
 */
d3.GeoGraticule_.stepMinor = function(step) {};

/**
 * @param {number=} angle
 */
d3.GeoGraticule_.precision = function(angle) {};

/**
 * @return {!GeoJSON.MultiLineString}
 */
d3.geoGraticule10 = function() {};

// Paths

/**
 * @param {?{stream: function(!d3.GeoStream): !d3.GeoStream}=} projection
 * @param {?d3.GeoPathContext=} context
 * @return {!d3.GeoPath}
 */
d3.geoPath = function(projection, context) {};

/**
 * @typedef {function(!GeoJSON, ...?): string}
 */
d3.GeoPath;

/**
 * @private {!d3.GeoPath}
 */
d3.GeoPath_;

/**
 * @param {!GeoJSON} object
 * @return {number}
 */
d3.GeoPath_.area = function(object) {};

/**
 * @param {!GeoJSON} object
 * @return {!Array<!Array<number>>}
 */
d3.GeoPath_.bounds = function(object) {};

/**
 * @param {!GeoJSON} object
 * @return {!Array<number>}
 */
d3.GeoPath_.centroid = function(object) {};

/**
 * @param {!GeoJSON} object
 * @return {number}
 */
d3.GeoPath_.measure = function(object) {};

/**
 * @param {?{stream: function(!d3.GeoStream): !d3.GeoStream}=} projection
 */
d3.GeoPath_.projection = function(projection) {};

/**
 * @param {?d3.GeoPathContext=} context
 */
d3.GeoPath_.context = function(context) {};

/**
 * @param {number | !Function=} radius
 */
d3.GeoPath_.pointRadius = function(radius) {};

/**
 * Subset of the CanvasRenderingContext2D interface.
 * @interface
 */
d3.GeoPathContext = function() {};

/**
 * @return {void}
 */
d3.GeoPathContext.prototype.beginPath = function() {};

/**
 * @param {number} x
 * @param {number} y
 * @return {void}
 */
d3.GeoPathContext.prototype.moveTo = function(x, y) {};

/**
 * @param {number} x
 * @param {number} y
 * @return {void}
 */
d3.GeoPathContext.prototype.lineTo = function(x, y) {};

/**
 * @param {number} x
 * @param {number} y
 * @param {number} radius
 * @param {number} startAngle
 * @param {number} endAngle
 * @return {void}
 */
d3.GeoPathContext.prototype.arc =
    function(x, y, radius, startAngle, endAngle) {};

/**
 * @return {void}
 */
d3.GeoPathContext.prototype.closePath = function() {};

// Projections

/**
 * @param {!d3.RawProjection} project
 * @return {!d3.GeoProjection}
 */
d3.geoProjection = function(project) {};

/**
 * @param {!Function} factory
 * @return {!Function}
 */
d3.geoProjectionMutator = function(factory) {};

/**
 * @typedef {function(!d3.LngLat): ?Array<number>}
 */
d3.GeoProjection;

/**
 * @private {!d3.GeoProjection}
 */
d3.GeoProjection_;

/**
 * @param {!Array<number>} point
 * @return {?d3.LngLat}
 */
d3.GeoProjection_.invert = function(point) {};

/**
 * @param {!d3.GeoStream} stream
 * @return {!d3.GeoStream}
 */
d3.GeoProjection_.stream = function(stream) {};

/**
 * @param {function(!d3.GeoStream): !d3.GeoStream=} preclip
 * @return {!Function}
 */
d3.GeoProjection_.preclip = function(preclip) {};

/**
 * @param {function(!d3.GeoStream): !d3.GeoStream=} postclip
 * @return {!Function}
 */
d3.GeoProjection_.postclip = function(postclip) {};

/**
 * @param {?number=} angle
 */
d3.GeoProjection_.clipAngle = function(angle) {};

/**
 * @param {?Array<!Array<number>>=} extent
 */
d3.GeoProjection_.clipExtent = function(extent) {};

/**
 * @param {number=} scale
 */
d3.GeoProjection_.scale = function(scale) {};

/**
 * @param {!Array<number>=} translate
 */
d3.GeoProjection_.translate = function(translate) {};

/**
 * @param {!d3.LngLat=} center
 */
d3.GeoProjection_.center = function(center) {};

/**
 * @param {!Array<number>=} angles
 */
d3.GeoProjection_.rotate = function(angles) {};

/**
 * @param {number=} precision
 */
d3.GeoProjection_.precision = function(precision) {};

/**
 * @param {!Array<!Array<number>>} extent
 * @param {!GeoJSON} object
 * @return {!d3.GeoProjection}
 */
d3.GeoProjection_.fitExtent = function(extent, object) {};

/**
 * @param {!Array<number>} size
 * @param {!GeoJSON} object
 * @return {!d3.GeoProjection}
 */
d3.GeoProjection_.fitSize = function(size, object) {};

/**
 * @param {number} width
 * @param {!GeoJSON} object
 * @return {!d3.GeoProjection}
 */
d3.GeoProjection_.fitWidth = function(width, object) {};

/**
 * @param {number} height
 * @param {!GeoJSON} object
 * @return {!d3.GeoProjection}
 */
d3.GeoProjection_.fitHeight = function(height, object) {};

/**
 * Only exists for conic projections.
 * @type {function(!Array<number>=) | undefined}
 */
d3.GeoProjection_.parallels;

/**
 * @return {!d3.GeoProjection}
 */
d3.geoAlbers = function() {};

/**
 * @return {!d3.GeoProjection}
 */
d3.geoAlbersUsa = function() {};

/**
 * @return {!d3.GeoProjection}
 */
d3.geoAzimuthalEqualArea = function() {};

/**
 * @return {!d3.GeoProjection}
 */
d3.geoAzimuthalEquidistant = function() {};

/**
 * @return {!d3.GeoProjection}
 */
d3.geoConicConformal = function() {};

/**
 * @return {!d3.GeoProjection}
 */
d3.geoConicEqualArea = function() {};

/**
 * @return {!d3.GeoProjection}
 */
d3.geoConicEquidistant = function() {};

/**
 * @return {!d3.GeoProjection}
 */
d3.geoEquirectangular = function() {};

/**
 * @return {!d3.GeoProjection}
 */
d3.geoGnomonic = function() {};

/**
 * @return {!d3.GeoProjection}
 */
d3.geoMercator = function() {};

/**
 * @return {!d3.GeoProjection}
 */
d3.geoOrthographic = function() {};

/**
 * @return {!d3.GeoProjection}
 */
d3.geoStereographic = function() {};

/**
 * @return {!d3.GeoProjection}
 */
d3.geoEqualEarth = function() {};

/**
 * @return {!d3.GeoProjection}
 */
d3.geoTransverseMercator = function() {};

/**
 * @return {!d3.GeoProjection}
 */
d3.geoNaturalEarth1 = function() {};

/**
 * @deprecated Use d3.geoIdentity's clipExtent instead.
 */
d3.geoClipExtent = null;

// Raw Projections

/**
 * (longitude in radians, latitude in radians) => [x, y]
 * @typedef {function(number, number): !Array<number>}
 */
d3.RawProjection;

/**
 * @private {!d3.RawProjection}
 */
d3.RawProjection_;

/**
 * @param {number} x
 * @param {number} y
 * @return {!Array<number>}
 */
d3.RawProjection_.invert = function(x, y) {};

/**
 * @type {!d3.RawProjection}
 */
d3.geoAzimuthalEqualAreaRaw;

/**
 * @type {!d3.RawProjection}
 */
d3.geoAzimuthalEquidistantRaw;

/**
 * @param {number} phi0
 * @param {number} phi1
 * @return {!d3.RawProjection}
 */
d3.geoConicConformalRaw = function(phi0, phi1) {};

/**
 * @param {number} phi0
 * @param {number} phi1
 * @return {!d3.RawProjection}
 */
d3.geoConicEqualAreaRaw = function(phi0, phi1) {};

/**
 * @param {number} phi0
 * @param {number} phi1
 * @return {!d3.RawProjection}
 */
d3.geoConicEquidistantRaw = function(phi0, phi1) {};

/**
 * @type {!d3.RawProjection}
 */
d3.geoEquirectangularRaw;

/**
 * @type {!d3.RawProjection}
 */
d3.geoGnomonicRaw;

/**
 * @type {!d3.RawProjection}
 */
d3.geoMercatorRaw;

/**
 * @type {!d3.RawProjection}
 */
d3.geoOrthographicRaw;

/**
 * @type {!d3.RawProjection}
 */
d3.geoStereographicRaw;

/**
 * @type {!d3.RawProjection}
 */
d3.geoEqualEarthRaw;

/**
 * @type {!d3.RawProjection}
 */
d3.geoTransverseMercatorRaw;

/**
 * @type {!d3.RawProjection}
 */
d3.geoNaturalEarth1Raw;

// Projection Streams

/**
 * @param {!GeoJSON} object
 * @param {!d3.GeoStream} stream
 * @return {void}
 */
d3.geoStream = function(object, stream) {};

/**
 * @record
 */
d3.GeoStream = function() {};

/**
 * @param {number} x
 * @param {number} y
 * @param {number=} z
 * @return {void}
 */
d3.GeoStream.prototype.point = function(x, y, z) {};

/**
 * @return {void}
 */
d3.GeoStream.prototype.lineStart = function() {};

/**
 * @return {void}
 */
d3.GeoStream.prototype.lineEnd = function() {};

/**
 * @return {void}
 */
d3.GeoStream.prototype.polygonStart = function() {};

/**
 * @return {void}
 */
d3.GeoStream.prototype.polygonEnd = function() {};

/**
 * @return {void}
 */
d3.GeoStream.prototype.sphere = function() {};

// Transforms

/**
 * @record
 */
d3.GeoStreamOverrides = function() {};

/**
 * @type {undefined |
 *     function(this:d3.GeoStreamOverrides, number, number, number=): void}
 */
d3.GeoStreamOverrides.prototype.point;

/**
 * @type {undefined | function(this:d3.GeoStreamOverrides): void}
 */
d3.GeoStreamOverrides.prototype.lineStart;

/**
 * @type {undefined | function(this:d3.GeoStreamOverrides): void}
 */
d3.GeoStreamOverrides.prototype.lineEnd;

/**
 * @type {undefined | function(this:d3.GeoStreamOverrides): void}
 */
d3.GeoStreamOverrides.prototype.polygonStart;

/**
 * @type {undefined | function(this:d3.GeoStreamOverrides): void}
 */
d3.GeoStreamOverrides.prototype.polygonEnd;

/**
 * @type {undefined | function(this:d3.GeoStreamOverrides): void}
 */
d3.GeoStreamOverrides.prototype.sphere;

/**
 * @type {undefined | !d3.GeoStream}
 */
d3.GeoStreamOverrides.prototype.stream;

/**
 * @param {!d3.GeoStreamOverrides} methods
 * @return {{stream: function(!d3.GeoStream): !d3.GeoStream}}
 */
d3.geoTransform = function(methods) {};

/**
 * @return {!d3.GeoIdentity}
 */
d3.geoIdentity = function() {};

/**
 * @interface
 */
d3.GeoIdentity = function() {};

/**
 * @param {number=} scale
 */
d3.GeoIdentity.prototype.scale = function(scale) {};

/**
 * @param {!Array<number>=} translate
 */
d3.GeoIdentity.prototype.translate = function(translate) {};

/**
 * @param {boolean=} reflect
 */
d3.GeoIdentity.prototype.reflectX = function(reflect) {};

/**
 * @param {boolean=} reflect
 */
d3.GeoIdentity.prototype.reflectY = function(reflect) {};

/**
 * @param {?Array<!Array<number>>=} extent
 */
d3.GeoIdentity.prototype.clipExtent = function(extent) {};

/**
 * @param {!Array<number>} size
 * @param {!GeoJSON} object
 * @return {!d3.GeoIdentity}
 */
d3.GeoIdentity.prototype.fitSize = function(size, object) {};

/**
 * @param {!Array<!Array<number>>} extent
 * @param {!GeoJSON} object
 * @return {!d3.GeoIdentity}
 */
d3.GeoIdentity.prototype.fitExtent = function(extent, object) {};

/**
 * @param {!d3.GeoStream} stream
 * @return {!d3.GeoStream}
 */
d3.GeoIdentity.prototype.stream = function(stream) {};

// Clipping

/**
 * @param {!d3.GeoStream} stream
 * @return {!d3.GeoStream}
 */
d3.geoClipAntimeridian = function(stream) {};

/**
 * @param {number} angle
 * @return {function(!d3.GeoStream): !d3.GeoStream}
 */
d3.geoClipCircle = function(angle) {};

/**
 * @param {number} x0
 * @param {number} y0
 * @param {number} x1
 * @param {number} y1
 * @return {function(!d3.GeoStream): !d3.GeoStream}
 */
d3.geoClipRectangle = function(x0, y0, x1, y1) {};

////////////////////////////////////////////////////////////////////////////////
// Hierarchy
// https://github.com/d3/d3-hierarchy
////////////////////////////////////////////////////////////////////////////////

// Hierarchy

/**
 * @param {T} data
 * @param {function(T): ?Array<T>=} children
 * @return {!d3.hierarchy<T>}
 * @constructor
 * @template T
 */
d3.hierarchy = function(data, children) {};

/**
 * @type {T}
 */
d3.hierarchy.prototype.data;

/**
 * @type {number}
 */
d3.hierarchy.prototype.depth;

/**
 * @type {number}
 */
d3.hierarchy.prototype.height;

/**
 * @type {?d3.hierarchy}
 */
d3.hierarchy.prototype.parent;

/**
 * @type {!Array<!d3.hierarchy<T>> | undefined}
 */
d3.hierarchy.prototype.children;

/**
 * @type {number | undefined}
 */
d3.hierarchy.prototype.value;

/**
 * @return {!Array<!d3.hierarchy<T>>}
 */
d3.hierarchy.prototype.ancestors = function() {};

/**
 * @return {!Array<!d3.hierarchy<T>>}
 */
d3.hierarchy.prototype.descendants = function() {};

/**
 * @return {!Array<!d3.hierarchy<T>>}
 */
d3.hierarchy.prototype.leaves = function() {};

/**
 * @param {!d3.hierarchy} target
 * @return {!Array<!d3.hierarchy<T>>}
 */
d3.hierarchy.prototype.path = function(target) {};

/**
 * @return {!Array<{source: !d3.hierarchy<T>, target: !d3.hierarchy<T>}>}
 */
d3.hierarchy.prototype.links = function() {};

/**
 * @return {!d3.hierarchy}
 */
d3.hierarchy.prototype.count = function() {};

/**
 * @param {function(T): number} value
 * @return {!d3.hierarchy}
 */
d3.hierarchy.prototype.sum = function(value) {};

/**
 * @param {function(!d3.hierarchy<T>, !d3.hierarchy<T>): number} compare
 * @return {!d3.hierarchy}
 */
d3.hierarchy.prototype.sort = function(compare) {};

/**
 * @param {function(!d3.hierarchy<T>): void} callback
 */
d3.hierarchy.prototype.each = function(callback) {};

/**
 * @param {function(!d3.hierarchy<T>): void} callback
 */
d3.hierarchy.prototype.eachAfter = function(callback) {};

/**
 * @param {function(!d3.hierarchy<T>): void} callback
 */
d3.hierarchy.prototype.eachBefore = function(callback) {};

/**
 * @return {!d3.hierarchy<T>}
 */
d3.hierarchy.prototype.copy = function() {};

// Stratify

/**
 * @return {!d3.Stratify}
 */
d3.stratify = function() {};

/**
 * @typedef {function(!Array): !d3.hierarchy}
 */
d3.Stratify;

/**
 * @private {!d3.Stratify}
 */
d3.Stratify_;

/**
 * @param {function(T, number, !Array<T>): ?(string | undefined)=} id
 * @template T
 */
d3.Stratify_.id = function(id) {};

/**
 * @param {function(T, number, !Array<T>): ?(string | undefined)=} parentId
 * @template T
 */
d3.Stratify_.parentId = function(parentId) {};

// Cluster

/**
 * @return {!d3.Cluster}
 */
d3.cluster = function() {};

/**
 * @typedef {function(!d3.hierarchy)}
 */
d3.Cluster;

/**
 * @private {!d3.Cluster}
 */
d3.Cluster_;

/**
 * @param {!Array<number>=} size
 */
d3.Cluster_.size = function(size) {};

/**
 * @param {!Array<number>=} size
 */
d3.Cluster_.nodeSize = function(size) {};

/**
 * @param {function(?, ?): number=} separation
 */
d3.Cluster_.separation = function(separation) {};

// Tree

/**
 * @return {!d3.Tree}
 */
d3.tree = function() {};

/**
 * @typedef {function(!d3.hierarchy)}
 */
d3.Tree;

/**
 * @private {!d3.Tree}
 */
d3.Tree_;

/**
 * @param {!Array<number>=} size
 */
d3.Tree_.size = function(size) {};

/**
 * @param {!Array<number>=} size
 */
d3.Tree_.nodeSize = function(size) {};

/**
 * @param {function(?, ?): number=} separation
 */
d3.Tree_.separation = function(separation) {};

// Treemap

/**
 * @return {!d3.Treemap}
 */
d3.treemap = function() {};

/**
 * @typedef {function(!d3.hierarchy)}
 */
d3.Treemap;

/**
 * @private {!d3.Treemap}
 */
d3.Treemap_;

/**
 * @param {{node: !d3.hierarchy,
 *          x0: number,
 *          y0: number,
 *          x1: number,
 *          y1: number}=} tile
 */
d3.Treemap_.tile = function(tile) {};

/**
 * @param {!Array<number>=} size
 */
d3.Treemap_.size = function(size) {};

/**
 * @param {boolean=} round
 */
d3.Treemap_.round = function(round) {};

/**
 * @param {number | function(?): number=} padding
 */
d3.Treemap_.padding = function(padding) {};

/**
 * @param {number | function(?): number=} padding
 */
d3.Treemap_.paddingInner = function(padding) {};

/**
 * @param {number | function(?): number=} padding
 */
d3.Treemap_.paddingOuter = function(padding) {};

/**
 * @param {number | function(?): number=} padding
 */
d3.Treemap_.paddingTop = function(padding) {};

/**
 * @param {number | function(?): number=} padding
 */
d3.Treemap_.paddingRight = function(padding) {};

/**
 * @param {number | function(?): number=} padding
 */
d3.Treemap_.paddingBottom = function(padding) {};

/**
 * @param {number | function(?): number=} padding
 */
d3.Treemap_.paddingLeft = function(padding) {};

// Treemap Tiling

/**
 * @param {!d3.hierarchy} node
 * @param {number} x0
 * @param {number} y0
 * @param {number} x1
 * @param {number} y1
 * @return {void}
 */
d3.treemapBinary = function(node, x0, y0, x1, y1) {};

/**
 * @param {!d3.hierarchy} node
 * @param {number} x0
 * @param {number} y0
 * @param {number} x1
 * @param {number} y1
 * @return {void}
 */
d3.treemapDice = function(node, x0, y0, x1, y1) {};

/**
 * @param {!d3.hierarchy} node
 * @param {number} x0
 * @param {number} y0
 * @param {number} x1
 * @param {number} y1
 * @return {void}
 */
d3.treemapSlice = function(node, x0, y0, x1, y1) {};

/**
 * @param {!d3.hierarchy} node
 * @param {number} x0
 * @param {number} y0
 * @param {number} x1
 * @param {number} y1
 * @return {void}
 */
d3.treemapSliceDice = function(node, x0, y0, x1, y1) {};

/**
 * @param {!d3.hierarchy} node
 * @param {number} x0
 * @param {number} y0
 * @param {number} x1
 * @param {number} y1
 * @return {void}
 */
d3.treemapSquarify = function(node, x0, y0, x1, y1) {};

/**
 * @param {number} ratio
 * @return {function(!d3.hierarchy, number, number, number, number): void}
 */
d3.treemapSquarify.ratio = function(ratio) {};

/**
 * @param {!d3.hierarchy} node
 * @param {number} x0
 * @param {number} y0
 * @param {number} x1
 * @param {number} y1
 * @return {void}
 */
d3.treemapResquarify = function(node, x0, y0, x1, y1) {};

/**
 * @param {number} ratio
 * @return {function(!d3.hierarchy, number, number, number, number)}
 */
d3.treemapResquarify.ratio = function(ratio) {};

// Partition

/**
 * @return {!d3.Partition}
 */
d3.partition = function() {};

/**
 * @typedef {function(!d3.hierarchy)}
 */
d3.Partition;

/**
 * @private {!d3.Partition}
 */
d3.Partition_;

/**
 * @param {!Array<number>=} size
 */
d3.Partition_.size = function(size) {};

/**
 * @param {boolean=} round
 */
d3.Partition_.round = function(round) {};

/**
 * @param {number=} padding
 */
d3.Partition_.padding = function(padding) {};

// Pack

/**
 * @return {!d3.Pack}
 */
d3.pack = function() {};

/**
 * @typedef {function(!d3.hierarchy)}
 */
d3.Pack;

/**
 * @private {!d3.Pack}
 */
d3.Pack_;

/**
 * @param {function(?): number=} radius
 */
d3.Pack_.radius = function(radius) {};

/**
 * @param {!Array<number>=} size
 */
d3.Pack_.size = function(size) {};

/**
 * @param {number | function(?): number=} padding
 */
d3.Pack_.padding = function(padding) {};

/**
 * @param {!Array<{r: number}>} circles
 * @return {!Array<{x: number, y: number, r: number}>}
 */
d3.packSiblings = function(circles) {};

/**
 * @param {!Array<{x: number, y: number, r: number}>} circles
 * @return {{x: number, y: number, r: number}}
 */
d3.packEnclose = function(circles) {};

////////////////////////////////////////////////////////////////////////////////
// Interpolators
// https://github.com/d3/d3-interpolate
////////////////////////////////////////////////////////////////////////////////

// API Reference

/**
 * @param {T} a
 * @param {T} b
 * @return {function(number): T}
 * @template T
 */
d3.interpolate = function(a, b) {};

/**
 * @param {number} a
 * @param {number} b
 * @return {function(number): number}
 */
d3.interpolateNumber = function(a, b) {};

/**
 * @param {number} a
 * @param {number} b
 * @return {function(number): number}
 */
d3.interpolateRound = function(a, b) {};

/**
 * @param {string} a
 * @param {string} b
 * @return {function(number): string}
 */
d3.interpolateString = function(a, b) {};

/**
 * @param {number | !Date} a
 * @param {number | !Date} b
 * @return {function(number): !Date}
 */
d3.interpolateDate = function(a, b) {};

/**
 * @param {!Array<T>} a
 * @param {!Array<T>} b
 * @return {function(number): !Array<T>}
 * @template T
 */
d3.interpolateArray = function(a, b) {};

/**
 * @param {!Object} a
 * @param {!Object} b
 * @return {function(number): !Object}
 */
d3.interpolateObject = function(a, b) {};

/**
 * @param {string} a
 * @param {string} b
 * @return {function(number): string}
 */
d3.interpolateTransformCss = function(a, b) {};

/**
 * @param {string} a
 * @param {string} b
 * @return {function(number): string}
 */
d3.interpolateTransformSvg = function(a, b) {};

/**
 * @param {!Array<number>} a
 * @param {!Array<number>} b
 * @return {function(number): !Array<number>}
 */
d3.interpolateZoom = function(a, b) {};

/**
 * @param {!Array<T>} values
 * @return {function(number): T}
 * @template T
 */
d3.interpolateDiscrete = function(values) {};

// Sampling

/**
 * @param {function(number): T} interpolator
 * @param {number} n
 * @return {!Array<T>}
 * @template T
 */
d3.quantize = function(interpolator, n) {};

// Color Spaces

/**
 * @param {string | !d3.color} a
 * @param {string | !d3.color} b
 * @return {function(number): string}
 */
d3.interpolateRgb = function(a, b) {};

/**
 * @param {number} gamma
 * @return {function((string | !d3.color), (string | !d3.color)):
 *     function(number): string}
 */
d3.interpolateRgb.gamma = function(gamma) {};

/**
 * @param {!Array<string | !d3.color>} colors
 * @return {function(number): string}
 */
d3.interpolateRgbBasis = function(colors) {};

/**
 * @param {!Array<string | !d3.color>} colors
 * @return {function(number): string}
 */
d3.interpolateRgbBasisClosed = function(colors) {};

/**
 * @param {string | !d3.color} a
 * @param {string | !d3.color} b
 * @return {function(number): string}
 */
d3.interpolateHsl = function(a, b) {};

/**
 * @param {string | !d3.color} a
 * @param {string | !d3.color} b
 * @return {function(number): string}
 */
d3.interpolateHslLong = function(a, b) {};

/**
 * @param {string | !d3.color} a
 * @param {string | !d3.color} b
 * @return {function(number): string}
 */
d3.interpolateLab = function(a, b) {};

/**
 * @param {string | !d3.color} a
 * @param {string | !d3.color} b
 * @return {function(number): string}
 */
d3.interpolateHcl = function(a, b) {};

/**
 * @param {string | !d3.color} a
 * @param {string | !d3.color} b
 * @return {function(number): string}
 */
d3.interpolateHclLong = function(a, b) {};

/**
 * @param {string | !d3.color} a
 * @param {string | !d3.color} b
 * @return {function(number): string}
 */
d3.interpolateCubehelix = function(a, b) {};

/**
 * @param {number} gamma
 * @return {function((string | !d3.color), (string | !d3.color)):
 *     function(number): string}
 */
d3.interpolateCubehelix.gamma = function(gamma) {};

/**
 * @param {string | !d3.color} a
 * @param {string | !d3.color} b
 * @return {function(number): string}
 */
d3.interpolateCubehelixLong = function(a, b) {};

/**
 * @param {number} gamma
 * @return {function((string | !d3.color), (string | !d3.color)):
 *     function(number): string}
 */
d3.interpolateCubehelixLong.gamma = function(gamma) {};

/**
 * @param {number} a
 * @param {number} b
 * @return {function(number): number}
 */
d3.interpolateHue = function(a, b) {};

// Splines

/**
 * @param {!Array<number>} values
 * @return {function(number): number}
 */
d3.interpolateBasis = function(values) {};

/**
 * @param {!Array<number>} values
 * @return {function(number): number}
 */
d3.interpolateBasisClosed = function(values) {};

// Piecewise

/**
 * @param {function(T, T): function(number): T} interpolate
 * @param {!Array<T>} values
 * @return {function(number): T}
 * @template T
 */
d3.piecewise = function(interpolate, values) {};

////////////////////////////////////////////////////////////////////////////////
// Paths
// https://github.com/d3/d3-path
////////////////////////////////////////////////////////////////////////////////

// API Reference

/**
 * @constructor
 * @return {!d3.path}
 */
d3.path = function() {};

/**
 * @param {number} x
 * @param {number} y
 * @return {void}
 */
d3.path.prototype.moveTo = function(x, y) {};

/**
 * @return {void}
 */
d3.path.prototype.closePath = function() {};

/**
 * @param {number} x
 * @param {number} y
 * @return {void}
 */
d3.path.prototype.lineTo = function(x, y) {};

/**
 * @param {number} cpx
 * @param {number} cpy
 * @param {number} x
 * @param {number} y
 * @return {void}
 */
d3.path.prototype.quadraticCurveTo = function(cpx, cpy, x, y) {};

/**
 * @param {number} cpx1
 * @param {number} cpy1
 * @param {number} cpx2
 * @param {number} cpy2
 * @param {number} x
 * @param {number} y
 * @return {void}
 */
d3.path.prototype.bezierCurveTo = function(cpx1, cpy1, cpx2, cpy2, x, y) {};

/**
 * @param {number} x1
 * @param {number} y1
 * @param {number} x2
 * @param {number} y2
 * @param {number} radius
 * @return {void}
 */
d3.path.prototype.arcTo = function(x1, y1, x2, y2, radius) {};

/**
 * @param {number} x
 * @param {number} y
 * @param {number} radius
 * @param {number} startAngle
 * @param {number} endAngle
 * @param {boolean=} anticlockwise
 * @return {void}
 */
d3.path.prototype.arc = function(x, y, radius, startAngle, endAngle,
    anticlockwise) {};

/**
 * @param {number} x
 * @param {number} y
 * @param {number} w
 * @param {number} h
 * @return {void}
 */
d3.path.prototype.rect = function(x, y, w, h) {};

/**
 * @override
 * @return {string}
 */
d3.path.prototype.toString = function() {};

////////////////////////////////////////////////////////////////////////////////
// Polygons
// https://github.com/d3/d3-polygon
////////////////////////////////////////////////////////////////////////////////

// API Reference

/**
 * @param {!Array<!Array<number>>} polygon
 * @return {number}
 */
d3.polygonArea = function(polygon) {};

/**
 * @param {!Array<!Array<number>>} polygon
 * @return {!Array<number>}
 */
d3.polygonCentroid = function(polygon) {};

/**
 * @param {!Array<!Array<number>>} points
 * @return {?Array<!Array<number>>}
 */
d3.polygonHull = function(points) {};

/**
 * @param {!Array<!Array<number>>} polygon
 * @param {!Array<number>} point
 * @return {boolean}
 */
d3.polygonContains = function(polygon, point) {};

/**
 * @param {!Array<!Array<number>>} polygon
 * @return {number}
 */
d3.polygonLength = function(polygon) {};

////////////////////////////////////////////////////////////////////////////////
// Quadtrees
// https://github.com/d3/d3-quadtree
////////////////////////////////////////////////////////////////////////////////

// API Reference

/**
 * @param {!Array<T>=} data
 * @param {function(T): number=} x
 * @param {function(T): number=} y
 * @constructor
 * @return {!d3.quadtree<T>}
 * @template T
 */
d3.quadtree = function(data, x, y) {};

/**
 * @param {function(T): number=} x
 */
d3.quadtree.prototype.x = function(x) {};

/**
 * @param {function(T): number=} y
 */
d3.quadtree.prototype.y = function(y) {};

/**
 * @param {!Array<!Array<number>>=} extent
 */
d3.quadtree.prototype.extent = function(extent) {};

/**
 * @param {number} x
 * @param {number} y
 * @return {!d3.quadtree<T>}
 */
d3.quadtree.prototype.cover = function(x, y) {};

/**
 * @param {T} datum
 * @return {!d3.quadtree<T>}
 */
d3.quadtree.prototype.add = function(datum) {};

/**
 * @param {!Array<T>} data
 * @return {!d3.quadtree<T>}
 */
d3.quadtree.prototype.addAll = function(data) {};

/**
 * @param {T} datum
 * @return {!d3.quadtree<T>}
 */
d3.quadtree.prototype.remove = function(datum) {};

/**
 * @param {!Array<T>} data
 * @return {!d3.quadtree<T>}
 */
d3.quadtree.prototype.removeAll = function(data) {};

/**
 * @return {!d3.quadtree<T>}
 */
d3.quadtree.prototype.copy = function() {};

/**
 * @return {!d3.QuadtreeNode | undefined}
 */
d3.quadtree.prototype.root = function() {};

/**
 * @return {!Array<T>}
 */
d3.quadtree.prototype.data = function() {};

/**
 * @return {number}
 */
d3.quadtree.prototype.size = function() {};

/**
 * @param {number} x
 * @param {number} y
 * @param {number=} radius
 * @return {T | undefined}
 */
d3.quadtree.prototype.find = function(x, y, radius) {};

/**
 * @param {function(!d3.QuadtreeNode, number, number, number, number):
 *     (boolean | undefined)} callback
 */
d3.quadtree.prototype.visit = function(callback) {};

/**
 * @param {function(!d3.QuadtreeNode, number, number, number, number): void}
 *     callback
 */
d3.quadtree.prototype.visitAfter = function(callback) {};

// Nodes

/**
 * @record
 */
d3.QuadtreeLeaf = function() {};

/**
 * @type {?}
 */
d3.QuadtreeLeaf.prototype.data;

/**
 * @type {!d3.QuadtreeLeaf | undefined}
 */
d3.QuadtreeLeaf.prototype.next;

/**
 * JSCompiler doesn't support recursive typedefs, therefore we use Object
 * instead of (!d3.QuadtreeNode | !d3.QuadtreeLeaf) for child nodes.
 * @typedef {!d3.QuadtreeLeaf | !Array<!Object | undefined>}
 */
d3.QuadtreeNode;

////////////////////////////////////////////////////////////////////////////////
// Random Numbers
// https://github.com/d3/d3-random
////////////////////////////////////////////////////////////////////////////////

// API Reference

/**
 * @param {number=} minOrMax
 * @param {number=} max
 * @return {function(): number}
 */
d3.randomUniform = function(minOrMax, max) {};

/**
 * @param {function(): number} source
 * @return {function(number=, number=): function(): number}
 */
d3.randomUniform.source = function(source) {};

/**
 * @param {number=} mu
 * @param {number=} sigma
 * @return {function(): number}
 */
d3.randomNormal = function(mu, sigma) {};

/**
 * @param {function(): number} source
 * @return {function(number=, number=): function(): number}
 */
d3.randomNormal.source = function(source) {};

/**
 * @param {number=} mu
 * @param {number=} sigma
 * @return {function(): number}
 */
d3.randomLogNormal = function(mu, sigma) {};

/**
 * @param {function(): number} source
 * @return {function(number=, number=): function(): number}
 */
d3.randomLogNormal.source = function(source) {};

/**
 * @param {number} n
 * @return {function(): number}
 */
d3.randomBates = function(n) {};

/**
 * @param {function(): number} source
 * @return {function(number): function(): number}
 */
d3.randomBates.source = function(source) {};

/**
 * @param {number} n
 * @return {function(): number}
 */
d3.randomIrwinHall = function(n) {};

/**
 * @param {function(): number} source
 * @return {function(number): function(): number}
 */
d3.randomIrwinHall.source = function(source) {};

/**
 * @param {number} lambda
 * @return {function(): number}
 */
d3.randomExponential = function(lambda) {};

/**
 * @param {function(): number} source
 * @return {function(number): function(): number}
 */
d3.randomExponential.source = function(source) {};

////////////////////////////////////////////////////////////////////////////////
// Scales
// https://github.com/d3/d3-scale
////////////////////////////////////////////////////////////////////////////////

// Linear Scales

/**
 * @return {!d3.LinearScale}
 */
d3.scaleLinear = function() {};

/**
 * Besides numbers, continuous scales also support RGB string ranges.
 * @typedef {function(number): ?}
 */
d3.LinearScale;

/**
 * @private {!d3.LinearScale}
 */
d3.LinearScale_;

/**
 * @param {number} value
 * @return {number}
 */
d3.LinearScale_.invert = function(value) {};

/**
 * @param {!Array<number>=} domain
 */
d3.LinearScale_.domain = function(domain) {};

/**
 * @param {!(Array<number> | Array<string>)=} range
 */
d3.LinearScale_.range = function(range) {};

/**
 * @param {!Array<number>=} range
 */
d3.LinearScale_.rangeRound = function(range) {};

/**
 * @param {boolean=} clamp
 */
d3.LinearScale_.clamp = function(clamp) {};

/**
 * @param {function(?, ?): function(number)=} interpolate
 */
d3.LinearScale_.interpolate = function(interpolate) {};

/**
 * @param {number=} count
 * @return {!Array<number>}
 */
d3.LinearScale_.ticks = function(count) {};

/**
 * @param {number=} count
 * @param {string=} specifier
 * @return {function(number): string}
 */
d3.LinearScale_.tickFormat = function(count, specifier) {};

/**
 * @param {number=} count
 * @return {!d3.LinearScale}
 */
d3.LinearScale_.nice = function(count) {};

/**
 * @return {!d3.LinearScale}
 */
d3.LinearScale_.copy = function() {};

// Power Scales

/**
 * @return {!d3.PowScale}
 */
d3.scalePow = function() {};

/**
 * @typedef {function(number): ?}
 */
d3.PowScale;

/**
 * @private {!d3.PowScale}
 */
d3.PowScale_;

/**
 * @param {number} value
 * @return {number}
 */
d3.PowScale_.invert = function(value) {};

/**
 * @param {number=} exponent
 */
d3.PowScale_.exponent = function(exponent) {};

/**
 * @param {!Array<number>=} domain
 */
d3.PowScale_.domain = function(domain) {};

/**
 * @param {!(Array<number> | Array<string>)=} range
 */
d3.PowScale_.range = function(range) {};

/**
 * @param {!Array<number>=} range
 */
d3.PowScale_.rangeRound = function(range) {};

/**
 * @param {boolean=} clamp
 */
d3.PowScale_.clamp = function(clamp) {};

/**
 * @param {function(?, ?): function(number)=} interpolate
 */
d3.PowScale_.interpolate = function(interpolate) {};

/**
 * @param {number=} count
 * @return {!Array<number>}
 */
d3.PowScale_.ticks = function(count) {};

/**
 * @param {number=} count
 * @param {string=} specifier
 * @return {function(number): string}
 */
d3.PowScale_.tickFormat = function(count, specifier) {};

/**
 * @param {number=} count
 * @return {!d3.PowScale}
 */
d3.PowScale_.nice = function(count) {};

/**
 * @return {!d3.PowScale}
 */
d3.PowScale_.copy = function() {};

/**
 * @return {!d3.PowScale}
 */
d3.scaleSqrt = function() {};

// Log Scales

/**
 * @return {!d3.LogScale}
 */
d3.scaleLog = function() {};

/**
 * @typedef {function(number): ?}
 */
d3.LogScale;

/**
 * @private {!d3.LogScale}
 */
d3.LogScale_;

/**
 * @param {number} value
 * @return {number}
 */
d3.LogScale_.invert = function(value) {};

/**
 * @param {number=} base
 */
d3.LogScale_.base = function(base) {};

/**
 * @param {!Array<number>=} domain
 */
d3.LogScale_.domain = function(domain) {};

/**
 * @param {!(Array<number> | Array<string>)=} range
 */
d3.LogScale_.range = function(range) {};

/**
 * @param {!Array<number>=} range
 */
d3.LogScale_.rangeRound = function(range) {};

/**
 * @param {boolean=} clamp
 */
d3.LogScale_.clamp = function(clamp) {};

/**
 * @param {function(?, ?): function(number)=} interpolate
 */
d3.LogScale_.interpolate = function(interpolate) {};

/**
 * @param {number=} count
 * @return {!Array<number>}
 */
d3.LogScale_.ticks = function(count) {};

/**
 * @param {number=} count
 * @param {string=} specifier
 * @return {function(number): string}
 */
d3.LogScale_.tickFormat = function(count, specifier) {};

/**
 * @param {number=} count
 * @return {!d3.LogScale}
 */
d3.LogScale_.nice = function(count) {};

/**
 * @return {!d3.LogScale}
 */
d3.LogScale_.copy = function() {};

// Identity Scales

/**
 * @return {!d3.IdentityScale}
 */
d3.scaleIdentity = function() {};

/**
 * @typedef {function(number): number}
 */
d3.IdentityScale;

/**
 * @private {!d3.IdentityScale}
 */
d3.IdentityScale_;

/**
 * @param {number} value
 * @return {number}
 */
d3.IdentityScale_.invert = function(value) {};

/**
 * @param {!Array<number>=} domain
 */
d3.IdentityScale_.domain = function(domain) {};

/**
 * @param {!Array<number>=} range
 */
d3.IdentityScale_.range = function(range) {};

/**
 * @param {number=} count
 * @return {!Array<number>}
 */
d3.IdentityScale_.ticks = function(count) {};

/**
 * @param {number=} count
 * @param {string=} specifier
 * @return {function(number): string}
 */
d3.IdentityScale_.tickFormat = function(count, specifier) {};

/**
 * @param {number=} count
 * @return {!d3.IdentityScale}
 */
d3.IdentityScale_.nice = function(count) {};

/**
 * @return {!d3.IdentityScale}
 */
d3.IdentityScale_.copy = function() {};

// Time Scales

/**
 * @return {!d3.TimeScale}
 */
d3.scaleTime = function() {};

/**
 * @typedef {function((number | !Date)): ?}
 */
d3.TimeScale;

/**
 * @private {!d3.TimeScale}
 */
d3.TimeScale_;

/**
 * @param {number} value
 * @return {!Date}
 */
d3.TimeScale_.invert = function(value) {};

/**
 * @param {!Array<!Date>=} domain
 */
d3.TimeScale_.domain = function(domain) {};

/**
 * @param {!(Array<number> | Array<string>)=} range
 */
d3.TimeScale_.range = function(range) {};

/**
 * @param {!Array<number>=} range
 */
d3.TimeScale_.rangeRound = function(range) {};

/**
 * @param {boolean=} clamp
 */
d3.TimeScale_.clamp = function(clamp) {};

/**
 * @param {function(?, ?): function(number)=} interpolate
 */
d3.TimeScale_.interpolate = function(interpolate) {};

/**
 * @param {number | ?d3.Interval=} countOrInterval
 * @return {!Array<!Date>}
 */
d3.TimeScale_.ticks = function(countOrInterval) {};

/**
 * @param {?number | d3.Interval=} countOrInterval
 * @param {string=} specifier
 * @return {function(!Date): string}
 */
d3.TimeScale_.tickFormat = function(countOrInterval, specifier) {};

/**
 * @param {?number | d3.Interval=} countOrInterval
 * @param {number=} step
 */
d3.TimeScale_.nice = function(countOrInterval, step) {};

/**
 * @return {!d3.TimeScale}
 */
d3.TimeScale_.copy = function() {};

/**
 * @return {!d3.TimeScale}
 */
d3.scaleUtc = function() {};

// Sequential Scales

/**
 * @param {function(number): ?} interpolator
 * @return {!d3.SequentialScale}
 */
d3.scaleSequential = function(interpolator) {};

/**
 * @typedef {function(number): ?}
 */
d3.SequentialScale;

/**
 * @private {!d3.SequentialScale}
 */
d3.SequentialScale_;

/**
 * @param {!Array<number>=} domain
 */
d3.SequentialScale_.domain = function(domain) {};

/**
 * @param {boolean=} clamp
 */
d3.SequentialScale_.clamp = function(clamp) {};

/**
 * @param {function(number)=} interpolator
 */
d3.SequentialScale_.interpolator = function(interpolator) {};

/**
 * @return {!d3.SequentialScale}
 */
d3.SequentialScale_.copy = function() {};

// Diverging scales

/**
 * @param {?} interpolator
 * @return {!d3.DivergingScale}
 */
d3.scaleDiverging = function(interpolator) {};

/**
 * @typedef {function(number): ?}
 */
d3.DivergingScale;

/**
 * @private {!d3.DivergingScale}
 */
d3.DivergingScale_;

/**
 * @param {!Array<number>=} domain Exactly 3 values
 * @return {?}
 */
d3.DivergingScale_.domain = function(domain) {};

/**
 * @param {boolean=} clamp
 * @return {?}
 */
d3.DivergingScale_.clamp = function(clamp) {};

/**
 * @param {!Function=} interpolator
 * @return {?}
 */
d3.DivergingScale_.interpolator = function(interpolator) {};

/**
 * @return {!d3.DivergingScale}
 */
d3.DivergingScale_.copy = function() {};

// Quantize Scales

/**
 * @return {!d3.QuantizeScale}
 */
d3.scaleQuantize = function() {};

/**
 * @typedef {function(number): ?}
 */
d3.QuantizeScale;

/**
 * @private {!d3.QuantizeScale}
 */
d3.QuantizeScale_;

/**
 * @param {?} value
 * @return {!Array<number>}
 */
d3.QuantizeScale_.invertExtent = function(value) {};

/**
 * @param {!Array<number>=} domain
 */
d3.QuantizeScale_.domain = function(domain) {};

/**
 * @param {!Array=} range
 */
d3.QuantizeScale_.range = function(range) {};

/**
 * @param {number=} count
 * @return {!Array<number>}
 */
d3.QuantizeScale_.ticks = function(count) {};

/**
 * @param {number=} count
 * @param {string=} specifier
 * @return {function(number): string}
 */
d3.QuantizeScale_.tickFormat = function(count, specifier) {};

/**
 * @param {number=} count
 * @return {!d3.QuantizeScale}
 */
d3.QuantizeScale_.nice = function(count) {};

/**
 * @return {!d3.QuantizeScale}
 */
d3.QuantizeScale_.copy = function() {};

// Quantile Scales

/**
 * @return {!d3.QuantileScale}
 */
d3.scaleQuantile = function() {};

/**
 * @typedef {function(number): ?}
 */
d3.QuantileScale;

/**
 * @private {!d3.QuantileScale}
 */
d3.QuantileScale_;

/**
 * @param {?} value
 * @return {!Array<number>}
 */
d3.QuantileScale_.invertExtent = function(value) {};

/**
 * @param {!Array<number>=} domain
 */
d3.QuantileScale_.domain = function(domain) {};

/**
 * @param {!Array=} range
 */
d3.QuantileScale_.range = function(range) {};

/**
 * @return {!Array<number>}
 */
d3.QuantileScale_.quantiles = function() {};

/**
 * @return {!d3.QuantileScale}
 */
d3.QuantileScale_.copy = function() {};

// Threshold Scales

/**
 * @return {!d3.ThresholdScale}
 */
d3.scaleThreshold = function() {};

/**
 * @typedef {function((number | string)): ?}
 */
d3.ThresholdScale;

/**
 * @private {!d3.ThresholdScale}
 */
d3.ThresholdScale_;

/**
 * @param {?} value
 * @return {!Array}
 */
d3.ThresholdScale_.invertExtent = function(value) {};

/**
 * @param {!Array=} domain
 */
d3.ThresholdScale_.domain = function(domain) {};

/**
 * @param {!Array=} range
 */
d3.ThresholdScale_.range = function(range) {};

/**
 * @return {!d3.ThresholdScale}
 */
d3.ThresholdScale_.copy = function() {};

// Ordinal Scales

/**
 * @param {!Array<?>=} range
 * @return {!d3.OrdinalScale}
 */
d3.scaleOrdinal = function(range) {};

/**
 * @typedef {function((string | number)): ?}
 */
d3.OrdinalScale;

/**
 * @private {!d3.OrdinalScale}
 */
d3.OrdinalScale_;

/**
 * @param {!(Array<string> | Array<number>)=} domain
 */
d3.OrdinalScale_.domain = function(domain) {};

/**
 * @param {!Array=} range
 */
d3.OrdinalScale_.range = function(range) {};

/**
 * @param {?=} value
 */
d3.OrdinalScale_.unknown = function(value) {};

/**
 * @return {!d3.OrdinalScale}
 */
d3.OrdinalScale_.copy = function() {};

/**
 * @type {{name: string}}
 */
d3.scaleImplicit;

// Band Scales

/**
 * @return {!d3.BandScale}
 */
d3.scaleBand = function() {};

/**
 * @typedef {function(string): number}
 */
d3.BandScale;

/**
 * @private {!d3.BandScale}
 */
d3.BandScale_;

/**
 * @param {!(Array<string> | Array<number>)=} domain
 */
d3.BandScale_.domain = function(domain) {};

/**
 * @param {!Array<number>=} range
 */
d3.BandScale_.range = function(range) {};

/**
 * @param {!Array<number>=} range
 */
d3.BandScale_.rangeRound = function(range) {};

/**
 * @param {boolean=} round
 */
d3.BandScale_.round = function(round) {};

/**
 * @param {number=} padding
 */
d3.BandScale_.paddingInner = function(padding) {};

/**
 * @param {number=} padding
 */
d3.BandScale_.paddingOuter = function(padding) {};

/**
 * @param {number=} padding
 */
d3.BandScale_.padding = function(padding) {};

/**
 * @param {number=} align
 */
d3.BandScale_.align = function(align) {};

/**
 * @return {number}
 */
d3.BandScale_.bandwidth = function() {};

/**
 * @return {number}
 */
d3.BandScale_.step = function() {};

/**
 * @return {!d3.BandScale}
 */
d3.BandScale_.copy = function() {};

// Point Scales

/**
 * @return {!d3.PointScale}
 */
d3.scalePoint = function() {};

/**
 * @typedef {function(string): number}
 */
d3.PointScale;

/**
 * @private {!d3.PointScale}
 */
d3.PointScale_;

/**
 * @param {!(Array<string> | Array<number>)=} domain
 */
d3.PointScale_.domain = function(domain) {};

/**
 * @param {!Array<number>=} range
 */
d3.PointScale_.range = function(range) {};

/**
 * @param {!Array<number>=} range
 */
d3.PointScale_.rangeRound = function(range) {};

/**
 * @param {boolean=} round
 */
d3.PointScale_.round = function(round) {};

/**
 * @param {number=} padding
 */
d3.PointScale_.padding = function(padding) {};

/**
 * @param {number=} align
 */
d3.PointScale_.align = function(align) {};

/**
 * @return {number}
 */
d3.PointScale_.bandwidth = function() {};

/**
 * @return {number}
 */
d3.PointScale_.step = function() {};

/**
 * @return {!d3.PointScale}
 */
d3.PointScale_.copy = function() {};

////////////////////////////////////////////////////////////////////////////////
// Sequential, diverging and categorical color scales.
// https://github.com/d3/d3-scale-chromatic
////////////////////////////////////////////////////////////////////////////////

// Categorical

/**
 * @const {!Array<string>}
 */
d3.schemeCategory10;

/**
 * @const {!Array<string>}
 */
d3.schemeCategory20;

/**
 * @const {!Array<string>}
 */
d3.schemeCategory20b;

/**
 * @const {!Array<string>}
 */
d3.schemeCategory20c;

/**
 * @const {!Array<string>}
 */
d3.schemeAccent;

/**
 * @const {!Array<string>}
 */
d3.schemeDark2;

/**
 * @const {!Array<string>}
 */
d3.schemePaired;

/**
 * @const {!Array<string>}
 */
d3.schemePastel1;

/**
 * @const {!Array<string>}
 */
d3.schemePastel2;

/**
 * @const {!Array<string>}
 */
d3.schemeSet1;

/**
 * @const {!Array<string>}
 */
d3.schemeSet2;

/**
 * @const {!Array<string>}
 */
d3.schemeSet3;

// Diverging

/**
 * @param {number} t 0..1
 * @return {string}
 */
d3.interpolateBrBG = function(t) {};

/**
 * @const {!Array<!Array<string>>}
 */
d3.schemeBrBG;

/**
 * @param {number} t 0..1
 * @return {string}
 */
d3.interpolatePRGn = function(t) {};

/**
 * @const {!Array<!Array<string>>}
 */
d3.schemePRGn;

/**
 * @param {number} t 0..1
 * @return {string}
 */
d3.interpolatePiYG = function(t) {};

/**
 * @const {!Array<!Array<string>>}
 */
d3.schemePiYG;

/**
 * @param {number} t 0..1
 * @return {string}
 */
d3.interpolatePuOr = function(t) {};

/**
 * @const {!Array<!Array<string>>}
 */
d3.schemePuOr;

/**
 * @param {number} t 0..1
 * @return {string}
 */
d3.interpolateRdBu = function(t) {};

/**
 * @const {!Array<!Array<string>>}
 */
d3.schemeRdBu;

/**
 * @param {number} t 0..1
 * @return {string}
 */
d3.interpolateRdGy = function(t) {};

/**
 * @const {!Array<!Array<string>>}
 */
d3.schemeRdGy;

/**
 * @param {number} t 0..1
 * @return {string}
 */
d3.interpolateRdYlBu = function(t) {};

/**
 * @const {!Array<!Array<string>>}
 */
d3.schemeRdYlBu;

/**
 * @param {number} t 0..1
 * @return {string}
 */
d3.interpolateRdYlGn = function(t) {};

/**
 * @const {!Array<!Array<string>>}
 */
d3.schemeRdYlGn;

/**
 * @param {number} t 0..1
 * @return {string}
 */
d3.interpolateSpectral = function(t) {};

/**
 * @const {!Array<!Array<string>>}
 */
d3.schemeSpectral;

// Sequential

/**
 * @param {number} t 0..1
 * @return {string}
 */
d3.interpolateBlues = function(t) {};

/**
 * @const {!Array<!Array<string>>}
 */
d3.schemeBlues;

/**
 * @param {number} t 0..1
 * @return {string}
 */
d3.interpolateGreens = function(t) {};

/**
 * @const {!Array<!Array<string>>}
 */
d3.schemeGreens;

/**
 * @param {number} t 0..1
 * @return {string}
 */
d3.interpolateGreys = function(t) {};

/**
 * @const {!Array<!Array<string>>}
 */
d3.schemeGreys;

/**
 * @param {number} t 0..1
 * @return {string}
 */
d3.interpolateOranges = function(t) {};

/**
 * @const {!Array<!Array<string>>}
 */
d3.schemeOranges;

/**
 * @param {number} t 0..1
 * @return {string}
 */
d3.interpolatePurples = function(t) {};

/**
 * @const {!Array<!Array<string>>}
 */
d3.schemePurples;

/**
 * @param {number} t 0..1
 * @return {string}
 */
d3.interpolateReds = function(t) {};

/**
 * @const {!Array<!Array<string>>}
 */
d3.schemeReds;

// Sequential (Multi-Hue)

/**
 * @param {number} t 0..1
 * @return {string}
 */
d3.interpolateViridis = function(t) {};

/**
 * @param {number} t 0..1
 * @return {string}
 */
d3.interpolateInferno = function(t) {};

/**
 * @param {number} t 0..1
 * @return {string}
 */
d3.interpolateMagma = function(t) {};

/**
 * @param {number} t 0..1
 * @return {string}
 */
d3.interpolatePlasma = function(t) {};

/**
 * @param {number} t 0..1
 * @return {string}
 */
d3.interpolateWarm = function(t) {};

/**
 * @param {number} t 0..1
 * @return {string}
 */
d3.interpolateCool = function(t) {};

/**
 * @param {number} t 0..1
 * @return {string}
 */
d3.interpolateCubehelixDefault = function(t) {};

/**
 * @param {number} t 0..1
 * @return {string}
 */
d3.interpolateBuGn = function(t) {};

/**
 * @const {!Array<!Array<string>>}
 */
d3.schemeBuGn;

/**
 * @param {number} t 0..1
 * @return {string}
 */
d3.interpolateBuPu = function(t) {};

/**
 * @const {!Array<!Array<string>>}
 */
d3.schemeBuPu;

/**
 * @param {number} t 0..1
 * @return {string}
 */
d3.interpolateGnBu = function(t) {};

/**
 * @const {!Array<!Array<string>>}
 */
d3.schemeGnBu;

/**
 * @param {number} t 0..1
 * @return {string}
 */
d3.interpolateOrRd = function(t) {};

/**
 * @const {!Array<!Array<string>>}
 */
d3.schemeOrRd;

/**
 * @param {number} t 0..1
 * @return {string}
 */
d3.interpolatePuBuGn = function(t) {};

/**
 * @const {!Array<!Array<string>>}
 */
d3.schemePuBuGn;

/**
 * @param {number} t 0..1
 * @return {string}
 */
d3.interpolatePuBu = function(t) {};

/**
 * @const {!Array<!Array<string>>}
 */
d3.schemePuBu;

/**
 * @param {number} t 0..1
 * @return {string}
 */
d3.interpolatePuRd = function(t) {};

/**
 * @const {!Array<!Array<string>>}
 */
d3.schemePuRd;

/**
 * @param {number} t 0..1
 * @return {string}
 */
d3.interpolateRdPu = function(t) {};

/**
 * @const {!Array<!Array<string>>}
 */
d3.schemeRdPu;

/**
 * @param {number} t 0..1
 * @return {string}
 */
d3.interpolateYlGnBu = function(t) {};

/**
 * @const {!Array<!Array<string>>}
 */
d3.schemeYlGnBu;

/**
 * @param {number} t 0..1
 * @return {string}
 */
d3.interpolateYlGn = function(t) {};

/**
 * @const {!Array<!Array<string>>}
 */
d3.schemeYlGn;

/**
 * @param {number} t 0..1
 * @return {string}
 */
d3.interpolateYlOrBr = function(t) {};

/**
 * @const {!Array<!Array<string>>}
 */
d3.schemeYlOrBr;

/**
 * @param {number} t 0..1
 * @return {string}
 */
d3.interpolateYlOrRd = function(t) {};

/**
 * @const {!Array<!Array<string>>}
 */
d3.schemeYlOrRd;

// Cyclical

/**
 * @param {number} t 0..1
 * @return {string}
 */
d3.interpolateRainbow = function(t) {};

/**
 * @param {number} t 0..1
 * @return {string}
 */
d3.interpolateSinebow = function(t) {};
////////////////////////////////////////////////////////////////////////////////
// Selections
// https://github.com/d3/d3-selection
////////////////////////////////////////////////////////////////////////////////

// API Reference

// Selecting Elements

// According to https://github.com/d3/d3-selection/issues/103 d3.selection has
// limited support for non-element item types. Although the following examples
// work
//
//   var s = d3.select(window).on('resize', function() { ... });
//   var s = d3.select('p').append(() => document.createTextNode('foo'));
//
// most method calls such as s.attr('foo') or s.select('p') throw an Error.
//
// The declarations below try to stay on the safe side, therefore they only
// accept elements. To select a text node or a window, cast it first to {?}.

/**
 * @return {!d3.selection}
 * @constructor
 */
d3.selection = function() {};

/**
 * @param {?string | Element | Window} selector
 *     WARNING: d3.select(window) doesn't return a fully functional selection.
 *     Registering event listeners with on() and setting properties with
 *     property() work, but most methods throw an Error or silently fail.
 * @return {!d3.selection}
 */
d3.select = function(selector) {};

/**
 * @param {?string | Array<!Element> | NodeList<!Element>} selector
 * @return {!d3.selection}
 */
d3.selectAll = function(selector) {};

/**
 * @param {?string | function(this:Element): ?Element} selector
 * @return {!d3.selection}
 */
d3.selection.prototype.select = function(selector) {};

/**
 * @param {?string | function(this:Element): !IArrayLike<!Element>} selector
 * @return {!d3.selection}
 */
d3.selection.prototype.selectAll = function(selector) {};

/**
 * @param {string |
 *     function(this:Element, ?, number, !IArrayLike<!Element>): boolean} filter
 * @return {!d3.selection}
 */
d3.selection.prototype.filter = function(filter) {};

/**
 * @param {!d3.selection} other
 * @return {!d3.selection}
 */
d3.selection.prototype.merge = function(other) {};

/**
 * @param {string} selector
 * @return {function(this:Element): boolean}
 */
d3.matcher = function(selector) {};

/**
 * @param {string} selector
 * @return {function(this:Element): ?Element}
 */
d3.selector = function(selector) {};

/**
 * @param {string} selector
 * @return {function(this:Element): !IArrayLike<!Element>}
 */
d3.selectorAll = function(selector) {};

/**
 * @param {!(Node | Document | Window)} node
 * @return {!Window}
 */
d3.window = function(node) {};

/**
 * @param {!Element} node
 * @param {string} name
 * @return {string}
 */
d3.style = function(node, name) {};

// Modifying Elements

/**
 * @param {string} name
 * @param {?string | number | boolean | d3.local |
 *     function(this:Element, ?, number, !IArrayLike<!Element>):
 *         ?(string | number | boolean)=} value
 */
d3.selection.prototype.attr = function(name, value) {};

/**
 * @param {string} names Space separated CSS class names.
 * @param {boolean |
 *     function(this:Element, ?, number, !IArrayLike<!Element>): boolean=}
 *     value
 */
d3.selection.prototype.classed = function(names, value) {};

/**
 * @param {string} name
 * @param {?string | number |
 *    function(this:Element, ?, number, !IArrayLike<!Element>):
 *        ?(string | number)=} value
 * @param {?string=} priority
 * @return {?} Style value (1 argument) or this (2+ arguments)
 */
d3.selection.prototype.style = function(name, value, priority) {};

/**
 * @param {string | !d3.local} name
 * @param {* | function(this:Element, ?, number, !IArrayLike<!Element>)=}
 *     value
 */
d3.selection.prototype.property = function(name, value) {};

/**
 * @param {?string |
 *     function(this:Element, ?, number, !IArrayLike<!Element>): ?string=}
 *     value
 */
d3.selection.prototype.text = function(value) {};

/**
 * @param {?string |
 *     function(this:Element, ?, number, !IArrayLike<!Element>): ?string=}
 *     value
 */
d3.selection.prototype.html = function(value) {};

/**
 * @param {string |
 *     function(this:Element, ?, number, !IArrayLike<!Element>): !Element} type
 * @return {!d3.selection}
 */
d3.selection.prototype.append = function(type) {};

/**
 * @param {string |
 *     function(this:Element, ?, number, !IArrayLike<!Element>): !Element} type
 * @param {?string |
 *     function(this:Element, ?, number, !IArrayLike<!Element>): ?Element=}
 *     before
 * @return {!d3.selection}
 */
d3.selection.prototype.insert = function(type, before) {};

/**
 * @return {!d3.selection}
 */
d3.selection.prototype.remove = function() {};

/**
 * @param {boolean=} deep
 * @return {!d3.selection}
 */
d3.selection.prototype.clone = function(deep) {};

/**
 * @param {function(?, ?): number} compare
 * @return {!d3.selection}
 */
d3.selection.prototype.sort = function(compare) {};

/**
 * @return {!d3.selection}
 */
d3.selection.prototype.order = function() {};

/**
 * @return {!d3.selection}
 */
d3.selection.prototype.raise = function() {};

/**
 * @return {!d3.selection}
 */
d3.selection.prototype.lower = function() {};

/**
 * @param {string} name
 * @return {!d3.selection}
 */
d3.create = function(name) {};

/**
 * @param {string} name
 * @return {function(this:Element): !Element}
 */
d3.creator = function(name) {};

// Joining Data

/**
 * @param {!Array |
 *     function(this:Element, ?, number, !IArrayLike<!Element>): !Array=}
 *     data
 * @param {function(this:Element, ?, number, !IArrayLike)=} key
 */
d3.selection.prototype.data = function(data, key) {};

/**
 * @return {!d3.selection}
 */
d3.selection.prototype.enter = function() {};

/**
 * @return {!d3.selection}
 */
d3.selection.prototype.exit = function() {};

/**
 * @param {* | function(this:Element, ?, number, !IArrayLike<!Element>)=}
 *     value
 * @return {?}
 */
d3.selection.prototype.datum = function(value) {};

// Handling Events

/**
 * @param {string} typenames
 * @param {?function(this:Element, ?, number, !IArrayLike<!Element>)=}
 *     listener
 * @param {boolean=} capture
 * @return {?} d3.selection (2+ arguments), listener function (1 argument) or
 *     undefined (1 argument).
 */
d3.selection.prototype.on = function(typenames, listener, capture) {};

/**
 * @record
 */
d3.EventParameters = function() {};

/**
 * @type {boolean | undefined}
 */
d3.EventParameters.prototype.bubbles;

/**
 * @type {boolean | undefined}
 */
d3.EventParameters.prototype.cancelable;

/**
 * @type {*}
 */
d3.EventParameters.prototype.detail;

/**
 * @param {string} type
 * @param {!d3.EventParameters |
 *     function(this:Element, ?, number, !NodeList<!Element>):
 *         !d3.EventParameters=} parameters
 */
d3.selection.prototype.dispatch = function(type, parameters) {};

/**
 * @type {?Event |
 *     {type: string, target: ?, sourceEvent: ?{type: string, target: ?}}}
 */
d3.event;

/**
 * @param {{type: string, target: ?}} event
 * @param {function(this:T, ...?): R} listener
 * @param {T=} that
 * @param {?Array | Arguments=} args
 * @return {R}
 * @template T, R
 */
d3.customEvent = function(event, listener, that, args) {};

/**
 * @param {!Element} container
 * @param {!Event} event Mouse, touch or gesture event with clientX and clientY
 *     properties.
 * @return {!Array<number>}
 */
d3.clientPoint = function(container, event) {};

/**
 * @param {!Element} container
 * @return {!Array<number>}
 */
d3.mouse = function(container) {};

/**
 * @param {!Element} container
 * @param {!TouchList | string} touchesOrIdentifier
 * @param {string=} identifier
 * @return {?Array<!Array<number>>}
 */
d3.touch = function(container, touchesOrIdentifier, identifier) {};

/**
 * @param {!Element} container
 * @param {!TouchList=} touches
 * @return {!Array<!Array<number>>}
 */
d3.touches = function(container, touches) {};

// Control Flow

/**
 * @param {function(this:Element, ?, number, !IArrayLike<!Element>)} callback
 * @return {!d3.selection}
 */
d3.selection.prototype.each = function(callback) {};

/**
 * @param {!Function} callback
 * @param {...?} var_args
 */
d3.selection.prototype.call = function(callback, var_args) {};

/**
 * @return {boolean}
 */
d3.selection.prototype.empty = function() {};

/**
 * @return {!Array<!Element>}
 */
d3.selection.prototype.nodes = function() {};

/**
 * @return {?Element}
 */
d3.selection.prototype.node = function() {};

/**
 * @return {number}
 */
d3.selection.prototype.size = function() {};

// Local Variables

/**
 * @return {!d3.local}
 * @constructor
 * @template T
 */
d3.local = function() {};

/**
 * @param {!Element} node
 * @param {T} value
 * @return {!Element}
 */
d3.local.prototype.set = function(node, value) {};

/**
 * @param {!Element} node
 * @return {T | undefined} value
 */
d3.local.prototype.get = function(node) {};

/**
 * @param {!Element} node
 * @return {boolean}
 */
d3.local.prototype.remove = function(node) {};

/**
 * @override
 * @return {string}
 */
d3.local.prototype.toString = function() {};

// Namespaces

/**
 * @param {string} name
 * @return {{local: string, space: string} | string}
 */
d3.namespace = function(name) {};

/**
 * @type {{
 *   svg: string,
 *   xhtml: string,
 *   xlink: string,
 *   xml: string,
 *   xmlns: string
 * }}
 */
d3.namespaces;

////////////////////////////////////////////////////////////////////////////////
// Shapes
// https://github.com/d3/d3-shape
////////////////////////////////////////////////////////////////////////////////

// API Reference

// Arcs

/**
 * @return {!d3.Arc}
 */
d3.arc = function() {};

/**
 * @typedef {function(...?)}
 */
d3.Arc;

/**
 * @private {!d3.Arc}
 */
d3.Arc_;

/**
 * @param {...?} var_args
 * @return {!Array<number>}
 */
d3.Arc_.centroid = function(var_args) {};

/**
 * @param {number | function(...?): number=} radius
 */
d3.Arc_.innerRadius = function(radius) {};

/**
 * @param {number | function(...?): number=} radius
 */
d3.Arc_.outerRadius = function(radius) {};

/**
 * @param {number | function(...?): number=} radius
 */
d3.Arc_.cornerRadius = function(radius) {};

/**
 * @param {number | function(...?): number=} angle
 */
d3.Arc_.startAngle = function(angle) {};

/**
 * @param {number | function(...?): number=} angle
 */
d3.Arc_.endAngle = function(angle) {};

/**
 * @param {number | function(...?): number=} angle
 */
d3.Arc_.padAngle = function(angle) {};

/**
 * @param {number | function(...?): number=} radius
 */
d3.Arc_.padRadius = function(radius) {};

/**
 * @param {?CanvasPathMethods=} context
 */
d3.Arc_.context = function(context) {};

// Pies

/**
 * @return {!d3.Pie}
 */
d3.pie = function() {};

/**
 * @typedef {function(!Array, ...?): !Array<{
 *   data: ?,
 *   value: number,
 *   index: number,
 *   startAngle: number,
 *   endAngle: number,
 *   padAngle: number
 * }>}
 */
d3.Pie;

/**
 * @private {!d3.Pie}
 */
d3.Pie_;

/**
 * @param {number | function(T, number, !Array<T>): number=} value
 * @template T
 */
d3.Pie_.value = function(value) {};

/**
 * @param {?function(?, ?): number=} compare
 */
d3.Pie_.sort = function(compare) {};

/**
 * @param {?function(?, ?): number=} compare
 */
d3.Pie_.sortValues = function(compare) {};

/**
 * @param {number | function(!Array, ...?): number=} angle
 */
d3.Pie_.startAngle = function(angle) {};

/**
 * @param {number | function(!Array, ...?): number=} angle
 */
d3.Pie_.endAngle = function(angle) {};

/**
 * @param {number | function(!Array, ...?): number=} angle
 */
d3.Pie_.padAngle = function(angle) {};

// Lines

/**
 * @return {!d3.Line}
 */
d3.line = function() {};

/**
 * @typedef {function(!Array)}
 */
d3.Line;

/**
 * @private {!d3.Line}
 */
d3.Line_;

/**
 * @param {number | function(T, number, !Array<T>): number=} x
 * @template T
 */
d3.Line_.x = function(x) {};

/**
 * @param {number | function(T, number, !Array<T>): number=} y
 * @template T
 */
d3.Line_.y = function(y) {};

/**
 * @param {boolean | function(T, number, !Array<T>): boolean=} defined
 * @template T
 */
d3.Line_.defined = function(defined) {};

/**
 * @param {function(!CanvasPathMethods): !d3.Curve=} curve
 */
d3.Line_.curve = function(curve) {};

/**
 * @param {?CanvasPathMethods=} context
 */
d3.Line_.context = function(context) {};

/**
 * @return {!d3.RadialLine}
 * @deprecated Use d3.lineRadial
 */
d3.radialLine = function() {};

/**
 * @return {!d3.RadialLine}
 */
d3.lineRadial = function() {};

/**
 * @typedef {function(!Array)}
 */
d3.RadialLine;

/**
 * @private {!d3.RadialLine}
 */
d3.RadialLine_;

/**
 * @param {number | function(T, number, !Array<T>): number=} angle
 * @template T
 */
d3.RadialLine_.angle = function(angle) {};

/**
 * @param {number | function(T, number, !Array<T>): number=} radius
 * @template T
 */
d3.RadialLine_.radius = function(radius) {};

/**
 * @param {boolean | function(T, number, !Array<T>): boolean=} defined
 * @template T
 */
d3.RadialLine_.defined = function(defined) {};

/**
 * @param {function(!CanvasPathMethods): !d3.Curve=} curve
 */
d3.RadialLine_.curve = function(curve) {};

/**
 * @param {?CanvasPathMethods=} context
 */
d3.RadialLine_.context = function(context) {};

// Areas

/**
 * @return {!d3.Area}
 */
d3.area = function() {};

/**
 * @typedef {function(!Array)}
 */
d3.Area;

/**
 * @private {!d3.Area}
 */
d3.Area_;

/**
 * @param {number | function(T, number, !Array<T>): number=} x
 * @template T
 */
d3.Area_.x = function(x) {};

/**
 * @param {number | function(T, number, !Array<T>): number=} x
 * @template T
 */
d3.Area_.x0 = function(x) {};

/**
 * @param {number | function(T, number, !Array<T>): number=} x
 * @template T
 */
d3.Area_.x1 = function(x) {};

/**
 * @param {number | function(T, number, !Array<T>): number=} y
 * @template T
 */
d3.Area_.y = function(y) {};

/**
 * @param {number | function(T, number, !Array<T>): number=} y
 * @template T
 */
d3.Area_.y0 = function(y) {};

/**
 * @param {number | function(T, number, !Array<T>): number=} y
 * @template T
 */
d3.Area_.y1 = function(y) {};

/**
 * @param {boolean | function(T, number, !Array<T>): boolean=} defined
 * @template T
 */
d3.Area_.defined = function(defined) {};

/**
 * @param {function(!CanvasPathMethods): !d3.Curve2d=} curve
 */
d3.Area_.curve = function(curve) {};

/**
 * @param {?CanvasPathMethods=} context
 */
d3.Area_.context = function(context) {};

/**
 * @return {!d3.Line}
 */
d3.Area_.lineX0 = function() {};

/**
 * @return {!d3.Line}
 */
d3.Area_.lineY0 = function() {};

/**
 * @return {!d3.Line}
 */
d3.Area_.lineX1 = function() {};

/**
 * @return {!d3.Line}
 */
d3.Area_.lineY1 = function() {};

/**
 * @return {!d3.RadialArea}
 */
d3.areaRadial = function() {};

/**
 * @return {!d3.RadialArea}
 * @deprecated Use d3.areaRadial
 */
d3.radialArea = function() {};

/**
 * @typedef {function(!Array)}
 */
d3.RadialArea;

/**
 * @private {!d3.RadialArea}
 */
d3.RadialArea_;

/**
 * @param {number | function(!Array, ...?): number=} angle
 */
d3.RadialArea_.angle = function(angle) {};

/**
 * @param {number | function(!Array, ...?): number=} angle
 */
d3.RadialArea_.startAngle = function(angle) {};

/**
 * @param {number | function(!Array, ...?): number=} angle
 */
d3.RadialArea_.endAngle = function(angle) {};

/**
 * @param {number | function(!Array, ...?): number=} radius
 */
d3.RadialArea_.radius = function(radius) {};

/**
 * @param {number | function(!Array, ...?): number=} radius
 */
d3.RadialArea_.innerRadius = function(radius) {};

/**
 * @param {number | function(!Array, ...?): number=} radius
 */
d3.RadialArea_.outerRadius = function(radius) {};

/**
 * @param {boolean | function(T, number, !Array<T>): boolean=} defined
 * @template T
 */
d3.RadialArea_.defined = function(defined) {};

/**
 * @param {function(!CanvasPathMethods): !d3.Curve2d=} curve
 */
d3.RadialArea_.curve = function(curve) {};

/**
 * @param {?CanvasPathMethods=} context
 */
d3.RadialArea_.context = function(context) {};

/**
 * @return {!d3.RadialLine}
 */
d3.RadialArea_.lineStartAngle = function() {};

/**
 * @return {!d3.RadialLine}
 */
d3.RadialArea_.lineInnerRadius = function() {};

/**
 * @return {!d3.RadialLine}
 */
d3.RadialArea_.lineEndAngle = function() {};

/**
 * @return {!d3.RadialLine}
 */
d3.RadialArea_.lineOuterRadius = function() {};

// Curves

/**
 * @param {!CanvasPathMethods} context
 * @return {!d3.Curve2d}
 */
d3.curveBasis = function(context) {};

/**
 * @param {!CanvasPathMethods} context
 * @return {!d3.Curve2d}
 */
d3.curveBasisClosed = function(context) {};

/**
 * @param {!CanvasPathMethods} context
 * @return {!d3.Curve2d}
 */
d3.curveBasisOpen = function(context) {};

/**
 * @param {!CanvasPathMethods} context
 * @return {!d3.Curve}
 */
d3.curveBundle = function(context) {};

/**
 * @param {number} beta
 * @return {function(!CanvasPathMethods): !d3.Curve}
 */
d3.curveBundle.beta = function(beta) {};

/**
 * @param {!CanvasPathMethods} context
 * @return {!d3.Curve2d}
 */
d3.curveCardinal = function(context) {};

/**
 * @param {number} tension
 * @return {function(!CanvasPathMethods): !d3.Curve2d}
 */
d3.curveCardinal.tension = function(tension) {};

/**
 * @param {!CanvasPathMethods} context
 * @return {!d3.Curve2d}
 */
d3.curveCardinalClosed = function(context) {};

/**
 * @param {number} tension
 * @return {function(!Object): !d3.Curve2d}
 */
d3.curveCardinalClosed.tension = function(tension) {};

/**
 * @param {!CanvasPathMethods} context
 * @return {!d3.Curve2d}
 */
d3.curveCardinalOpen = function(context) {};

/**
 * @param {number} tension
 * @return {function(!CanvasPathMethods): !d3.Curve2d}
 */
d3.curveCardinalOpen.tension = function(tension) {};

/**
 * @param {!CanvasPathMethods} context
 * @return {!d3.Curve2d}
 */
d3.curveCatmullRom = function(context) {};

/**
 * @param {number} alpha
 * @return {function(!CanvasPathMethods): !d3.Curve2d}
 */
d3.curveCatmullRom.alpha = function(alpha) {};

/**
 * @param {!CanvasPathMethods} context
 * @return {!d3.Curve2d}
 */
d3.curveCatmullRomClosed = function(context) {};

/**
 * @param {number} alpha
 * @return {function(!Object): !d3.Curve2d}
 */
d3.curveCatmullRomClosed.alpha = function(alpha) {};

/**
 * @param {!CanvasPathMethods} context
 * @return {!d3.Curve2d}
 */
d3.curveCatmullRomOpen = function(context) {};

/**
 * @param {number} alpha
 * @return {function(!CanvasPathMethods): !d3.Curve2d}
 */
d3.curveCatmullRomOpen.alpha = function(alpha) {};

/**
 * @param {!CanvasPathMethods} context
 * @return {!d3.Curve2d}
 */
d3.curveLinear = function(context) {};

/**
 * @param {!CanvasPathMethods} context
 * @return {!d3.Curve2d}
 */
d3.curveLinearClosed = function(context) {};

/**
 * @param {!CanvasPathMethods} context
 * @return {!d3.Curve2d}
 */
d3.curveMonotoneX = function(context) {};

/**
 * @param {!CanvasPathMethods} context
 * @return {!d3.Curve2d}
 */
d3.curveMonotoneY = function(context) {};

/**
 * @param {!CanvasPathMethods} context
 * @return {!d3.Curve2d}
 */
d3.curveNatural = function(context) {};

/**
 * @param {!CanvasPathMethods} context
 * @return {!d3.Curve2d}
 */
d3.curveStep = function(context) {};

/**
 * @param {!CanvasPathMethods} context
 * @return {!d3.Curve2d}
 */
d3.curveStepAfter = function(context) {};

/**
 * @param {!CanvasPathMethods} context
 * @return {!d3.Curve2d}
 */
d3.curveStepBefore = function(context) {};

// Custom Curves

/**
 * @interface
 */
d3.Curve = function() {};

/**
 * @return {void}
 */
d3.Curve.prototype.lineStart = function() {};

/**
 * @return {void}
 */
d3.Curve.prototype.lineEnd = function() {};

/**
 * @param {number} x
 * @param {number} y
 * @return {void}
 */
d3.Curve.prototype.point = function(x, y) {};

/**
 * @interface
 * @extends {d3.Curve}
 */
d3.Curve2d = function() {};

/**
 * @return {void}
 */
d3.Curve2d.prototype.areaStart = function() {};

/**
 * @return {void}
 */
d3.Curve2d.prototype.areaEnd = function() {};

// Links

/**
 * @return {!d3.LinkShape}
 */
d3.linkHorizontal = function() {};

/**
 * @return {!d3.LinkShape}
 */
d3.linkVertical = function() {};

/**
 * @typedef {function(...?)}
 */
d3.LinkShape;

/**
 * @private {!d3.LinkShape}
 */
d3.LinkShape_;

/**
 * @param {!Function=} source
 * @return {!Function} Source accessor (0 arguments) or this (1 argument).
 */
d3.LinkShape_.source = function(source) {};

/**
 * @param {!Function=} target
 * @return {!Function} Target accessor (0 arguments) or this (1 argument).
 */
d3.LinkShape_.target = function(target) {};

/**
 * @param {!Function=} x
 * @return {!Function} x-accessor (0 arguments) or this (1 argument).
 */
d3.LinkShape_.x = function(x) {};

/**
 * @param {!Function=} y
 * @return {!Function} y-accessor (0 arguments) or this (1 argument).
 */
d3.LinkShape_.y = function(y) {};

/**
 * @param {?CanvasPathMethods=} context
 * @return {?} Context (0 arguments) or this (1 argument).
 */
d3.LinkShape_.context = function(context) {};

/**
 * @return {!d3.RadialLink}
 */
d3.linkRadial = function() {};

/**
 * @typedef {function(...?)}
 */
d3.RadialLink;

/**
 * @private {!d3.RadialLink}
 */
d3.RadialLink_;

/**
 * @param {!Function=} source
 * @return {!Function} Source accessor (0 arguments) or this (1 argument).
 */
d3.RadialLink_.source = function(source) {};

/**
 * @param {!Function=} target
 * @return {!Function} Target accessor (0 arguments) or this (1 argument).
 */
d3.RadialLink_.target = function(target) {};

/**
 * @param {!Function=} angle
 * @return {!Function} Angle accessor (0 arguments) or this (1 argument).
 */
d3.RadialLink_.angle = function(angle) {};

/**
 * @param {!Function=} radius
 * @return {!Function} Radius accessor (0 arguments) or this (1 argument).
 */
d3.RadialLink_.radius = function(radius) {};

/**
 * @param {?CanvasPathMethods=} context
 * @return {?} Context (0 arguments) or this (1 argument).
 */
d3.RadialLink_.context = function(context) {};

// Symbols

/**
 * @return {!d3.Symbol}
 */
d3.symbol = function() {};

/**
 * @typedef {function(...?)}
 */
d3.Symbol;

/**
 * @private {!d3.Symbol}
 */
d3.Symbol_;

/**
 * @param {!d3.SymbolType | function(...?): !d3.SymbolType=} type
 */
d3.Symbol_.type = function(type) {};

/**
 * @param {number | function(...?): number=} size
 */
d3.Symbol_.size = function(size) {};

/**
 * @param {?CanvasPathMethods=} context
 */
d3.Symbol_.context = function(context) {};

/**
 * @type {!Array<!d3.SymbolType>}
 */
d3.symbols;

/**
 * @type {!d3.SymbolType}
 */
d3.symbolCircle;

/**
 * @type {!d3.SymbolType}
 */
d3.symbolCross;

/**
 * @type {!d3.SymbolType}
 */
d3.symbolDiamond;

/**
 * @type {!d3.SymbolType}
 */
d3.symbolSquare;

/**
 * @type {!d3.SymbolType}
 */
d3.symbolStar;

/**
 * @type {!d3.SymbolType}
 */
d3.symbolTriangle;

/**
 * @type {!d3.SymbolType}
 */
d3.symbolWye;

/**
 * @param {number} angle
 * @param {number} radius
 * @return {!Array<number>}
 */
d3.pointRadial = function(angle, radius) {};

// Custom Symbol Types

/**
 * @interface
 */
d3.SymbolType = function() {};

/**
 * @param {!CanvasPathMethods} context
 * @param {number} size
 */
d3.SymbolType.prototype.draw = function(context, size) {};

// Stacks

/**
 * @constructor
 * @extends {Array<number>}
 */
d3.SeriesPoint = function() {};

/**
 * @type {number}
 */
d3.SeriesPoint.prototype.index;

/**
 * @type {?}
 */
d3.SeriesPoint.prototype.data;

/**
 * @constructor
 * @extends {Array<!d3.SeriesPoint>}
 */
d3.Series = function() {};

/**
 * @type {?}
 */
d3.Series.prototype.key;

/**
 * @return {!d3.Stack}
 */
d3.stack = function() {};

/**
 * @typedef {function(!Array, ...?): !Array<!d3.Series>}
 */
d3.Stack;

/**
 * @private {!d3.Stack}
 */
d3.Stack_;

/**
 * @param {!Array | function(!Array, ...?): !Array=} keys
 */
d3.Stack_.keys = function(keys) {};

/**
 * @param {number | function(?, ?, number, !Array): number=} value
 */
d3.Stack_.value = function(value) {};

/**
 * @param {?Array<number> | function(!d3.Series): !Array<number>=} order
 */
d3.Stack_.order = function(order) {};

/**
 * @param {?function(!d3.Series, !Array<number>): void=} offset
 */
d3.Stack_.offset = function(offset) {};

// Stack Orders

/**
 * @param {!d3.Series} series
 * @return {!Array<number>}
 */
d3.stackOrderAscending = function(series) {};

/**
 * @param {!d3.Series} series
 * @return {!Array<number>}
 */
d3.stackOrderDescending = function(series) {};

/**
 * @param {!d3.Series} series
 * @return {!Array<number>}
 */
d3.stackOrderInsideOut = function(series) {};

/**
 * @param {!d3.Series} series
 * @return {!Array<number>}
 */
d3.stackOrderNone = function(series) {};

/**
 * @param {!d3.Series} series
 * @return {!Array<number>}
 */
d3.stackOrderReverse = function(series) {};

// Stack Offsets

/**
 * @param {!d3.Series} series
 * @param {!Array<number>} order
 * @return {void}
 */
d3.stackOffsetExpand = function(series, order) {};

/**
 * @param {!d3.Series} series
 * @param {!Array<number>} order
 * @return {void}
 */
d3.stackOffsetDiverging = function(series, order) {};

/**
 * @param {!d3.Series} series
 * @param {!Array<number>} order
 * @return {void}
 */
d3.stackOffsetNone = function(series, order) {};

/**
 * @param {!d3.Series} series
 * @param {!Array<number>} order
 * @return {void}
 */
d3.stackOffsetSilhouette = function(series, order) {};

/**
 * @param {!d3.Series} series
 * @param {!Array<number>} order
 * @return {void}
 */
d3.stackOffsetWiggle = function(series, order) {};

////////////////////////////////////////////////////////////////////////////////
// Time Formats
// https://github.com/d3/d3-time-format
////////////////////////////////////////////////////////////////////////////////

// API Reference

/**
 * @param {string} specifier
 * @return {function((!Date | number)): string}
 */
d3.timeFormat = function(specifier) {};

/**
 * @param {string} specifier
 * @return {function(string): ?Date}
 */
d3.timeParse = function(specifier) {};

/**
 * @param {string} specifier
 * @return {function((!Date | number)): string}
 */
d3.utcFormat = function(specifier) {};

/**
 * @param {string} specifier
 * @return {function(string): ?Date}
 */
d3.utcParse = function(specifier) {};

/**
 * @type {function((!Date | number)): string}
 */
d3.isoFormat;

/**
 * @type {function(string): ?Date}
 */
d3.isoParse;

// Locales

/**
 * @record
 */
d3.TimeLocaleDefinition = function() {};

/**
 * @type {string}
 */
d3.TimeLocaleDefinition.prototype.dateTime;

/**
 * @type {string}
 */
d3.TimeLocaleDefinition.prototype.date;

/**
 * @type {string}
 */
d3.TimeLocaleDefinition.prototype.time;

/**
 * @type {!Array<string>}
 */
d3.TimeLocaleDefinition.prototype.periods;

/**
 * @type {!Array<string>}
 */
d3.TimeLocaleDefinition.prototype.days;

/**
 * @type {!Array<string>}
 */
d3.TimeLocaleDefinition.prototype.shortDays;

/**
 * @type {!Array<string>}
 */
d3.TimeLocaleDefinition.prototype.months;

/**
 * @type {!Array<string>}
 */
d3.TimeLocaleDefinition.prototype.shortMonths;

/**
 * @interface
 */
d3.TimeLocale = function() {};

/**
 * @param {string} specifier
 * @return {function((!Date | number)): string}
 */
d3.TimeLocale.prototype.format = function(specifier) {};

/**
 * @param {string} specifier
 * @return {function(string): ?Date}
 */
d3.TimeLocale.prototype.parse = function(specifier) {};

/**
 * @param {string} specifier
 * @return {function((!Date | number)): string}
 */
d3.TimeLocale.prototype.utcFormat = function(specifier) {};

/**
 * @param {string} specifier
 * @return {function(string): ?Date}
 */
d3.TimeLocale.prototype.utcParse = function(specifier) {};

/**
 * @param {!d3.TimeLocaleDefinition} definition
 * @return {!d3.TimeLocale}
 */
d3.timeFormatLocale = function(definition) {};

/**
 * @param {!d3.TimeLocaleDefinition} definition
 * @return {!d3.TimeLocale}
 */
d3.timeFormatDefaultLocale = function(definition) {};

////////////////////////////////////////////////////////////////////////////////
// Time Intervals
// https://github.com/d3/d3-time
////////////////////////////////////////////////////////////////////////////////

// API Reference

/**
 * @typedef {function((!Date | number)): !Date}
 */
d3.Interval;

/**
 * @private {!d3.Interval}
 */
d3.Interval_;

/**
 * @param {!Date | number} date
 * @return {!Date}
 */
d3.Interval_.floor = function(date) {};

/**
 * @param {!Date | number} date
 * @return {!Date}
 */
d3.Interval_.round = function(date) {};

/**
 * @param {!Date | number} date
 * @return {!Date}
 */
d3.Interval_.ceil = function(date) {};

/**
 * @param {!Date | number} date
 * @param {number} step
 * @return {!Date}
 */
d3.Interval_.offset = function(date, step) {};

/**
 * @param {!Date | number} start
 * @param {!Date | number} stop
 * @param {number=} step
 * @return {!Array<!Date>}
 */
d3.Interval_.range = function(start, stop, step) {};

/**
 * @param {function(!Date): boolean} test
 * @return {!d3.Interval}
 */
d3.Interval_.filter = function(test) {};

/**
 * @param {number} step
 * @return {!d3.Interval}
 */
d3.Interval_.every = function(step) {};

/**
 * @param {!Date | number} start
 * @param {!Date | number} end
 * @return {number}
 */
d3.Interval_.count = function(start, end) {};

/**
 * @param {function(!Date): void} floor
 * @param {function(!Date, number): void} offset
 * @param {function(!Date, !Date): number=} count
 * @param {function(!Date): number=} field
 * @return {!d3.Interval}
 */
d3.timeInterval = function(floor, offset, count, field) {};

// Intervals

/**
 * @type {!d3.Interval}
 */
d3.timeMillisecond;

/**
 * @type {!d3.Interval}
 */
d3.timeSecond;

/**
 * @type {!d3.Interval}
 */
d3.timeMinute;

/**
 * @type {!d3.Interval}
 */
d3.timeHour;

/**
 * @type {!d3.Interval}
 */
d3.timeDay;

/**
 * @type {!d3.Interval}
 */
d3.timeWeek;

/**
 * @type {!d3.Interval}
 */
d3.timeSunday;

/**
 * @type {!d3.Interval}
 */
d3.timeMonday;

/**
 * @type {!d3.Interval}
 */
d3.timeTuesday;

/**
 * @type {!d3.Interval}
 */
d3.timeWednesday;

/**
 * @type {!d3.Interval}
 */
d3.timeThursday;

/**
 * @type {!d3.Interval}
 */
d3.timeFriday;

/**
 * @type {!d3.Interval}
 */
d3.timeSaturday;

/**
 * @type {!d3.Interval}
 */
d3.timeMonth;

/**
 * @type {!d3.Interval}
 */
d3.timeYear;

/**
 * @type {!d3.Interval}
 */
d3.utcMillisecond;

/**
 * @type {!d3.Interval}
 */
d3.utcSecond;

/**
 * @type {!d3.Interval}
 */
d3.utcMinute;

/**
 * @type {!d3.Interval}
 */
d3.utcHour;

/**
 * @type {!d3.Interval}
 */
d3.utcDay;

/**
 * @type {!d3.Interval}
 */
d3.utcWeek;

/**
 * @type {!d3.Interval}
 */
d3.utcSunday;

/**
 * @type {!d3.Interval}
 */
d3.utcMonday;

/**
 * @type {!d3.Interval}
 */
d3.utcTuesday;

/**
 * @type {!d3.Interval}
 */
d3.utcWednesday;

/**
 * @type {!d3.Interval}
 */
d3.utcThursday;

/**
 * @type {!d3.Interval}
 */
d3.utcFriday;

/**
 * @type {!d3.Interval}
 */
d3.utcSaturday;

/**
 * @type {!d3.Interval}
 */
d3.utcMonth;

/**
 * @type {!d3.Interval}
 */
d3.utcYear;

// Ranges

/**
 * @param {!Date | number} start
 * @param {!Date | number} stop
 * @param {number=} step
 * @return {!Array<!Date>}
 */
d3.timeMilliseconds = function(start, stop, step) {};

/**
 * @param {!Date | number} start
 * @param {!Date | number} stop
 * @param {number=} step
 * @return {!Array<!Date>}
 */
d3.timeSeconds = function(start, stop, step) {};

/**
 * @param {!Date | number} start
 * @param {!Date | number} stop
 * @param {number=} step
 * @return {!Array<!Date>}
 */
d3.timeMinutes = function(start, stop, step) {};

/**
 * @param {!Date | number} start
 * @param {!Date | number} stop
 * @param {number=} step
 * @return {!Array<!Date>}
 */
d3.timeHours = function(start, stop, step) {};

/**
 * @param {!Date | number} start
 * @param {!Date | number} stop
 * @param {number=} step
 * @return {!Array<!Date>}
 */
d3.timeDays = function(start, stop, step) {};

/**
 * @param {!Date | number} start
 * @param {!Date | number} stop
 * @param {number=} step
 * @return {!Array<!Date>}
 */
d3.timeWeeks = function(start, stop, step) {};

/**
 * @param {!Date | number} start
 * @param {!Date | number} stop
 * @param {number=} step
 * @return {!Array<!Date>}
 */
d3.timeSundays = function(start, stop, step) {};

/**
 * @param {!Date | number} start
 * @param {!Date | number} stop
 * @param {number=} step
 * @return {!Array<!Date>}
 */
d3.timeMondays = function(start, stop, step) {};

/**
 * @param {!Date | number} start
 * @param {!Date | number} stop
 * @param {number=} step
 * @return {!Array<!Date>}
 */
d3.timeTuesdays = function(start, stop, step) {};

/**
 * @param {!Date | number} start
 * @param {!Date | number} stop
 * @param {number=} step
 * @return {!Array<!Date>}
 */
d3.timeWednesdays = function(start, stop, step) {};

/**
 * @param {!Date | number} start
 * @param {!Date | number} stop
 * @param {number=} step
 * @return {!Array<!Date>}
 */
d3.timeThursdays = function(start, stop, step) {};

/**
 * @param {!Date | number} start
 * @param {!Date | number} stop
 * @param {number=} step
 * @return {!Array<!Date>}
 */
d3.timeFridays = function(start, stop, step) {};

/**
 * @param {!Date | number} start
 * @param {!Date | number} stop
 * @param {number=} step
 * @return {!Array<!Date>}
 */
d3.timeSaturdays = function(start, stop, step) {};

/**
 * @param {!Date | number} start
 * @param {!Date | number} stop
 * @param {number=} step
 * @return {!Array<!Date>}
 */
d3.timeMonths = function(start, stop, step) {};

/**
 * @param {!Date | number} start
 * @param {!Date | number} stop
 * @param {number=} step
 * @return {!Array<!Date>}
 */
d3.timeYears = function(start, stop, step) {};

/**
 * @param {!Date | number} start
 * @param {!Date | number} stop
 * @param {number=} step
 * @return {!Array<!Date>}
 */
d3.utcMilliseconds = function(start, stop, step) {};

/**
 * @param {!Date | number} start
 * @param {!Date | number} stop
 * @param {number=} step
 * @return {!Array<!Date>}
 */
d3.utcSeconds = function(start, stop, step) {};

/**
 * @param {!Date | number} start
 * @param {!Date | number} stop
 * @param {number=} step
 * @return {!Array<!Date>}
 */
d3.utcMinutes = function(start, stop, step) {};

/**
 * @param {!Date | number} start
 * @param {!Date | number} stop
 * @param {number=} step
 * @return {!Array<!Date>}
 */
d3.utcHours = function(start, stop, step) {};

/**
 * @param {!Date | number} start
 * @param {!Date | number} stop
 * @param {number=} step
 * @return {!Array<!Date>}
 */
d3.utcDays = function(start, stop, step) {};

/**
 * @param {!Date | number} start
 * @param {!Date | number} stop
 * @param {number=} step
 * @return {!Array<!Date>}
 */
d3.utcWeeks = function(start, stop, step) {};

/**
 * @param {!Date | number} start
 * @param {!Date | number} stop
 * @param {number=} step
 * @return {!Array<!Date>}
 */
d3.utcSundays = function(start, stop, step) {};

/**
 * @param {!Date | number} start
 * @param {!Date | number} stop
 * @param {number=} step
 * @return {!Array<!Date>}
 */
d3.utcMondays = function(start, stop, step) {};

/**
 * @param {!Date | number} start
 * @param {!Date | number} stop
 * @param {number=} step
 * @return {!Array<!Date>}
 */
d3.utcTuesdays = function(start, stop, step) {};

/**
 * @param {!Date | number} start
 * @param {!Date | number} stop
 * @param {number=} step
 * @return {!Array<!Date>}
 */
d3.utcWednesdays = function(start, stop, step) {};

/**
 * @param {!Date | number} start
 * @param {!Date | number} stop
 * @param {number=} step
 * @return {!Array<!Date>}
 */
d3.utcThursdays = function(start, stop, step) {};

/**
 * @param {!Date | number} start
 * @param {!Date | number} stop
 * @param {number=} step
 * @return {!Array<!Date>}
 */
d3.utcFridays = function(start, stop, step) {};

/**
 * @param {!Date | number} start
 * @param {!Date | number} stop
 * @param {number=} step
 * @return {!Array<!Date>}
 */
d3.utcSaturdays = function(start, stop, step) {};

/**
 * @param {!Date | number} start
 * @param {!Date | number} stop
 * @param {number=} step
 * @return {!Array<!Date>}
 */
d3.utcMonths = function(start, stop, step) {};

/**
 * @param {!Date | number} start
 * @param {!Date | number} stop
 * @param {number=} step
 * @return {!Array<!Date>}
 */
d3.utcYears = function(start, stop, step) {};

////////////////////////////////////////////////////////////////////////////////
// Timers
// https://github.com/d3/d3-timer
////////////////////////////////////////////////////////////////////////////////

// API Reference

/**
 * @return {number}
 */
d3.now = function() {};

/**
 * @param {function(number): void} callback
 * @param {number=} delay
 * @param {number=} time
 * @return {!d3.timer}
 * @constructor
 */
d3.timer = function(callback, delay, time) {};

/**
 * @param {function(number): void} callback
 * @param {number=} delay
 * @param {number=} time
 * @return {void}
 */
d3.timer.prototype.restart = function(callback, delay, time) {};

/**
 * @return {void}
 */
d3.timer.prototype.stop = function() {};

/**
 * @return {void}
 */
d3.timerFlush = function() {};

/**
 * @param {function(number): void} callback
 * @param {number=} delay
 * @param {number=} time
 * @return {!d3.timer}
 */
d3.timeout = function(callback, delay, time) {};

/**
 * @param {function(number): void} callback
 * @param {number=} delay
 * @param {number=} time
 * @return {!d3.timer}
 */
d3.interval = function(callback, delay, time) {};

////////////////////////////////////////////////////////////////////////////////
// Transitions
// https://github.com/d3/d3-transition
////////////////////////////////////////////////////////////////////////////////

// Selecting Elements

/**
 * @param {?string | d3.transition=} nameOrTransition
 * @return {!d3.transition}
 */
d3.selection.prototype.transition = function(nameOrTransition) {};

/**
 * @param {?string=} name
 * @return {!d3.selection}
 */
d3.selection.prototype.interrupt = function(name) {};

/**
 * @param {!Element} node
 * @param {?string=} name
 */
d3.interrupt = function(node, name) {};

/**
 * @param {?string | d3.transition=} nameOrTransition
 * @return {!d3.transition}
 * @constructor
 */
d3.transition = function(nameOrTransition) {};

/**
 * @param {?string} selector
 * @return {!d3.transition}
 */
d3.transition.prototype.select = function(selector) {};

/**
 * @param {?string} selector
 * @return {!d3.transition}
 */
d3.transition.prototype.selectAll = function(selector) {};

/**
 * @param {string |
 *     function(this:Element, ?, number, !IArrayLike<!Element>): boolean} filter
 * @return {!d3.transition}
 */
d3.transition.prototype.filter = function(filter) {};

/**
 * @param {!d3.transition} other
 * @return {!d3.transition}
 */
d3.transition.prototype.merge = function(other) {};

/**
 * @return {!d3.transition}
 */
d3.transition.prototype.transition = function() {};

/**
 * @return {!d3.selection}
 */
d3.transition.prototype.selection = function() {};

/**
 * @param {!Element} node
 * @param {?string=} name
 * @return {!d3.transition}
 */
d3.active = function(node, name) {};

// Modifying Elements

/**
 * @param {string} name
 * @param {?string | number |
 *     function(this:Element, ?, number, !IArrayLike<!Element>):
 *         ?(string | number)} value
 * @return {!d3.transition}
 */
d3.transition.prototype.attr = function(name, value) {};

/**
 * @param {string} name
 * @param {?function(this:Element, ?, number, !IArrayLike<!Element>):
 *     function(number): (string | number)=} value
 */
d3.transition.prototype.attrTween = function(name, value) {};

/**
 * @param {string} name
 * @param {?string |
 *     function(this:Element, ?, number, !IArrayLike<!Element>): ?string} value
 * @param {?string=} priority
 * @return {!d3.transition}
 */
d3.transition.prototype.style = function(name, value, priority) {};

/**
 * @param {string} name
 * @param {?function(this:Element, ?, number, !IArrayLike<!Element>):
 *     function(number): string=} value
 * @param {?string=} priority
 */
d3.transition.prototype.styleTween = function(name, value, priority) {};

/**
 * @param {?string |
 *     function(this:Element, ?, number, !IArrayLike<!Element>): ?string} value
 * @return {!d3.transition}
 */
d3.transition.prototype.text = function(value) {};

/**
 * @return {!d3.transition}
 */
d3.transition.prototype.remove = function() {};

/**
 * @param {string} name
 * @param {?function(this:Element, ?, number, !IArrayLike<!Element>):
 *     function(number)=} value
 */
d3.transition.prototype.tween = function(name, value) {};

// Timing

/**
 * @param {number |
 *     function(this:Element, ?, number, !IArrayLike<!Element>): number=}
 *     value
 */
d3.transition.prototype.delay = function(value) {};

/**
 * @param {number |
 *     function(this:Element, ?, number, !IArrayLike<!Element>): number=}
 *     value
 */
d3.transition.prototype.duration = function(value) {};

/**
 * @param {function(number): number=} value
 */
d3.transition.prototype.ease = function(value) {};

// Control Flow

/**
 * @param {string} typenames
 * @param {?function(this:Element, ?, number, !IArrayLike<!Element>)=}
 *     listener
 * @return {!d3.selection}
 */
d3.transition.prototype.on = function(typenames, listener) {};

/**
 * @param {function(this:Element, ?, number, !IArrayLike<!Element>)} callback
 * @return {!d3.transition}
 */
d3.transition.prototype.each = function(callback) {};

/**
 * @param {!Function} callback
 * @param {...?} var_args
 */
d3.transition.prototype.call = function(callback, var_args) {};

/**
 * @return {boolean}
 */
d3.transition.prototype.empty = function() {};

/**
 * @return {!Array<!Element>}
 */
d3.transition.prototype.nodes = function() {};

/**
 * @return {?Element}
 */
d3.transition.prototype.node = function() {};

/**
 * @return {number}
 */
d3.transition.prototype.size = function() {};

////////////////////////////////////////////////////////////////////////////////
// Voronoi Diagrams
// https://github.com/d3/d3-voronoi
////////////////////////////////////////////////////////////////////////////////

// API Reference

/**
 * @return {!d3.Voronoi}
 */
d3.voronoi = function() {};

/**
 * @typedef {function(!Array): !d3.VoronoiDiagram}
 */
d3.Voronoi;

/**
 * @private {!d3.Voronoi}
 */
d3.Voronoi_;

/**
 * @param {function(?): number=} x
 */
d3.Voronoi_.x = function(x) {};

/**
 * @param {function(?): number=} y
 */
d3.Voronoi_.y = function(y) {};

/**
 * @param {!Array<!Array<number>>=} extent
 */
d3.Voronoi_.extent = function(extent) {};

/**
 * @param {!Array<number>=} size
 */
d3.Voronoi_.size = function(size) {};

/**
 * @param {!Array<T>} data
 * @return {!Array<!d3.VoronoiPolygon<T>>}
 * @template T
 */
d3.Voronoi_.polygons = function(data) {};

/**
 * @param {!Array<T>} data
 * @return {!Array<!Array<T>>}
 * @template T
 */
d3.Voronoi_.triangles = function(data) {};

/**
 * @param {!Array<T>} data
 * @return {!Array<!d3.VoronoiLink<T>>}
 * @template T
 */
d3.Voronoi_.links = function(data) {};

// Voronoi Diagrams

/**
 * @interface
 */
d3.VoronoiDiagram = function() {};

/**
 * @type {!Array<!d3.VoronoiEdge>}
 */
d3.VoronoiDiagram.prototype.edges;

/**
 * @type {!Array<!d3.VoronoiCell | undefined>}
 */
d3.VoronoiDiagram.prototype.cells;

/**
 * @return {!Array<!d3.VoronoiPolygon | undefined>}
 */
d3.VoronoiDiagram.prototype.polygons = function() {};

/**
 * @return {!Array<!Array>}
 */
d3.VoronoiDiagram.prototype.triangles = function() {};

/**
 * @return {!Array<!Array<!d3.VoronoiLink<?>>>}
 */
d3.VoronoiDiagram.prototype.links = function() {};

/**
 * @param {number} x
 * @param {number} y
 * @param {number=} radius
 * @return {?d3.VoronoiSite}
 */
d3.VoronoiDiagram.prototype.find = function(x, y, radius) {};

/**
 * @record
 */
d3.VoronoiCell = function() {};

/**
 * @type {!d3.VoronoiSite}
 */
d3.VoronoiCell.prototype.site;

/**
 * @type {!Array<number>}
 */
d3.VoronoiCell.prototype.halfedges;

/**
 * @record
 * @extends {IArrayLike<number>}
 */
d3.VoronoiSite = function() {};

/**
 * @type {number}
 */
d3.VoronoiSite.prototype.index;

/**
 * @type {?}
 */
d3.VoronoiSite.prototype.data;

/**
 * @record
 * @extends {IArrayLike<?Array<number>>}
 */
d3.VoronoiEdge = function() {};

/**
 * @type {!d3.VoronoiSite}
 */
d3.VoronoiEdge.prototype.left;

/**
 * @type {?d3.VoronoiSite}
 */
d3.VoronoiEdge.prototype.right;

/**
 * @record
 * @extends {IArrayLike<?Array<number>>}
 * @template T
 */
d3.VoronoiPolygon = function() {};

/**
 * @type {T}
 */
d3.VoronoiPolygon.prototype.data;

/**
 * @record
 * @template T
 */
d3.VoronoiLink = function() {};

/**
 * @type {T}
 */
d3.VoronoiLink.prototype.source;

/**
 * @type {T}
 */
d3.VoronoiLink.prototype.target;

////////////////////////////////////////////////////////////////////////////////
// Zooming
// https://github.com/d3/d3-zoom
////////////////////////////////////////////////////////////////////////////////

// API Reference

/**
 * @return {!d3.Zoom}
 */
d3.zoom = function() {};

/**
 * @typedef {function(!d3.selection): void}
 */
d3.Zoom;

/**
 * @private {!d3.Zoom}
 */
d3.Zoom_;

/**
 * @param {!d3.selection | !d3.transition} selection
 * @param {!d3.zoomTransform |
 *     function(this:Element, T, number, !Array<T>): !d3.zoomTransform}
 *     transform
 * @return {void}
 * @template T
 */
d3.Zoom_.transform = function(selection, transform) {};

/**
 * @param {!d3.selection | !d3.transition} selection
 * @param {number | function(this:Element, T, number, !Array<T>): number} x
 * @param {number | function(this:Element, T, number, !Array<T>): number} y
 * @return {void}
 * @template T
 */
d3.Zoom_.translateBy = function(selection, x, y) {};

/**
 * @param {!d3.selection | !d3.transition} selection
 * @param {number | function(this:Element, T, number, !Array<T>): number} x
 * @param {number | function(this:Element, T, number, !Array<T>): number} y
 * @return {void}
 * @template T
 */
d3.Zoom_.translateTo = function(selection, x, y) {};

/**
 * @param {!d3.selection | !d3.transition} selection
 * @param {number | function(this:Element, T, number, !Array<T>): number} k
 * @return {void}
 * @template T
 */
d3.Zoom_.scaleBy = function(selection, k) {};

/**
 * @param {!d3.selection | !d3.transition} selection
 * @param {number | function(this:Element, T, number, !Array<T>): number} k
 * @return {void}
 * @template T
 */
d3.Zoom_.scaleTo = function(selection, k) {};

/**
 * @param {function(!d3.zoomTransform,
 *                  !Array<!Array<number>>,
 *                  !Array<!Array<number>>): !d3.zoomTransform=} constrain
 * @return {!Function}
 */
d3.Zoom_.constrain = function(constrain) {};

/**
 * @param {function(this:Element, T, number, !Array<T>): boolean=} filter
 * @template T
 */
d3.Zoom_.filter = function(filter) {};

/**
 * @param {function(this:Element): boolean=} touchable
 * @return {!Function}
 */
d3.Zoom_.touchable = function(touchable) {};

/**
 * @param {function(): number=} delta
 * @return {!Function}
 */
d3.Zoom_.wheelDelta = function(delta) {};

/**
 * @param {!Array<!Array<number>> |
 *     function(this:Element, T, number, !Array<T>): !Array<!Array<number>>=}
 *     extent
 * @template T
 */
d3.Zoom_.extent = function(extent) {};

/**
 * @param {!Array<number>=} extent
 */
d3.Zoom_.scaleExtent = function(extent) {};

/**
 * @param {!Array<!Array<number>>=} extent
 */
d3.Zoom_.translateExtent = function(extent) {};

/**
 * @param {number=} distance
 * @return {?} Distance (0 arguments) or this (1 argument).
 */
d3.Zoom_.clickDistance = function(distance) {};

/**
 * @param {number=} duration
 */
d3.Zoom_.duration = function(duration) {};

/**
 * @param {function(!Array<number>, !Array<number>):
 *     function(number): !Array<number>=} interpolator
 */
d3.Zoom_.interpolate = function(interpolator) {};

/**
 * @param {string} typenames
 * @param {?function(this:Element, T, number, !Array<T>): void=} listener
 * @template T
 */
d3.Zoom_.on = function(typenames, listener) {};

// Zoom Events

/**
 * @record
 */
d3.ZoomEvent = function() {};

/**
 * @type {!d3.Zoom}
 */
d3.ZoomEvent.prototype.target;

/**
 * @type {string}
 */
d3.ZoomEvent.prototype.type;

/**
 * @type {!d3.zoomTransform}
 */
d3.ZoomEvent.prototype.transform;

/**
 * @type {!Event}
 */
d3.ZoomEvent.prototype.sourceEvent;

// Zoom Transforms

/**
 * @param {!Element} node
 * @return {!d3.zoomTransform}
 * @constructor
 */
d3.zoomTransform = function(node) {};

/**
 * @const {number}
 */
d3.zoomTransform.prototype.x;

/**
 * @const {number}
 */
d3.zoomTransform.prototype.y;

/**
 * @const {number}
 */
d3.zoomTransform.prototype.k;

/**
 * @param {number} k
 * @return {!d3.zoomTransform}
 */
d3.zoomTransform.prototype.scale = function(k) {};

/**
 * @param {number} x
 * @param {number} y
 * @return {!d3.zoomTransform}
 */
d3.zoomTransform.prototype.translate = function(x, y) {};

/**
 * @param {!Array<number>} point
 * @return {!Array<number>}
 */
d3.zoomTransform.prototype.apply = function(point) {};

/**
 * @param {number} x
 * @return {number}
 */
d3.zoomTransform.prototype.applyX = function(x) {};

/**
 * @param {number} y
 * @return {number}
 */
d3.zoomTransform.prototype.applyY = function(y) {};

/**
 * @param {!Array<number>} point
 * @return {!Array<number>}
 */
d3.zoomTransform.prototype.invert = function(point) {};

/**
 * @param {number} x
 * @return {number}
 */
d3.zoomTransform.prototype.invertX = function(x) {};

/**
 * @param {number} y
 * @return {number}
 */
d3.zoomTransform.prototype.invertY = function(y) {};

/**
 * @param {function(?): ?} x Invertible continuous scale.
 * @return {function(?): ?}
 */
d3.zoomTransform.prototype.rescaleX = function(x) {};

/**
 * @param {function(?): ?} y Invertible continuous scale.
 * @return {function(?): ?}
 */
d3.zoomTransform.prototype.rescaleY = function(y) {};

/**
 * @override
 * @return {string}
 */
d3.zoomTransform.prototype.toString = function() {};

/**
 * @type {!d3.zoomTransform}
 */
d3.zoomIdentity;