# Generated by detroit
# See https://github.com/bourbonut/detroit/tree/main/api_maker

from functools import partial, update_wrapper
from operator import is_not
from .Adder import Adder
from .bin import _bin
from .bisector import bisector
from .axisTop import axisTop
from .axisRight import axisRight
from .axisBottom import axisBottom
from .axisLeft import axisLeft
from .brush import brush
from .brushX import brushX
from .brushY import brushY
from .chord import chord
from .ribbon import ribbon
from .ribbonArrow import ribbonArrow
from .color import color
from .rgb import rgb
from .hsl import hsl
from .contours import contours
from .contourDensity import contourDensity
from .Delaunay import Delaunay
from .voronoi import voronoi
from .dispatch import dispatch
from .drag import drag
from .event import event
from .dsvFormat import dsvFormat
from .easePolyIn import easePolyIn
from .easePolyOut import easePolyOut
from .easePoly import easePoly
from .easePolyInOut import easePolyInOut
from .easeElasticIn import easeElasticIn
from .easeElastic import easeElastic
from .easeElasticOut import easeElasticOut
from .easeElasticInOut import easeElasticInOut
from .easeBackIn import easeBackIn
from .easeBackOut import easeBackOut
from .easeBack import easeBack
from .easeBackInOut import easeBackInOut
from .forceSimulation import forceSimulation
from .forceCenter import forceCenter
from .forceCollide import forceCollide
from .forceLink import forceLink
from .forceManyBody import forceManyBody
from .forceX import forceX
from .forceY import forceY
from .forceRadial import forceRadial
from .geoPath import geoPath
from .projection import projection
from .project import project
from .geoIdentity import geoIdentity
from .conic import conic
from .geoStream import geoStream
from .geoGraticule import geoGraticule
from .geoCircle import geoCircle
from .node import node
from .stratify import stratify
from .cluster import cluster
from .tree import tree
from .treemap import treemap
from .treemapSquarify import treemapSquarify
from .treemapResquarify import treemapResquarify
from .partition import partition
from .pack import pack
from .interpolateColor import interpolateColor
from .interpolateZoom import interpolateZoom
from .path import path
from .quadtree import quadtree
from .randomUniform import randomUniform
from .randomInt import randomInt
from .randomNormal import randomNormal
from .randomLogNormal import randomLogNormal
from .randomBates import randomBates
from .randomIrwinHall import randomIrwinHall
from .randomExponential import randomExponential
from .randomPareto import randomPareto
from .randomBernoulli import randomBernoulli
from .randomGeometric import randomGeometric
from .randomBinomial import randomBinomial
from .randomGamma import randomGamma
from .randomBeta import randomBeta
from .randomWeibull import randomWeibull
from .randomCauchy import randomCauchy
from .randomLogistic import randomLogistic
from .randomPoisson import randomPoisson
from .scaleLinear import scaleLinear
from .scaleIdentity import scaleIdentity
from .scaleRadial import scaleRadial
from .scalePow import scalePow
from .scaleSqrt import scaleSqrt
from .scaleLog import scaleLog
from .scaleSymlog import scaleSymlog
from .scaleTime import scaleTime
from .scaleUtc import scaleUtc
from .scaleSequential import scaleSequential
from .scaleSequentialLog import scaleSequentialLog
from .scaleSequentialPow import scaleSequentialPow
from .scaleSequentialSqrt import scaleSequentialSqrt
from .scaleSequentialSymlog import scaleSequentialSymlog
from .scaleSequentialQuantile import scaleSequentialQuantile
from .scaleDiverging import scaleDiverging
from .scaleDivergingLog import scaleDivergingLog
from .scaleDivergingPow import scaleDivergingPow
from .scaleDivergingSqrt import scaleDivergingSqrt
from .scaleDivergingSymlog import scaleDivergingSymlog
from .scaleQuantize import scaleQuantize
from .scaleQuantile import scaleQuantile
from .scaleThreshold import scaleThreshold
from .scaleOrdinal import scaleOrdinal
from .scaleImplicit import scaleImplicit
from .scaleBand import scaleBand
from .scalePoint import scalePoint
from ._select import select
from ._selectAll import selectAll
from .local import local
from .arc import arc
from .pie import pie
from .line import line
from .lineRadial import lineRadial
from .area import area
from .areaRadial import areaRadial
from .curveBasis import curveBasis
from .curveBasisClosed import curveBasisClosed
from .curveBasisOpen import curveBasisOpen
from .curveBundle import curveBundle
from .curveBumpX import curveBumpX
from .curveBumpY import curveBumpY
from .curveCardinal import curveCardinal
from .curveCardinalClosed import curveCardinalClosed
from .curveCardinalOpen import curveCardinalOpen
from .curveCatmullRom import curveCatmullRom
from .curveCatmullRomClosed import curveCatmullRomClosed
from .curveCatmullRomOpen import curveCatmullRomOpen
from .curveLinear import curveLinear
from .curveLinearClosed import curveLinearClosed
from .curveMonotoneX import curveMonotoneX
from .curveMonotoneY import curveMonotoneY
from .curveNatural import curveNatural
from .curveStep import curveStep
from .curveStepAfter import curveStepAfter
from .curveStepBefore import curveStepBefore
from .link import link
from .linkVertical import linkVertical
from .linkHorizontal import linkHorizontal
from .linkRadial import linkRadial
from .symbol import symbol
from .symbolType import symbolType
from .stack import stack
from .timeInterval import timeInterval
from .timer import timer
from .transition import transition
from .zoom import zoom
from .zoomTransform import zoomTransform
from ._selection import selection

class ReprWrapper:
    """
    Wrapper class to make possible to represent methods in a different way
    """
    def __init__(self, repr, func):
        self._repr = repr
        self._func = func
        update_wrapper(self, func)

    def __call__(self, *args, **kw):
        return self._func(*args, **kw)
    def __repr__(self):
        return self._repr(self._func)

def repr_wrapper(func):
    return ReprWrapper(lambda method: f"d3.{method.__name__}", func)

class d3:
    """
    Class used to mimick javascript syntax for :code:`d3`

    See `documentation <https://d3js.org/getting-started>`_.

    Examples
    --------

    >>> from detroit import d3, js
    >>> d3.axisBottom(js("x")).tickFormat(d3.format(".0f"))
    d3.axisBottom(x).tickFormat(d3.format('.0f'))
    """
    def __init__(self, content="d3"):
        self.content = content

    def __repr__(self):
        return self.content

    def __str__(self):
        return self.content

    def __call__(self, *args):
        arguments = ", ".join(map(repr, args))
        return f"{self}({arguments})"

    @staticmethod
    def fcumsum(values=None, accessor=None):
        """
        .. code:: javascript

            d3.fcumsum([1, 1e-14, -1]) // [1, 1.00000000000001, 1e-14]

        Examples · Source · Returns a full-precision cumulative sum of the given values as a
        Float64Array. Although slower, d3.fcumsum can replace d3.cumsum when greater precision
        is needed.
        .. code:: javascript

            d3.fcumsum(penguins, (d) => d.body_mass_g) // [3750, 7550, 10800, 10800, 14250, …]

        If an accessor is specified, invokes the given function for each element in the input
        values, being passed the element d, the index i, and the array data as three arguments;
        the returned values will then be added.

        See more informations `here <https://d3js.org/d3-array/add#fcumsum>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (values, accessor))))
        return d3(f"d3.fcumsum({arguments})")

    @staticmethod
    def fsum(values=None, accessor=None):
        """
        .. code:: javascript

            d3.fsum([0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1]) // 1

        Examples · Source · Returns a full-precision summation of the given values. Although
        slower, d3.fsum can replace d3.sum wherever greater precision is needed.
        .. code:: javascript

            d3.fsum(penguins, (d) => d.body_mass_g) // 1437000

        If an accessor is specified, invokes the given function for each element in the input
        values, being passed the element d, the index i, and the array data as three arguments;
        the returned values will then be added.

        See more informations `here <https://d3js.org/d3-array/add#fsum>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (values, accessor))))
        return d3(f"d3.fsum({arguments})")

    @staticmethod
    def thresholdFreedmanDiaconis(values=None, min=None, max=None):
        """
        .. code:: javascript

            const bin = d3.bin().thresholds(d3.thresholdFreedmanDiaconis);

        Source · Returns the number of bins according to the Freedman–Diaconis rule; the input
        values must be numbers.

        See more informations `here <https://d3js.org/d3-array/bin#thresholdFreedmanDiaconis>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (values, min, max))))
        return d3(f"d3.thresholdFreedmanDiaconis({arguments})")

    @staticmethod
    def thresholdScott(values=None, min=None, max=None):
        """
        .. code:: javascript

            const bin = d3.bin().thresholds(d3.thresholdScott);

        Source · Returns the number of bins according to Scott’s normal reference rule; the
        input values must be numbers.

        See more informations `here <https://d3js.org/d3-array/bin#thresholdScott>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (values, min, max))))
        return d3(f"d3.thresholdScott({arguments})")

    @staticmethod
    def thresholdSturges(values=None, min=None, max=None):
        """
        .. code:: javascript

            const bin = d3.bin().thresholds(d3.thresholdSturges);

        Source · Returns the number of bins according to Sturges’ formula; the input values
        must be numbers.

        See more informations `here <https://d3js.org/d3-array/bin#thresholdSturges>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (values, min, max))))
        return d3(f"d3.thresholdSturges({arguments})")

    @staticmethod
    def bisectRight(array=None, x=None, lo=None, hi=None):
        """
        .. code:: javascript

            d3.bisectRight(aapl.map((d) => d.Date), new Date("2014-01-02")) // 163

        Like bisectLeft, but returns an insertion point which comes after (to the right of) any
        existing entries equivalent to x in array. The returned insertion point i partitions
        the array into two halves so that all v <= x for v in array.slice(lo, i) for the left
        side and all v > x for v in array.slice(i, hi) for the right side. See also
        bisector.right.

        See more informations `here <https://d3js.org/d3-array/bisect#bisectRight>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (array, x, lo, hi))))
        return d3(f"d3.bisectRight({arguments})")

    @staticmethod
    def bisectLeft(array=None, x=None, lo=None, hi=None):
        """
        .. code:: javascript

            d3.bisectLeft(aapl.map((d) => d.Date), new Date("2014-01-02")) // 162

        Returns the insertion point for x in array to maintain sorted order. The arguments lo
        and hi may be used to specify a subset of the array which should be considered; by
        default the entire array is used. If x is already present in array, the insertion point
        will be before (to the left of) any existing entries. The return value is suitable for
        use as the first argument to array.splice assuming that array is already sorted. The
        returned insertion point i partitions the array into two halves so that all v < x for v
        in array.slice(lo, i) for the left side and all v >= x for v in array.slice(i, hi) for
        the right side. See also bisector.left.

        See more informations `here <https://d3js.org/d3-array/bisect#bisectLeft>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (array, x, lo, hi))))
        return d3(f"d3.bisectLeft({arguments})")

    @staticmethod
    def bisectCenter(array=None, x=None, lo=None, hi=None):
        """
        .. code:: javascript

            d3.bisectCenter(aapl.map((d) => d.Date), new Date("2013-12-31")) // 161

        Returns the index of the value closest to x in the given array of numbers. The
        arguments lo (inclusive) and hi (exclusive) may be used to specify a subset of the
        array which should be considered; by default the entire array is used. See also
        bisector.center.

        See more informations `here <https://d3js.org/d3-array/bisect#bisectCenter>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (array, x, lo, hi))))
        return d3(f"d3.bisectCenter({arguments})")

    @staticmethod
    def blur(data=None, radius=None):
        """
        .. code:: javascript

            const numbers = d3.cumsum({length: 1000}, () => Math.random() - 0.5);
            d3.blur(numbers, 5); // a smoothed random walk

        Examples · Source · Blurs an array of data in-place by applying three iterations of a
        moving average transform (box filter) for a fast approximation of a Gaussian kernel of
        the given radius, a non-negative number. Returns the given data.

        See more informations `here <https://d3js.org/d3-array/blur#blur>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (data, radius))))
        return d3(f"d3.blur({arguments})")

    @staticmethod
    def blur2(matrix=None, rx=None, ry=None):
        """
        .. code:: javascript

            const matrix = {
              width: 4,
              height: 3,
              data: [
                1, 0, 0, 0,
                0, 0, 0, 0,
                0, 0, 0, 1
              ]
            };

            d3.blur2(matrix, 1);

        Examples · Source · Blurs a matrix of the given width and height in-place by applying a
        horizontal blur of radius rx and a vertical blur of radius ry (which defaults to rx).
        The matrix values data are stored in a flat (one-dimensional) array. If height is not
        specified, it is inferred from the given width and data.length. Returns the blurred
        matrix {data, width, height}.

        See more informations `here <https://d3js.org/d3-array/blur#blur2>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (matrix, rx, ry))))
        return d3(f"d3.blur2({arguments})")

    @staticmethod
    def blurImage(imageData=None, rx=None, ry=None):
        """
        .. code:: javascript

            const imageData = context.getImageData(0, 0, width, height);
            d3.blurImage(imageData, 5);

        Examples · Source · Blurs the given ImageData in-place, blurring each of the RGBA
        layers independently by applying an horizontal blur of radius rx and a vertical blur of
        radius ry (which defaults to rx). Returns the blurred ImageData.

        See more informations `here <https://d3js.org/d3-array/blur#blurImage>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (imageData, rx, ry))))
        return d3(f"d3.blurImage({arguments})")

    @staticmethod
    def group(iterable=None, *keys):
        """
        Examples · Source · Groups the specified iterable of values into an InternMap from key
        to array of value. For example, to group the penguins sample dataset by species field:
        .. code:: javascript

            const species = d3.group(penguins, (d) => d.species);

        To get the elements whose species field is Adelie:
        .. code:: javascript

            species.get("Adelie") // Array(152)

        If more than one key is specified, a nested InternMap is returned. For example:
        .. code:: javascript

            const speciesSex = d3.group(penguins, (d) => d.species, (d) => d.sex)

        To get the penguins whose species is Adelie and whose sex is FEMALE:
        .. code:: javascript

            speciesSex.get("Adelie").get("FEMALE") // Array(73)

        Elements are returned in the order of the first instance of each key.

        See more informations `here <https://d3js.org/d3-array/group#group>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (iterable, *keys))))
        return d3(f"d3.group({arguments})")

    @staticmethod
    def groups(iterable=None, *keys):
        """
        .. code:: javascript

            const species = d3.groups(penguins, (d) => d.species); // [["Adelie", Array(152)], …]

        Equivalent to group, but returns an array of [key, value] entries instead of a map. If
        more than one key is specified, each value will be a nested array of [key, value]
        entries. Elements are returned in the order of the first instance of each key.

        See more informations `here <https://d3js.org/d3-array/group#groups>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (iterable, *keys))))
        return d3(f"d3.groups({arguments})")

    @staticmethod
    def rollup(iterable=None, reduce=None, *keys):
        """
        Examples · Source · Groups and reduces the specified iterable of values into an
        InternMap from key to reduced value. For example, to group and count the penguins
        sample dataset by species field:
        .. code:: javascript

            const speciesCount = d3.rollup(penguins, (D) => D.length, (d) => d.species);

        To get the count of penguins whose species is Adelie:
        .. code:: javascript

            speciesCount.get("Adelie") // 152

        If more than one key is specified, a nested InternMap is returned. For example:
        .. code:: javascript

            const speciesSexCount = d3.rollup(penguins, (D) => D.length, (d) => d.species, (d) => d.sex);

        To get the count of penguins whose species is Adelie and whose sex is FEMALE:
        .. code:: javascript

            speciesSexCount.get("Adelie").get("FEMALE") // 73

        Elements are returned in the order of the first instance of each key.

        See more informations `here <https://d3js.org/d3-array/group#rollup>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (iterable, reduce, *keys))))
        return d3(f"d3.rollup({arguments})")

    @staticmethod
    def rollups(iterable=None, reduce=None, *keys):
        """
        .. code:: javascript

            const speciesCounts = d3.rollups(penguins, (D) => D.length, (d) => d.species); // [["Adelie", 152], …]

        Equivalent to rollup, but returns an array of [key, value] entries instead of a map. If
        more than one key is specified, each value will be a nested array of [key, value]
        entries. Elements are returned in the order of the first instance of each key.

        See more informations `here <https://d3js.org/d3-array/group#rollups>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (iterable, reduce, *keys))))
        return d3(f"d3.rollups({arguments})")

    @staticmethod
    def index(iterable=None, *keys):
        """
        Uses rollup with a reducer that extracts the first element from each group, and throws
        an error if the group has more than one element. For example, to index the aapl same
        dataset by date:
        .. code:: javascript

            const aaplDate = d3.index(aapl, (d) => d.Date);

        You can then quickly retrieve a value by date:
        .. code:: javascript

            aaplDate.get(new Date("2013-12-31")).Close // 80.145714

        Elements are returned in input order.

        See more informations `here <https://d3js.org/d3-array/group#index>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (iterable, *keys))))
        return d3(f"d3.index({arguments})")

    @staticmethod
    def indexes(iterable=None, *keys):
        """
        Like index, but returns an array of [key, value] entries instead of a map. This
        probably isn’t useful for anything, but is included for symmetry with groups and
        rollups.

        See more informations `here <https://d3js.org/d3-array/group#indexes>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (iterable, *keys))))
        return d3(f"d3.indexes({arguments})")

    @staticmethod
    def flatGroup(iterable=None, *keys):
        """
        Examples · Source · Equivalent to group, but returns a flat array of [key0, key1, …,
        values] instead of nested maps; useful for iterating over all groups.

        See more informations `here <https://d3js.org/d3-array/group#flatGroup>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (iterable, *keys))))
        return d3(f"d3.flatGroup({arguments})")

    @staticmethod
    def flatRollup(iterable=None, reduce=None, *keys):
        """
        Examples · Source · Equivalent to rollup, but returns a flat array of [key0, key1, …,
        value] instead of nested maps; useful for iterating over all groups.

        See more informations `here <https://d3js.org/d3-array/group#flatRollup>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (iterable, reduce, *keys))))
        return d3(f"d3.flatRollup({arguments})")

    @staticmethod
    def groupSort(iterable=None, comparator=None, key=None):
        """
        Examples · Source · Groups the specified iterable of elements according to the
        specified key function, sorts the groups according to the specified comparator, and
        then returns an array of keys in sorted order. For example, to order the species of the
        penguins sample dataset by ascending median body mass:
        .. code:: javascript

            d3.groupSort(penguins, (D) => d3.median(D, (d) => d.body_mass_g), (d) => d.species) // ["Adelie", "Chinstrap", "Gentoo"]

        For descending order, negate the group value:
        .. code:: javascript

            d3.groupSort(penguins, (D) => -d3.median(D, (d) => d.body_mass_g), (d) => d.species) // ["Gentoo", "Adelie", "Chinstrap"]

        If a comparator is passed instead of an accessor (i.e., if the second argument is a
        function that takes exactly two arguments), it will be asked to compare two groups a
        and b and should return a negative value if a should be before b, a positive value if a
        should be after b, or zero for a partial ordering.

        See more informations `here <https://d3js.org/d3-array/group#groupSort>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (iterable, comparator, key))))
        return d3(f"d3.groupSort({arguments})")

    @staticmethod
    def InternMap(iterable=None, key=None):
        """
        .. code:: javascript

            const valueByDate = new d3.InternMap([
              [new Date("2021-01-01"), 42],
              [new Date("2022-01-01"), 12],
              [new Date("2023-01-01"), 45]
            ]);

        Examples · Source · Constructs a new Map given the specified iterable of [key, value]
        entries. The keys are interned using the specified key function which defaults to
        object.valueOf for non-primitive values. For example, to retrieve a value keyed by a
        given date:
        .. code:: javascript

            valueByDate.get(new Date("2022-01-01")) // 12


        See more informations `here <https://d3js.org/d3-array/intern#InternMap>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (iterable, key))))
        return d3(f"new d3.InternMap({arguments})")

    @staticmethod
    def InternSet(iterable=None, key=None):
        """
        .. code:: javascript

            const dates = new d3.InternSet([
              new Date("2021-01-01"),
              new Date("2022-01-01"),
              new Date("2023-01-01")
            ]);

        Examples · Source · Constructs a new Set given the specified iterable of values. The
        values are interned using the specified key function which defaults to object.valueOf
        for non-primitive values. For example, to query for a given date:
        .. code:: javascript

            dates.has(new Date("2022-01-01")) // true


        See more informations `here <https://d3js.org/d3-array/intern#InternSet>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (iterable, key))))
        return d3(f"new d3.InternSet({arguments})")

    @staticmethod
    def difference(iterable=None, *others):
        """
        Source · Returns a new InternSet containing every value in iterable that is not in any
        of the others iterables.
        .. code:: javascript

            d3.difference([0, 1, 2, 0], [1]) // Set {0, 2}


        See more informations `here <https://d3js.org/d3-array/sets#difference>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (iterable, *others))))
        return d3(f"d3.difference({arguments})")

    @staticmethod
    def disjoint(a=None, b=None):
        """
        Source · Returns true if a and b are disjoint: if a and b contain no shared value.
        .. code:: javascript

            d3.disjoint([1, 3], [2, 4]) // true


        See more informations `here <https://d3js.org/d3-array/sets#disjoint>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (a, b))))
        return d3(f"d3.disjoint({arguments})")

    @staticmethod
    def intersection(*iterables):
        """
        Source · Returns a new InternSet containing every (distinct) value that appears in all
        of the given iterables. The order of values in the returned set is based on their first
        occurrence in the given iterables.
        .. code:: javascript

            d3.intersection([0, 2, 1, 0], [1, 3]) // Set {1}


        See more informations `here <https://d3js.org/d3-array/sets#intersection>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (*iterables,))))
        return d3(f"d3.intersection({arguments})")

    @staticmethod
    def superset(a=None, b=None):
        """
        Source · Returns true if a is a superset of b: if every value in the given iterable b
        is also in the given iterable a.
        .. code:: javascript

            d3.superset([0, 2, 1, 3, 0], [1, 3]) // true


        See more informations `here <https://d3js.org/d3-array/sets#superset>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (a, b))))
        return d3(f"d3.superset({arguments})")

    @staticmethod
    def subset(a=None, b=None):
        """
        Source · Returns true if a is a subset of b: if every value in the given iterable a is
        also in the given iterable b.
        .. code:: javascript

            d3.subset([1, 3], [0, 2, 1, 3, 0]) // true


        See more informations `here <https://d3js.org/d3-array/sets#subset>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (a, b))))
        return d3(f"d3.subset({arguments})")

    @staticmethod
    def union(*iterables):
        """
        Source · Returns a new InternSet containing every (distinct) value that appears in any
        of the given iterables. The order of values in the returned set is based on their first
        occurrence in the given iterables.
        .. code:: javascript

            d3.union([0, 2, 1, 0], [1, 3]) // Set {0, 2, 1, 3}


        See more informations `here <https://d3js.org/d3-array/sets#union>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (*iterables,))))
        return d3(f"d3.union({arguments})")

    @staticmethod
    def ascending(a=None, b=None):
        """
        Examples · Source · Returns -1 if a is less than b, 1 if a is greater than b, 0 if a
        and b are equivalent, and otherwise NaN.
        .. code:: javascript

            [39, 21, 1, 104, 22].sort(d3.ascending) // [1, 21, 22, 39, 104]

        This is the comparator function for natural order, and can be used with array.sort to
        arrange elements in ascending order.

        See more informations `here <https://d3js.org/d3-array/sort#ascending>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (a, b))))
        return d3(f"d3.ascending({arguments})")

    @staticmethod
    def descending(a=None, b=None):
        """
        Examples · Source · Returns -1 if a is greater than b, 1 if a is less than b, 0 if a
        and b are equivalent, and otherwise NaN.
        .. code:: javascript

            [39, 21, 1, 104, 22].sort(d3.descending) // [104, 39, 22, 21, 1]

        This is the comparator function for natural order, and can be used with array.sort to
        arrange elements in descending order.

        See more informations `here <https://d3js.org/d3-array/sort#descending>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (a, b))))
        return d3(f"d3.descending({arguments})")

    @staticmethod
    def permute(source=None, keys=None):
        """
        Examples · Source · Returns a permutation of the specified source array or object using
        the specified iterable of keys. The returned array contains the corresponding property
        of the source object for each key in keys, in order.
        .. code:: javascript

            d3.permute(["a", "b", "c"], [1, 2, 0]) // returns ["b", "c", "a"]

        The given source need not be an array; for example, given an object
        .. code:: javascript

            const object = {yield: 27, variety: "Manchuria", year: 1931, site: "University Farm"};

        three fields could be extract like so
        .. code:: javascript

            d3.permute(object, ["site", "variety", "yield"]) // ["University Farm", "Manchuria", 27]


        See more informations `here <https://d3js.org/d3-array/sort#permute>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (source, keys))))
        return d3(f"d3.permute({arguments})")

    @staticmethod
    def quickselect(array=None, k=None, lo=None, hi=None, compare=None):
        """
        Examples · Source · Rearranges the elements of array between lo and hi (inclusive)
        in-place such that array[k] is the (k - lo + 1)-th smallest value and array.slice(lo,
        k) are the k smallest elements, according to the given compare function, and returns
        the given array. If lo is not specified, it defaults to zero; if hi is not specified,
        it defaults to array.length - 1; if compare is not specified, it defaults to ascending.
        For example, given an array of numbers:
        .. code:: javascript

            const numbers = [65, 28, 59, 33, 21, 56, 22, 95, 50, 12, 90, 53, 28, 77, 39];

        To select the smallest 8 elements:
        .. code:: javascript

            d3.quickselect(numbers, 8)

        The rearranged numbers is
        .. code:: javascript

            [39, 28, 28, 33, 21, 12, 22, 50, 53, 56, 59, 65, 90, 77, 95]
            //                               ^^ numbers[k]

        where numbers[8] is 53: greater than the preceding k elements and less than the
        following elements. Implemented by Volodymyr Agafonkin’s quickselect.

        See more informations `here <https://d3js.org/d3-array/sort#quickselect>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (array, k, lo, hi, compare))))
        return d3(f"d3.quickselect({arguments})")

    @staticmethod
    def reverse(iterable=None):
        """
        Source · Returns an array containing the values in the given iterable in reverse order.
        .. code:: javascript

            d3.reverse(new Set([0, 2, 3, 1])) // [1, 3, 2, 0]

        Equivalent to array.reverse, except that it does not mutate the given input and works
        with any iterable.

        See more informations `here <https://d3js.org/d3-array/sort#reverse>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (iterable,))))
        return d3(f"d3.reverse({arguments})")

    @staticmethod
    def shuffle(array=None, start=None, stop=None):
        """
        Examples · Source · Randomizes the order of the specified array in-place using the
        Fisher–Yates shuffle and returns the array.
        .. code:: javascript

            d3.shuffle([..."abcdefg"]) // ["e", "c", "a", "d", "b", "g", "f"], perhaps

        If start is specified, it is the starting index (inclusive) of the array to shuffle; if
        start is not specified, it defaults to zero. If stop is specified, it is the ending
        index (exclusive) of the array to shuffle; if stop is not specified, it defaults to
        array.length. For example, to shuffle the first ten elements of the array:
        shuffle(array, 0, 10).

        See more informations `here <https://d3js.org/d3-array/sort#shuffle>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (array, start, stop))))
        return d3(f"d3.shuffle({arguments})")

    @staticmethod
    def shuffler(random=None):
        """
        Source · Returns a shuffle function given the specified random source.
        .. code:: javascript

            d3.shuffler(d3.randomLcg(42))([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) // [5, 3, 7, 6, 8, 9, 1, 4, 0, 2]

        Often used with d3.randomLcg for a deterministic shuffle.

        See more informations `here <https://d3js.org/d3-array/sort#shuffler>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (random,))))
        return d3(f"d3.shuffler({arguments})")

    @staticmethod
    def sort(iterable=None, comparator=None):
        """
        Source · Returns an array containing the values in the given iterable in the sorted
        order defined by the given comparator or accessor function. If comparator is not
        specified, it defaults to d3.ascending.
        .. code:: javascript

            d3.sort(new Set([0, 2, 3, 1])) // [0, 1, 2, 3]

        If an accessor (a function that does not take exactly two arguments) is specified,
        .. code:: javascript

            d3.sort(data, (d) => d.value)

        it is equivalent to a comparator using natural order:
        .. code:: javascript

            d3.sort(data, (a, b) => d3.ascending(a.value, b.value))

        The accessor is only invoked once per element, and thus the returned sorted order is
        consistent even if the accessor is nondeterministic. Multiple accessors may be
        specified to break ties.
        .. code:: javascript

            d3.sort(points, ({x}) => x, ({y}) => y)

        The above is equivalent to:
        .. code:: javascript

            d3.sort(data, (a, b) => d3.ascending(a.x, b.x) || d3.ascending(a.y, b.y))

        Unlike array.sort, d3.sort does not mutate the given input, the comparator defaults to
        natural order instead of lexicographic order, and the input can be any iterable.

        See more informations `here <https://d3js.org/d3-array/sort#sort>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (iterable, comparator))))
        return d3(f"d3.sort({arguments})")

    @staticmethod
    def count(iterable=None, accessor=None):
        """
        .. code:: javascript

            d3.count(penguins, (d) => d.body_mass_g) // 342

        Examples · Source · Returns the number of valid number values (i.e., not null, NaN, or
        undefined) in the specified iterable; accepts an accessor.

        See more informations `here <https://d3js.org/d3-array/summarize#count>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (iterable, accessor))))
        return d3(f"d3.count({arguments})")

    @staticmethod
    def min(iterable=None, accessor=None):
        """
        Examples · Source · Returns the minimum value in the given iterable using natural
        order.
        .. code:: javascript

            d3.min([3, 2, 1, 1, 6, 2, 4]) // 1

        Unlike Math.min, d3.min does not coerce the inputs to numbers; for example, the minimum
        of the strings ["20", "3"] is "20", while the minimum of the numbers [20, 3] is 3.
        .. code:: javascript

            d3.min(["bob", "alice", "carol"]) // "alice"

        .. code:: javascript

            d3.min([new Date("2018-01-01"), new Date("2011-03-09")]) // 2011-03-09

        Also unlike Math.min, this method ignores undefined, null and NaN values, which is
        useful for ignoring missing data.
        .. code:: javascript

            d3.min([3, 2, 1, NaN, 4]) // 1

        An optional accessor function may be specified, which is similar to calling Array.from
        before computing the minimum value. The accessor function is repeatedly passed an
        element from the given iterable (often d) and the zero-based index (i).
        .. code:: javascript

            d3.min(alphabet, (d) => d.frequency) // 0.00074

        Because undefined values are ignored, you can use the accessor function to ignore
        values. For example, to get the frequency of the least-common letter than is not Z:
        .. code:: javascript

            d3.min(alphabet, (d) => d.letter === "Z" ? NaN : d.frequency) // 0.00095

        If the iterable contains no comparable values, returns undefined.
        .. code:: javascript

            d3.min([]) // undefined

        .. code:: javascript

            d3.min(alphabet, (d) => d.doesnotexist) // undefined

        See also extent and least.

        See more informations `here <https://d3js.org/d3-array/summarize#min>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (iterable, accessor))))
        return d3(f"d3.min({arguments})")

    @staticmethod
    def minIndex(iterable=None, accessor=None):
        """
        Source · Like min, but returns the index of the minimum value rather than the value
        itself.
        .. code:: javascript

            d3.minIndex([3, 2, 1, 1, 6, 2, 4]) // 2

        This method can find the least element according to the given accessor, similar to
        least:
        .. code:: javascript

            d3.minIndex(alphabet, (d) => d.frequency) // 25

        .. code:: javascript

            alphabet[d3.minIndex(alphabet, (d) => d.frequency)] // {letter: "Z", frequency: 0.00074}

        See also leastIndex.

        See more informations `here <https://d3js.org/d3-array/summarize#minIndex>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (iterable, accessor))))
        return d3(f"d3.minIndex({arguments})")

    @staticmethod
    def max(iterable=None, accessor=None):
        """
        Examples · Source · Returns the maximum value in the given iterable using natural
        order.
        .. code:: javascript

            d3.max([3, 2, 1, 1, 6, 2, 4]) // 6

        Unlike Math.max, d3.max does not coerce the inputs to numbers; for example, the maximum
        of the strings ["20", "3"] is "3", while the maximum of the numbers [20, 3] is 20.
        .. code:: javascript

            d3.max(["bob", "alice", "carol"]) // "carol"

        .. code:: javascript

            d3.max([new Date("2018-01-01"), new Date("2011-03-09")]) // 2018-01-01

        Also unlike Math.max, this method ignores undefined, null and NaN values, which is
        useful for ignoring missing data.
        .. code:: javascript

            d3.max([3, 2, 1, NaN, 4]) // 4

        An optional accessor function may be specified, which is similar to calling Array.from
        before computing the maximum value. The accessor function is repeatedly passed an
        element from the given iterable (often d) and the zero-based index (i).
        .. code:: javascript

            d3.max(alphabet, (d) => d.frequency) // 0.12702

        Because undefined values are ignored, you can use the accessor function to ignore
        values. For example, to get the frequency of the most-common letter than is not E:
        .. code:: javascript

            d3.max(alphabet, (d) => d.letter === "E" ? NaN : d.frequency) // 0.09056

        If the iterable contains no comparable values, returns undefined.
        .. code:: javascript

            d3.max([]) // undefined

        .. code:: javascript

            d3.max(alphabet, (d) => d.doesnotexist) // undefined

        See also extent and greatest.

        See more informations `here <https://d3js.org/d3-array/summarize#max>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (iterable, accessor))))
        return d3(f"d3.max({arguments})")

    @staticmethod
    def maxIndex(iterable=None, accessor=None):
        """
        Source · Like max, but returns the index of the maximum value rather than the value
        itself.
        .. code:: javascript

            d3.maxIndex([3, 2, 1, 1, 6, 2, 4]) // 2

        This method can find the greatest element according to the given accessor, similar to
        greatest:
        .. code:: javascript

            d3.maxIndex(alphabet, (d) => d.frequency) // 0

        .. code:: javascript

            alphabet[d3.maxIndex(alphabet, (d) => d.frequency)] // {letter: "E", frequency: 0.12702}

        See also greatestIndex.

        See more informations `here <https://d3js.org/d3-array/summarize#maxIndex>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (iterable, accessor))))
        return d3(f"d3.maxIndex({arguments})")

    @staticmethod
    def least(iterable=None, comparator=None):
        """
        Examples · Source · Returns the least element of the specified iterable according to
        the specified comparator.
        .. code:: javascript

            d3.least(alphabet, (a, b) => a.frequency - b.frequency) // {letter: "Z", frequency: 0.00074}

        .. code:: javascript

            d3.least(alphabet, (a, b) => b.frequency - a.frequency) // {letter: "E", frequency: 0.12702}

        If the comparator takes a single argument, is interpreted as an accessor and the
        returned elements are compared using natural order.
        .. code:: javascript

            d3.least(alphabet, (d) => d.frequency) // {letter: "Z", frequency: 0.00074}

        .. code:: javascript

            d3.least(alphabet, (d) => -d.frequency) // {letter: "E", frequency: 0.12702}

        If comparator is not specified, it defaults to ascending.
        .. code:: javascript

            d3.least(alphabet.map((d) => d.frequency)) // 0.00074

        If the given iterable contains no comparable elements (i.e., the comparator returns NaN
        when comparing each element to itself), returns undefined.
        .. code:: javascript

            d3.least([]) // undefined

        This function is similar to min, except it allows the use of a comparator rather than
        an accessor.

        See more informations `here <https://d3js.org/d3-array/summarize#least>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (iterable, comparator))))
        return d3(f"d3.least({arguments})")

    @staticmethod
    def leastIndex(iterable=None, comparator=None):
        """
        Source · Returns the index of the least element of the specified iterable according to
        the specified comparator or accessor. If the given iterable contains no comparable
        elements (i.e., the comparator returns NaN when comparing each element to itself),
        returns -1. If comparator is not specified, it defaults to ascending. For example:
        .. code:: javascript

            const array = [{foo: 42}, {foo: 91}];
            d3.leastIndex(array, (a, b) => a.foo - b.foo); // 0
            d3.leastIndex(array, (a, b) => b.foo - a.foo); // 1
            d3.leastIndex(array, (d) => d.foo); // 0

        This function is similar to minIndex, except it allows the use of a comparator rather
        than an accessor.

        See more informations `here <https://d3js.org/d3-array/summarize#leastIndex>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (iterable, comparator))))
        return d3(f"d3.leastIndex({arguments})")

    @staticmethod
    def greatest(iterable=None, comparator=None):
        """
        Examples · Source · Returns the greatest element of the specified iterable according to
        the specified comparator or accessor. If the given iterable contains no comparable
        elements (i.e., the comparator returns NaN when comparing each element to itself),
        returns undefined. If comparator is not specified, it defaults to ascending. For
        example:
        .. code:: javascript

            const array = [{foo: 42}, {foo: 91}];
            d3.greatest(array, (a, b) => a.foo - b.foo); // {foo: 91}
            d3.greatest(array, (a, b) => b.foo - a.foo); // {foo: 42}
            d3.greatest(array, (d) => d.foo); // {foo: 91}

        This function is similar to max, except it allows the use of a comparator rather than
        an accessor.

        See more informations `here <https://d3js.org/d3-array/summarize#greatest>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (iterable, comparator))))
        return d3(f"d3.greatest({arguments})")

    @staticmethod
    def greatestIndex(iterable=None, comparator=None):
        """
        Source · Returns the index of the greatest element of the specified iterable according
        to the specified comparator or accessor. If the given iterable contains no comparable
        elements (i.e., the comparator returns NaN when comparing each element to itself),
        returns -1. If comparator is not specified, it defaults to ascending. For example:
        .. code:: javascript

            const array = [{foo: 42}, {foo: 91}];
            d3.greatestIndex(array, (a, b) => a.foo - b.foo); // 1
            d3.greatestIndex(array, (a, b) => b.foo - a.foo); // 0
            d3.greatestIndex(array, (d) => d.foo); // 1

        This function is similar to maxIndex, except it allows the use of a comparator rather
        than an accessor.

        See more informations `here <https://d3js.org/d3-array/summarize#greatestIndex>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (iterable, comparator))))
        return d3(f"d3.greatestIndex({arguments})")

    @staticmethod
    def extent(iterable=None, accessor=None):
        """
        Examples · Source · Returns the minimum and maximum value in the given iterable using
        natural order.
        .. code:: javascript

            d3.extent([3, 2, 1, 1, 6, 2, 4]) // [1, 6]

        An optional accessor function may be specified, which is equivalent to calling
        Array.from before computing the extent.
        .. code:: javascript

            d3.extent(alphabet, (d) => d.frequency) // [0.00074, 0.12702]

        If the iterable contains no comparable values, returns [undefined, undefined].
        .. code:: javascript

            d3.extent(alphabet, (d) => d.doesnotexist) // [undefined, undefined]


        See more informations `here <https://d3js.org/d3-array/summarize#extent>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (iterable, accessor))))
        return d3(f"d3.extent({arguments})")

    @staticmethod
    def mode(iterable=None, accessor=None):
        """
        Examples · Source · Returns the mode of the given iterable, i.e. the value which
        appears the most often. Ignores undefined, null and NaN values.
        .. code:: javascript

            d3.mode([1, 2, 2, 2, 3, 3]) // 2

        An optional accessor function may be specified, which is equivalent to calling
        Array.from before computing the mode.
        .. code:: javascript

            d3.mode(penguins, (d) => d.island) // "Biscoe"

        In case of equality, returns the first of the relevant values. If the iterable contains
        no comparable values, returns undefined.

        See more informations `here <https://d3js.org/d3-array/summarize#mode>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (iterable, accessor))))
        return d3(f"d3.mode({arguments})")

    @staticmethod
    def sum(iterable=None, accessor=None):
        """
        Examples · Source · Returns the sum of the given iterable of numbers. Ignores
        undefined, null and NaN values.
        .. code:: javascript

            d3.sum([1, 2, 2, 2, NaN, 3, null]) // 10

        An optional accessor function may be specified, which is equivalent to calling
        Array.from before computing the sum.
        .. code:: javascript

            d3.sum(penguins, (d) => d.body_mass_g) // 1437000

        If the iterable contains no numbers, returns 0. See also fsum.

        See more informations `here <https://d3js.org/d3-array/summarize#sum>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (iterable, accessor))))
        return d3(f"d3.sum({arguments})")

    @staticmethod
    def mean(iterable=None, accessor=None):
        """
        Examples · Source · Returns the mean of the given iterable of numbers. Ignores
        undefined, null and NaN values.
        .. code:: javascript

            d3.mean([1, 2, 2, 2, NaN, 3, null]) // 2

        An optional accessor function may be specified, which is equivalent to calling
        Array.from before computing the mean.
        .. code:: javascript

            d3.mean(penguins, (d) => d.body_mass_g) // 4201.754385964912

        If the iterable contains no numbers, returns undefined.

        See more informations `here <https://d3js.org/d3-array/summarize#mean>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (iterable, accessor))))
        return d3(f"d3.mean({arguments})")

    @staticmethod
    def median(iterable=None, accessor=None):
        """
        Examples · Source · Returns the median of the given iterable of numbers using the R-7
        method. Ignores undefined, null and NaN values.
        .. code:: javascript

            d3.median([1, 2, 2, 2, NaN, 3, null]) // 2

        An optional accessor function may be specified, which is equivalent to calling
        Array.from before computing the median.
        .. code:: javascript

            d3.median(penguins, (d) => d.body_mass_g) // 4050

        If the iterable contains no numbers, returns undefined.

        See more informations `here <https://d3js.org/d3-array/summarize#median>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (iterable, accessor))))
        return d3(f"d3.median({arguments})")

    @staticmethod
    def medianIndex(iterable=None, accessor=None):
        """
        Examples · Source · Returns the median of the given iterable of numbers using the R-7
        method. Ignores undefined, null and NaN values.
        .. code:: javascript

            d3.median([1, 2, 2, 2, NaN, 3, null]) // 2

        An optional accessor function may be specified, which is equivalent to calling
        Array.from before computing the median.
        .. code:: javascript

            d3.median(penguins, (d) => d.body_mass_g) // 4050

        If the iterable contains no numbers, returns undefined.

        See more informations `here <https://d3js.org/d3-array/summarize#median>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (iterable, accessor))))
        return d3(f"d3.medianIndex({arguments})")

    @staticmethod
    def cumsum(iterable=None, accessor=None):
        """
        Examples · Source · Returns the cumulative sum of the given iterable of numbers, as a
        Float64Array of the same length.
        .. code:: javascript

            d3.cumsum([1, 1, 2, 3, 5]) // [1, 2, 4, 7, 12]

        An optional accessor function may be specified, which is equivalent to calling
        Array.from before computing the cumulative sum.
        .. code:: javascript

            d3.cumsum(penguins, (d) => d.body_mass_g) // [3750, 7550, 10800, 10800, …]

        This method ignores undefined and NaN values; this is useful for ignoring missing data.
        If the iterable contains no numbers, returns zeros. See also fcumsum.

        See more informations `here <https://d3js.org/d3-array/summarize#cumsum>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (iterable, accessor))))
        return d3(f"d3.cumsum({arguments})")

    @staticmethod
    def quantile(iterable=None, p=None, accessor=None):
        """
        Examples · Source · Returns the p-quantile of the given iterable of numbers, where p is
        a number in the range [0, 1]. For example, the median can be computed using p = 0.5,
        the first quartile at p = 0.25, and the third quartile at p = 0.75. This particular
        implementation uses the R-7 method, which is the default for the R programming language
        and Excel.
        .. code:: javascript

            const numbers = [0, 10, 30];
            d3.quantile(numbers, 0); // 0
            d3.quantile(numbers, 0.5); // 10
            d3.quantile(numbers, 1); // 30
            d3.quantile(numbers, 0.25); // 5
            d3.quantile(numbers, 0.75); // 20
            d3.quantile(numbers, 0.1); // 2

        An optional accessor function may be specified, which is equivalent to calling
        array.map before computing the quantile.

        See more informations `here <https://d3js.org/d3-array/summarize#quantile>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (iterable, p, accessor))))
        return d3(f"d3.quantile({arguments})")

    @staticmethod
    def quantileIndex(array=None, p=None, accessor=None):
        """
        Source · Similar to quantile, but returns the index to the left of p.

        See more informations `here <https://d3js.org/d3-array/summarize#quantileIndex>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (array, p, accessor))))
        return d3(f"d3.quantileIndex({arguments})")

    @staticmethod
    def quantileSorted(array=None, p=None, accessor=None):
        """
        Examples · Source · Similar to quantile, but expects the input to be a sorted array of
        values. In contrast with quantile, the accessor is only called on the elements needed
        to compute the quantile.

        See more informations `here <https://d3js.org/d3-array/summarize#quantileSorted>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (array, p, accessor))))
        return d3(f"d3.quantileSorted({arguments})")

    @staticmethod
    def rank(iterable=None, comparator=None):
        """
        Examples · Source · Returns an array with the rank of each value in the iterable, i.e.
        the zero-based index of the value when the iterable is sorted. Nullish values are
        sorted to the end and ranked NaN. An optional comparator or accessor function may be
        specified; the latter is equivalent to calling array.map before computing the ranks. If
        comparator is not specified, it defaults to ascending. Ties (equivalent values) all get
        the same rank, defined as the first time the value is found.
        .. code:: javascript

            d3.rank([{x: 1}, {}, {x: 2}, {x: 0}], d => d.x); // [1, NaN, 2, 0]
            d3.rank(["b", "c", "b", "a"]); // [1, 3, 1, 0]
            d3.rank([1, 2, 3], d3.descending); // [2, 1, 0]


        See more informations `here <https://d3js.org/d3-array/summarize#rank>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (iterable, comparator))))
        return d3(f"d3.rank({arguments})")

    @staticmethod
    def variance(iterable=None, accessor=None):
        """
        Examples · Source · Returns an unbiased estimator of the population variance of the
        given iterable of numbers using Welford’s algorithm. If the iterable has fewer than two
        numbers, returns undefined. An optional accessor function may be specified, which is
        equivalent to calling Array.from before computing the variance. This method ignores
        undefined and NaN values; this is useful for ignoring missing data.

        See more informations `here <https://d3js.org/d3-array/summarize#variance>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (iterable, accessor))))
        return d3(f"d3.variance({arguments})")

    @staticmethod
    def deviation(iterable=None, accessor=None):
        """
        Examples · Source · Returns the standard deviation, defined as the square root of the
        bias-corrected variance, of the given iterable of numbers. If the iterable has fewer
        than two numbers, returns undefined. An optional accessor function may be specified,
        which is equivalent to calling Array.from before computing the standard deviation. This
        method ignores undefined and NaN values; this is useful for ignoring missing data.

        See more informations `here <https://d3js.org/d3-array/summarize#deviation>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (iterable, accessor))))
        return d3(f"d3.deviation({arguments})")

    @staticmethod
    def every(iterable=None, test=None):
        """
        Source · Returns true if the given test function returns true for every value in the
        given iterable. This method returns as soon as test returns a non-truthy value or all
        values are iterated over. Equivalent to array.every:
        .. code:: javascript

            d3.every(new Set([1, 3, 5, 7]), x => x & 1) // true


        See more informations `here <https://d3js.org/d3-array/summarize#every>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (iterable, test))))
        return d3(f"d3.every({arguments})")

    @staticmethod
    def some(iterable=None, test=None):
        """
        Source · Returns true if the given test function returns true for any value in the
        given iterable. This method returns as soon as test returns a truthy value or all
        values are iterated over. Equivalent to array.some:
        .. code:: javascript

            d3.some(new Set([0, 2, 3, 4]), x => x & 1) // true


        See more informations `here <https://d3js.org/d3-array/summarize#some>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (iterable, test))))
        return d3(f"d3.some({arguments})")

    @staticmethod
    def ticks(start=None, stop=None, count=None):
        """
        Examples · Source · Returns an array of approximately count + 1 uniformly-spaced,
        nicely-rounded values between start and stop (inclusive). Each value is a power of ten
        multiplied by 1, 2 or 5.
        .. code:: javascript

            d3.ticks(1, 9, 5) // [2, 4, 6, 8]

        .. code:: javascript

            d3.ticks(1, 9, 20) // [1, 1.5, 2, 2.5, 3, 3.5, 4, 4.5, 5, 5.5, 6, 6.5, 7, 7.5, 8, 8.5, 9]

        Ticks are inclusive in the sense that they may include the specified start and stop
        values if (and only if) they are exact, nicely-rounded values consistent with the
        inferred step. More formally, each returned tick t satisfies start ≤ t and t ≤ stop.

        See more informations `here <https://d3js.org/d3-array/ticks#ticks>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (start, stop, count))))
        return d3(f"d3.ticks({arguments})")

    @staticmethod
    def tickIncrement(start=None, stop=None, count=None):
        """
        Source · Like d3.tickStep, except requires that start is always less than or equal to
        stop, and if the tick step for the given start, stop and count would be less than one,
        returns the negative inverse tick step instead.
        .. code:: javascript

            d3.tickIncrement(1, 9, 5) // 2

        .. code:: javascript

            d3.tickIncrement(1, 9, 20) // -2, meaning a tick step 0.5

        This method is always guaranteed to return an integer, and is used by d3.ticks to
        guarantee that the returned tick values are represented as precisely as possible in
        IEEE 754 floating point.

        See more informations `here <https://d3js.org/d3-array/ticks#tickIncrement>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (start, stop, count))))
        return d3(f"d3.tickIncrement({arguments})")

    @staticmethod
    def tickStep(start=None, stop=None, count=None):
        """
        Source · Returns the difference between adjacent tick values if the same arguments were
        passed to d3.ticks: a nicely-rounded value that is a power of ten multiplied by 1, 2 or
        5.
        .. code:: javascript

            d3.tickStep(1, 9, 5) // 2

        If stop is less than start, may return a negative tick step to indicate descending
        ticks.
        .. code:: javascript

            d3.tickStep(9, 1, 5) // -2

        Note that due to the limited precision of IEEE 754 floating point, the returned value
        may not be exact decimals; use d3-format to format numbers for human consumption.

        See more informations `here <https://d3js.org/d3-array/ticks#tickStep>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (start, stop, count))))
        return d3(f"d3.tickStep({arguments})")

    @staticmethod
    def nice(start=None, stop=None, count=None):
        """
        Source · Returns a new interval [niceStart, niceStop] covering the given interval
        [start, stop] and where niceStart and niceStop are guaranteed to align with the
        corresponding tick step.
        .. code:: javascript

            d3.nice(1, 9, 5) // [0, 10]

        Like d3.tickIncrement, this requires that start is less than or equal to stop.

        See more informations `here <https://d3js.org/d3-array/ticks#nice>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (start, stop, count))))
        return d3(f"d3.nice({arguments})")

    @staticmethod
    def range(start=None, stop=None, step=None):
        """
        Examples · Source · Returns an array containing an arithmetic progression, similar to
        the Python built-in range. This method is often used to iterate over a sequence of
        uniformly-spaced numeric values, such as the indexes of an array or the ticks of a
        linear scale. (See also d3.ticks for nicely-rounded values.)
        .. code:: javascript

            d3.range(6) // [0, 1, 2, 3, 4, 5]

        If step is omitted, it defaults to 1. If start is omitted, it defaults to 0. The stop
        value is exclusive; it is not included in the result. If step is positive, the last
        element is the largest start + i * step less than stop; if step is negative, the last
        element is the smallest start + i * step greater than stop.
        .. code:: javascript

            d3.range(5, -1, -1) // [5, 4, 3, 2, 1, 0]

        If the returned array would contain an infinite number of values, an empty range is
        returned.
        .. code:: javascript

            d3.range(Infinity) // []

        The arguments are not required to be integers; however, the results are more
        predictable if they are. The values in the returned array are defined as start + i *
        step, where i is an integer from zero to one minus the total number of elements in the
        returned array.
        .. code:: javascript

            d3.range(0, 1, 0.2) // [0, 0.2, 0.4, 0.6000000000000001, 0.8]

        This behavior is due to IEEE 754 double-precision floating point, which defines 0.2 * 3
        = 0.6000000000000001. Use d3-format to format numbers for human consumption with
        appropriate rounding; see also linear.tickFormat in d3-scale. Likewise, if the returned
        array should have a specific length, consider using array.map on an integer range.
        .. code:: javascript

            d3.range(0, 1, 1 / 49) // 👎 returns 50 elements!

        .. code:: javascript

            d3.range(49).map((d) => d / 49) // 👍 returns 49 elements


        See more informations `here <https://d3js.org/d3-array/ticks#range>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (start, stop, step))))
        return d3(f"d3.range({arguments})")

    @staticmethod
    def cross(*iterables, reducer=None):
        """
        Examples · Source · Returns the Cartesian product of the specified iterables.
        .. code:: javascript

            d3.cross([1, 2], ["x", "y"]) // [[1, "x"], [1, "y"], [2, "x"], [2, "y"]]

        If a reducer is specified, it is invoked for each combination of elements from each of
        the given iterables, and returns the corresponding reduced value.
        .. code:: javascript

            d3.cross([1, 2], ["x", "y"], (a, b) => a + b) // ["1x", "1y", "2x", "2y"]


        See more informations `here <https://d3js.org/d3-array/transform#cross>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (*iterables, reducer))))
        return d3(f"d3.cross({arguments})")

    @staticmethod
    def merge(iterables=None):
        """
        Examples · Source · Merges the specified iterable of iterables into a new flat array.
        This method is similar to the built-in array.concat method, but is more convenient when
        you have an array of arrays or an iterable of iterables.
        .. code:: javascript

            d3.merge([[1], [2, 3]]) // [1, 2, 3]

        .. code:: javascript

            d3.merge(new Set([new Set([1]), new Set([2, 3])])) // [1, 2, 3]


        See more informations `here <https://d3js.org/d3-array/transform#merge>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (iterables,))))
        return d3(f"d3.merge({arguments})")

    @staticmethod
    def pairs(iterable=None, reducer=None):
        """
        Examples · Source · Returns an array of adjacent pairs of elements from the specified
        iterable, in order. If the specified iterable has fewer than two elements, returns the
        empty array.
        .. code:: javascript

            d3.pairs([1, 2, 3, 4]) // [[1, 2], [2, 3], [3, 4]]

        If a reducer function is specified, it is successively passed an element i - 1 and
        element i from the iterable.
        .. code:: javascript

            d3.pairs([1, 1, 2, 3, 5], (a, b) => b - a) // [0, 1, 1, 2]


        See more informations `here <https://d3js.org/d3-array/transform#pairs>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (iterable, reducer))))
        return d3(f"d3.pairs({arguments})")

    @staticmethod
    def transpose(matrix=None):
        """
        Examples · Source · Uses the zip operator as a two-dimensional matrix transpose.
        .. code:: javascript

            d3.transpose([["Alice", "Bob", "Carol"], [32, 13, 14]]) // [["Alice", 32], ["Bob", 13], ["Carol", 14]]

        .. code:: javascript

            d3.transpose([["Alice", 32], ["Bob", 13], ["Carol", 14]]) // [["Alice", "Bob", "Carol"], [32, 13, 14]]


        See more informations `here <https://d3js.org/d3-array/transform#transpose>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (matrix,))))
        return d3(f"d3.transpose({arguments})")

    @staticmethod
    def zip(*arrays):
        """
        Examples · Source · Returns an array of arrays, where the ith array contains the ith
        element from each of the argument arrays. The returned array is truncated in length to
        the shortest array in arrays. If arrays contains only a single array, the returned
        array contains one-element arrays. With no arguments, the returned array is empty.
        .. code:: javascript

            d3.zip(["Alice", "Bob", "Carol"], [32, 13, 14]) // [["Alice", 32], ["Bob", 13], ["Carol", 14]]


        See more informations `here <https://d3js.org/d3-array/transform#zip>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (*arrays,))))
        return d3(f"d3.zip({arguments})")

    @staticmethod
    def filter(iterable=None, test=None):
        """
        Source · Returns a new array containing the values from iterable, in order, for which
        the given test function returns true.
        .. code:: javascript

            d3.filter(new Set([0, 2, 3, 4]), (d) => d & 1) // [3]

        Like array.filter, but works with any iterable.

        See more informations `here <https://d3js.org/d3-array/transform#filter>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (iterable, test))))
        return d3(f"d3.filter({arguments})")

    @staticmethod
    def map(iterable=None, mapper=None):
        """
        Source · Returns a new array containing the mapped values from iterable, in order, as
        defined by given mapper function.
        .. code:: javascript

            d3.map(new Set([0, 2, 3, 4]), (d) => d & 1) // [0, 0, 1, 0]

        Like array.map, but works with any iterable.

        See more informations `here <https://d3js.org/d3-array/transform#map>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (iterable, mapper))))
        return d3(f"d3.map({arguments})")

    @staticmethod
    def reduce(iterable=None, reducer=None, initialValue=None):
        """
        Source · Returns the reduced value defined by given reducer function, which is
        repeatedly invoked for each value in iterable, being passed the current reduced value
        and the next value.
        .. code:: javascript

            d3.reduce(new Set([0, 2, 3, 4]), (p, v) => p + v, 0) // 9

        Like array.reduce, but works with any iterable.

        See more informations `here <https://d3js.org/d3-array/transform#reduce>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (iterable, reducer, initialValue))))
        return d3(f"d3.reduce({arguments})")

    @staticmethod
    def brushSelection(node=None):
        """
        Examples · Source · Returns the current brush selection for the specified node.
        Internally, an element’s brush state is stored as element.__brush; however, you should
        use this method rather than accessing it directly. If the given node has no selection,
        returns null. Otherwise, the selection is defined as an array of numbers. For a
        two-dimensional brush, it is [[x0, y0], [x1, y1]], where x0 is the minimum x-value, y0
        is the minimum y-value, x1 is the maximum x-value, and y1 is the maximum y-value. For
        an x-brush, it is [x0, x1]; for a y-brush, it is [y0, y1].

        See more informations `here <https://d3js.org/d3-brush#brushSelection>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (node,))))
        return d3(f"d3.brushSelection({arguments})")

    @staticmethod
    def chordDirected():
        """
        Examples · Source · A chord layout for unidirectional flows. The chord from i to j is
        generated from the value in matrix[i][j] only.

        See more informations `here <https://d3js.org/d3-chord/chord#chordDirected>`_.
        """
        return d3("d3.chordDirected()")

    @staticmethod
    def chordTranspose():
        """
        Source · A transposed chord layout. Useful to highlight outgoing (rather than incoming)
        flows.

        See more informations `here <https://d3js.org/d3-chord/chord#chordTranspose>`_.
        """
        return d3("d3.chordTranspose()")

    @staticmethod
    def lab(color=None):
        """
        .. code:: javascript

            d3.lab("red") // {l: 54.29173376861782, a: 80.8124553179771, b: 69.88504032350531, opacity: 1}

        Source · Constructs a new CIELAB color. The channel values are exposed as l, a and b
        properties on the returned instance. Use the CIELAB color picker to explore this color
        space. The value of l is typically in the range [0, 100], while a and b are typically
        in [-160, +160].
        If l, a and b are specified, these represent the channel values of the returned color;
        an opacity may also be specified. If a CSS Color Module Level 3 specifier string is
        specified, it is parsed and then converted to the CIELAB color space. See color for
        examples. If a color instance is specified, it is converted to the RGB color space
        using color.rgb and then converted to CIELAB. (Colors already in the CIELAB color space
        skip the conversion to RGB, and colors in the HCL color space are converted directly to
        CIELAB.)

        See more informations `here <https://d3js.org/d3-color#lab>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (color,))))
        return d3(f"d3.lab({arguments})")

    @staticmethod
    def gray(l=None, opacity=None):
        """
        .. code:: javascript

            d3.gray(50) // {l: 50, a: 0, b: 0, opacity: 1}

        Source · Constructs a new CIELAB color with the specified l value and a = b = 0.

        See more informations `here <https://d3js.org/d3-color#gray>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (l, opacity))))
        return d3(f"d3.gray({arguments})")

    @staticmethod
    def hcl(color=None):
        """
        .. code:: javascript

            d3.hcl("yellow") // {h: 99.57458688693687, c: 94.70776566727464, l: 97.60712516622824, opacity: 1}

        Source · Equivalent to d3.lch, but with reversed argument order.

        See more informations `here <https://d3js.org/d3-color#hcl>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (color,))))
        return d3(f"d3.hcl({arguments})")

    @staticmethod
    def lch(color=None):
        """
        .. code:: javascript

            d3.lch("yellow") // {h: 99.57458688693687, c: 94.70776566727464, l: 97.60712516622824, opacity: 1}

        Source · Constructs a new CIELChab color. The channel values are exposed as l, c and h
        properties on the returned instance. Use the CIELChab color picker to explore this
        color space. The value of l is typically in the range [0, 100], c is typically in [0,
        230], and h is typically in [0, 360).
        If l, c, and h are specified, these represent the channel values of the returned color;
        an opacity may also be specified. If a CSS Color Module Level 3 specifier string is
        specified, it is parsed and then converted to CIELChab color space. See color for
        examples. If a color instance is specified, it is converted to the RGB color space
        using color.rgb and then converted to CIELChab. (Colors already in CIELChab color space
        skip the conversion to RGB, and colors in CIELAB color space are converted directly to
        CIELChab.)

        See more informations `here <https://d3js.org/d3-color#lch>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (color,))))
        return d3(f"d3.lch({arguments})")

    @staticmethod
    def cubehelix(color=None):
        """
        .. code:: javascript

            d3.cubehelix("yellow") // {h: 56.942171677321085, s: 4.614386868039714, l: 0.8900004504279901, opacity: 1}

        Source · Constructs a new Cubehelix color. The channel values are exposed as h, s and l
        properties on the returned instance.
        If h, s and l are specified, these represent the channel values of the returned color;
        an opacity may also be specified. If a CSS Color Module Level 3 specifier string is
        specified, it is parsed and then converted to the Cubehelix color space. See color for
        examples. If a color instance is specified, it is converted to the RGB color space
        using color.rgb and then converted to Cubehelix. (Colors already in the Cubehelix color
        space skip the conversion to RGB.)

        See more informations `here <https://d3js.org/d3-color#cubehelix>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (color,))))
        return d3(f"d3.cubehelix({arguments})")

    @staticmethod
    def dragDisable(window=None):
        """
        Source · Prevents native drag-and-drop and text selection on the specified window. As
        an alternative to preventing the default action of mousedown events (see #9), this
        method prevents undesirable default actions following mousedown. In supported browsers,
        this means capturing dragstart and selectstart events, preventing the associated
        default actions, and immediately stopping their propagation. In browsers that do not
        support selection events, the user-select CSS property is set to none on the document
        element. This method is intended to be called on mousedown, followed by dragEnable on
        mouseup.

        See more informations `here <https://d3js.org/d3-drag#dragDisable>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (window,))))
        return d3(f"d3.dragDisable({arguments})")

    @staticmethod
    def dragEnable(window=None, noclick=None):
        """
        Source · Allows native drag-and-drop and text selection on the specified window; undoes
        the effect of dragDisable. This method is intended to be called on mouseup, preceded by
        dragDisable on mousedown. If noclick is true, this method also temporarily suppresses
        click events. The suppression of click events expires after a zero-millisecond timeout,
        such that it only suppress the click event that would immediately follow the current
        mouseup event, if any.

        See more informations `here <https://d3js.org/d3-drag#dragEnable>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (window, noclick))))
        return d3(f"d3.dragEnable({arguments})")

    @staticmethod
    def csvParse(string=None, row=None):
        """
        Equivalent to d3.dsvFormat(",").parse.

        See more informations `here <https://d3js.org/d3-dsv#csvParse>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (string, row))))
        return d3(f"d3.csvParse({arguments})")

    @staticmethod
    def csvParseRows(string=None, row=None):
        """
        Equivalent to d3.dsvFormat(",").parseRows.

        See more informations `here <https://d3js.org/d3-dsv#csvParseRows>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (string, row))))
        return d3(f"d3.csvParseRows({arguments})")

    @staticmethod
    def csvFormat(rows=None, columns=None):
        """
        Equivalent to d3.dsvFormat(",").format.

        See more informations `here <https://d3js.org/d3-dsv#csvFormat>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (rows, columns))))
        return d3(f"d3.csvFormat({arguments})")

    @staticmethod
    def csvFormatBody(rows=None, columns=None):
        """
        Equivalent to d3.dsvFormat(",").formatBody.

        See more informations `here <https://d3js.org/d3-dsv#csvFormatBody>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (rows, columns))))
        return d3(f"d3.csvFormatBody({arguments})")

    @staticmethod
    def csvFormatRows(rows=None):
        """
        Equivalent to d3.dsvFormat(",").formatRows.

        See more informations `here <https://d3js.org/d3-dsv#csvFormatRows>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (rows,))))
        return d3(f"d3.csvFormatRows({arguments})")

    @staticmethod
    def csvFormatRow(row=None):
        """
        Equivalent to d3.dsvFormat(",").formatRow.

        See more informations `here <https://d3js.org/d3-dsv#csvFormatRow>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (row,))))
        return d3(f"d3.csvFormatRow({arguments})")

    @staticmethod
    def csvFormatValue(value=None):
        """
        Equivalent to d3.dsvFormat(",").formatValue.

        See more informations `here <https://d3js.org/d3-dsv#csvFormatValue>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (value,))))
        return d3(f"d3.csvFormatValue({arguments})")

    @staticmethod
    def tsvParse(string=None, row=None):
        """
        Equivalent to d3.dsvFormat("\t").parse.

        See more informations `here <https://d3js.org/d3-dsv#tsvParse>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (string, row))))
        return d3(f"d3.tsvParse({arguments})")

    @staticmethod
    def tsvParseRows(string=None, row=None):
        """
        Equivalent to d3.dsvFormat("\t").parseRows.

        See more informations `here <https://d3js.org/d3-dsv#tsvParseRows>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (string, row))))
        return d3(f"d3.tsvParseRows({arguments})")

    @staticmethod
    def tsvFormat(rows=None, columns=None):
        """
        Equivalent to d3.dsvFormat("\t").format.

        See more informations `here <https://d3js.org/d3-dsv#tsvFormat>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (rows, columns))))
        return d3(f"d3.tsvFormat({arguments})")

    @staticmethod
    def tsvFormatBody(rows=None, columns=None):
        """
        Equivalent to d3.dsvFormat("\t").formatBody.

        See more informations `here <https://d3js.org/d3-dsv#tsvFormatBody>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (rows, columns))))
        return d3(f"d3.tsvFormatBody({arguments})")

    @staticmethod
    def tsvFormatRows(rows=None):
        """
        Equivalent to d3.dsvFormat("\t").formatRows.

        See more informations `here <https://d3js.org/d3-dsv#tsvFormatRows>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (rows,))))
        return d3(f"d3.tsvFormatRows({arguments})")

    @staticmethod
    def tsvFormatRow(row=None):
        """
        Equivalent to d3.dsvFormat("\t").formatRow.

        See more informations `here <https://d3js.org/d3-dsv#tsvFormatRow>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (row,))))
        return d3(f"d3.tsvFormatRow({arguments})")

    @staticmethod
    def tsvFormatValue(value=None):
        """
        Equivalent to d3.dsvFormat("\t").formatValue.

        See more informations `here <https://d3js.org/d3-dsv#tsvFormatValue>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (value,))))
        return d3(f"d3.tsvFormatValue({arguments})")

    @staticmethod
    def autoType(object=None):
        """
        Source · Given an object (or array) representing a parsed row, infers the types of
        values on the object and coerces them accordingly, returning the mutated object. This
        function is intended to be used as a row accessor function in conjunction with
        dsv.parse and dsv.parseRows. For example, consider the following CSV file:
        .. code:: javascript

            Year,Make,Model,Length
            1997,Ford,E350,2.34
            2000,Mercury,Cougar,2.38

        When used with d3.csvParse,
        .. code:: javascript

            d3.csvParse(string, d3.autoType)

        the resulting JavaScript array is:
        .. code:: javascript

            [
              {"Year": 1997, "Make": "Ford", "Model": "E350", "Length": 2.34},
              {"Year": 2000, "Make": "Mercury", "Model": "Cougar", "Length": 2.38}
            ]

        Type inference works as follows. For each value in the given object, the trimmed value
        is computed; the value is then re-assigned as follows:
        Values with leading zeroes may be coerced to numbers; for example "08904" coerces to
        8904. However, extra characters such as commas or units (e.g., "$1.00", "(123)",
        "1,234" or "32px") will prevent number coercion, resulting in a string.
        Date strings must be in ECMAScript’s subset of the ISO 8601 format. When a date-only
        string such as YYYY-MM-DD is specified, the inferred time is midnight UTC; however, if
        a date-time string such as YYYY-MM-DDTHH:MM is specified without a time zone, it is
        assumed to be local time.
        Automatic type inference is primarily intended to provide safe, predictable behavior in
        conjunction with dsv.format and dsv.formatRows for common JavaScript types. If you need
        different behavior, you should implement your own row accessor function.
        For more, see the d3.autoType notebook.

        See more informations `here <https://d3js.org/d3-dsv#autoType>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (object,))))
        return d3(f"d3.autoType({arguments})")

    @staticmethod
    def ease(t=None):
        """
        Given the specified normalized time t, typically in the range [0,1], returns the
        “eased” time tʹ, also typically in [0,1]. 0 represents the start of the animation and 1
        represents the end. A good implementation returns 0 if t = 0 and 1 if t = 1. For
        example, to apply easeCubic easing:
        .. code:: javascript

            const te = d3.easeCubic(t);

        To apply custom elastic easing, create your easing function before the animation
        starts:
        .. code:: javascript

            const ease = d3.easeElastic.period(0.4);

        Then during the animation, apply the easing function:
        .. code:: javascript

            const te = ease(t);

        See also transition.ease.

        See more informations `here <https://d3js.org/d3-ease#_ease>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (t,))))
        return d3(f"d3.ease({arguments})")

    @staticmethod
    def easeLinear():
        """
        Source · Linear easing; the identity function; linear(t) returns t.

        See more informations `here <https://d3js.org/d3-ease#easeLinear>`_.
        """
        return d3("d3.easeLinear()")

    @staticmethod
    def easeQuadIn():
        """
        Quadratic easing; equivalent to easePolyIn.exponent(2).
        Reverse quadratic easing; equivalent to 1 - easeQuadIn(1 - t). Also equivalent to
        easePolyOut.exponent(2).
        Symmetric quadratic easing; scales easeQuadIn for t in 0–0.5 and easeQuadOut for t in
        0.5–1. Also equivalent to easePoly.exponent(2).

        See more informations `here <https://d3js.org/d3-ease#easeQuadIn>`_.
        """
        return d3("d3.easeQuadIn()")

    @staticmethod
    def easeQuadOut():
        """
        Reverse quadratic easing; equivalent to 1 - easeQuadIn(1 - t). Also equivalent to
        easePolyOut.exponent(2).
        Symmetric quadratic easing; scales easeQuadIn for t in 0–0.5 and easeQuadOut for t in
        0.5–1. Also equivalent to easePoly.exponent(2).

        See more informations `here <https://d3js.org/d3-ease#easeQuadOut>`_.
        """
        return d3("d3.easeQuadOut()")

    @staticmethod
    def easeQuad():
        """
        Source · Alias for easeQuadInOut.
        Quadratic easing; equivalent to easePolyIn.exponent(2).
        Reverse quadratic easing; equivalent to 1 - easeQuadIn(1 - t). Also equivalent to
        easePolyOut.exponent(2).
        Symmetric quadratic easing; scales easeQuadIn for t in 0–0.5 and easeQuadOut for t in
        0.5–1. Also equivalent to easePoly.exponent(2).

        See more informations `here <https://d3js.org/d3-ease#easeQuad>`_.
        """
        return d3("d3.easeQuad()")

    @staticmethod
    def easeQuadInOut():
        """
        Symmetric quadratic easing; scales easeQuadIn for t in 0–0.5 and easeQuadOut for t in
        0.5–1. Also equivalent to easePoly.exponent(2).

        See more informations `here <https://d3js.org/d3-ease#easeQuadInOut>`_.
        """
        return d3("d3.easeQuadInOut()")

    @staticmethod
    def easeCubicIn():
        """
        Cubic easing; equivalent to easePolyIn.exponent(3).
        Reverse cubic easing; equivalent to 1 - easeCubicIn(1 - t). Also equivalent to
        easePolyOut.exponent(3).
        Symmetric cubic easing; scales easeCubicIn for t in 0–0.5 and easeCubicOut for t in
        0.5–1. Also equivalent to easePoly.exponent(3).

        See more informations `here <https://d3js.org/d3-ease#easeCubicIn>`_.
        """
        return d3("d3.easeCubicIn()")

    @staticmethod
    def easeCubicOut():
        """
        Reverse cubic easing; equivalent to 1 - easeCubicIn(1 - t). Also equivalent to
        easePolyOut.exponent(3).
        Symmetric cubic easing; scales easeCubicIn for t in 0–0.5 and easeCubicOut for t in
        0.5–1. Also equivalent to easePoly.exponent(3).

        See more informations `here <https://d3js.org/d3-ease#easeCubicOut>`_.
        """
        return d3("d3.easeCubicOut()")

    @staticmethod
    def easeCubic():
        """
        Source · Alias for easeCubicInOut.
        Cubic easing; equivalent to easePolyIn.exponent(3).
        Reverse cubic easing; equivalent to 1 - easeCubicIn(1 - t). Also equivalent to
        easePolyOut.exponent(3).
        Symmetric cubic easing; scales easeCubicIn for t in 0–0.5 and easeCubicOut for t in
        0.5–1. Also equivalent to easePoly.exponent(3).

        See more informations `here <https://d3js.org/d3-ease#easeCubic>`_.
        """
        return d3("d3.easeCubic()")

    @staticmethod
    def easeCubicInOut():
        """
        Symmetric cubic easing; scales easeCubicIn for t in 0–0.5 and easeCubicOut for t in
        0.5–1. Also equivalent to easePoly.exponent(3).

        See more informations `here <https://d3js.org/d3-ease#easeCubicInOut>`_.
        """
        return d3("d3.easeCubicInOut()")

    @staticmethod
    def easeSinIn():
        """
        Sinusoidal easing; returns sin(t).
        Reverse sinusoidal easing; equivalent to 1 - easeSinIn(1 - t).
        Symmetric sinusoidal easing; scales easeSinIn for t in 0–0.5 and easeSinOut for t in
        0.5–1.

        See more informations `here <https://d3js.org/d3-ease#easeSinIn>`_.
        """
        return d3("d3.easeSinIn()")

    @staticmethod
    def easeSinOut():
        """
        Reverse sinusoidal easing; equivalent to 1 - easeSinIn(1 - t).
        Symmetric sinusoidal easing; scales easeSinIn for t in 0–0.5 and easeSinOut for t in
        0.5–1.

        See more informations `here <https://d3js.org/d3-ease#easeSinOut>`_.
        """
        return d3("d3.easeSinOut()")

    @staticmethod
    def easeSin():
        """
        Source · Alias for easeSinInOut.
        Sinusoidal easing; returns sin(t).
        Reverse sinusoidal easing; equivalent to 1 - easeSinIn(1 - t).
        Symmetric sinusoidal easing; scales easeSinIn for t in 0–0.5 and easeSinOut for t in
        0.5–1.

        See more informations `here <https://d3js.org/d3-ease#easeSin>`_.
        """
        return d3("d3.easeSin()")

    @staticmethod
    def easeSinInOut():
        """
        Symmetric sinusoidal easing; scales easeSinIn for t in 0–0.5 and easeSinOut for t in
        0.5–1.

        See more informations `here <https://d3js.org/d3-ease#easeSinInOut>`_.
        """
        return d3("d3.easeSinInOut()")

    @staticmethod
    def easeExpIn():
        """
        Exponential easing; raises 2 to the exponent 10 × (t - 1).
        Reverse exponential easing; equivalent to 1 - easeExpIn(1 - t).
        Symmetric exponential easing; scales easeExpIn for t in 0–0.5 and easeExpOut for t in
        0.5–1.

        See more informations `here <https://d3js.org/d3-ease#easeExpIn>`_.
        """
        return d3("d3.easeExpIn()")

    @staticmethod
    def easeExpOut():
        """
        Reverse exponential easing; equivalent to 1 - easeExpIn(1 - t).
        Symmetric exponential easing; scales easeExpIn for t in 0–0.5 and easeExpOut for t in
        0.5–1.

        See more informations `here <https://d3js.org/d3-ease#easeExpOut>`_.
        """
        return d3("d3.easeExpOut()")

    @staticmethod
    def easeExp():
        """
        Source · Alias for easeExpInOut.
        Exponential easing; raises 2 to the exponent 10 × (t - 1).
        Reverse exponential easing; equivalent to 1 - easeExpIn(1 - t).
        Symmetric exponential easing; scales easeExpIn for t in 0–0.5 and easeExpOut for t in
        0.5–1.

        See more informations `here <https://d3js.org/d3-ease#easeExp>`_.
        """
        return d3("d3.easeExp()")

    @staticmethod
    def easeExpInOut():
        """
        Symmetric exponential easing; scales easeExpIn for t in 0–0.5 and easeExpOut for t in
        0.5–1.

        See more informations `here <https://d3js.org/d3-ease#easeExpInOut>`_.
        """
        return d3("d3.easeExpInOut()")

    @staticmethod
    def easeCircleIn():
        """
        Circular easing.
        Reverse circular easing; equivalent to 1 - easeCircleIn(1 - t).
        Symmetric circular easing; scales easeCircleIn for t in 0–0.5 and easeCircleOut for t
        in 0.5–1.

        See more informations `here <https://d3js.org/d3-ease#easeCircleIn>`_.
        """
        return d3("d3.easeCircleIn()")

    @staticmethod
    def easeCircleOut():
        """
        Reverse circular easing; equivalent to 1 - easeCircleIn(1 - t).
        Symmetric circular easing; scales easeCircleIn for t in 0–0.5 and easeCircleOut for t
        in 0.5–1.

        See more informations `here <https://d3js.org/d3-ease#easeCircleOut>`_.
        """
        return d3("d3.easeCircleOut()")

    @staticmethod
    def easeCircle():
        """
        Source · Alias for easeCircleInOut.
        Circular easing.
        Reverse circular easing; equivalent to 1 - easeCircleIn(1 - t).
        Symmetric circular easing; scales easeCircleIn for t in 0–0.5 and easeCircleOut for t
        in 0.5–1.

        See more informations `here <https://d3js.org/d3-ease#easeCircle>`_.
        """
        return d3("d3.easeCircle()")

    @staticmethod
    def easeCircleInOut():
        """
        Symmetric circular easing; scales easeCircleIn for t in 0–0.5 and easeCircleOut for t
        in 0.5–1.

        See more informations `here <https://d3js.org/d3-ease#easeCircleInOut>`_.
        """
        return d3("d3.easeCircleInOut()")

    @staticmethod
    def easeBounceIn():
        """
        Bounce easing, like a rubber ball.
        Reverse bounce easing; equivalent to 1 - easeBounceIn(1 - t).
        Symmetric bounce easing; scales easeBounceIn for t in 0–0.5 and easeBounceOut for t in
        0.5–1.

        See more informations `here <https://d3js.org/d3-ease#easeBounceIn>`_.
        """
        return d3("d3.easeBounceIn()")

    @staticmethod
    def easeBounce():
        """
        Source · Alias for easeBounceOut.
        Bounce easing, like a rubber ball.
        Reverse bounce easing; equivalent to 1 - easeBounceIn(1 - t).
        Symmetric bounce easing; scales easeBounceIn for t in 0–0.5 and easeBounceOut for t in
        0.5–1.

        See more informations `here <https://d3js.org/d3-ease#easeBounce>`_.
        """
        return d3("d3.easeBounce()")

    @staticmethod
    def easeBounceOut():
        """
        Reverse bounce easing; equivalent to 1 - easeBounceIn(1 - t).
        Symmetric bounce easing; scales easeBounceIn for t in 0–0.5 and easeBounceOut for t in
        0.5–1.

        See more informations `here <https://d3js.org/d3-ease#easeBounceOut>`_.
        """
        return d3("d3.easeBounceOut()")

    @staticmethod
    def easeBounceInOut():
        """
        Symmetric bounce easing; scales easeBounceIn for t in 0–0.5 and easeBounceOut for t in
        0.5–1.

        See more informations `here <https://d3js.org/d3-ease#easeBounceInOut>`_.
        """
        return d3("d3.easeBounceInOut()")

    @staticmethod
    def blob(input=None, init=None):
        """
        .. code:: javascript

            const blob = await d3.blob("example.db");

        Source · Fetches the binary file at the specified input URL as a Blob. If init is
        specified, it is passed along to the underlying call to fetch; see RequestInit for
        allowed fields.

        See more informations `here <https://d3js.org/d3-fetch#blob>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (input, init))))
        return d3(f"d3.blob({arguments})")

    @staticmethod
    def buffer(input=None, init=None):
        """
        .. code:: javascript

            const buffer = await d3.buffer("example.db");

        Source · Fetches the binary file at the specified input URL as an ArrayBuffer. If init
        is specified, it is passed along to the underlying call to fetch; see RequestInit for
        allowed fields.

        See more informations `here <https://d3js.org/d3-fetch#buffer>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (input, init))))
        return d3(f"d3.buffer({arguments})")

    @staticmethod
    def csv(input=None, init=None, row=None):
        """
        .. code:: javascript

            const data = await d3.csv("example.csv");

        Source · Equivalent to d3.dsv with the comma character as the delimiter.

        See more informations `here <https://d3js.org/d3-fetch#csv>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (input, init, row))))
        return d3(f"d3.csv({arguments})")

    @staticmethod
    def dsv(delimiter=None, input=None, init=None, row=None):
        """
        .. code:: javascript

            const data = await d3.dsv(",", "example.csv");

        Source · Fetches the DSV file at the specified input URL. If init is specified, it is
        passed along to the underlying call to fetch; see RequestInit for allowed fields. An
        optional row conversion function may be specified to map and filter row objects to a
        more-specific representation; see dsv.parse for details. For example:
        .. code:: javascript

            const data = await d3.dsv(",", "example.csv", (d) => {
              return {
                year: new Date(+d.Year, 0, 1), // convert "Year" column to Date
                make: d.Make,
                model: d.Model,
                length: +d.Length // convert "Length" column to number
              };
            });

        If only one of init and row is specified, it is interpreted as the row conversion
        function if it is a function, and otherwise an init object. See also d3.csv and d3.tsv.

        See more informations `here <https://d3js.org/d3-fetch#dsv>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (delimiter, input, init, row))))
        return d3(f"d3.dsv({arguments})")

    @staticmethod
    def html(input=None, init=None):
        """
        .. code:: javascript

            const document = await d3.html("example.html");

        Source · Fetches the file at the specified input URL as text and then parses it as
        HTML. If init is specified, it is passed along to the underlying call to fetch; see
        RequestInit for allowed fields.

        See more informations `here <https://d3js.org/d3-fetch#html>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (input, init))))
        return d3(f"d3.html({arguments})")

    @staticmethod
    def image(input=None, init=None):
        """
        .. code:: javascript

            const image = await d3.image("example.png");

        Source · Fetches the image at the specified input URL. If init is specified, sets any
        additional properties on the image before loading. For example, to enable an anonymous
        cross-origin request:
        .. code:: javascript

            const image = await d3.image("https://example.com/image.png", {crossOrigin: "anonymous"});


        See more informations `here <https://d3js.org/d3-fetch#image>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (input, init))))
        return d3(f"d3.image({arguments})")

    @staticmethod
    def json(input=None, init=None):
        """
        .. code:: javascript

            const data = await d3.json("example.json");

        Source · Fetches the JSON file at the specified input URL. If init is specified, it is
        passed along to the underlying call to fetch; see RequestInit for allowed fields. If
        the server returns a status code of 204 No Content or 205 Reset Content, the promise
        resolves to undefined.

        See more informations `here <https://d3js.org/d3-fetch#json>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (input, init))))
        return d3(f"d3.json({arguments})")

    @staticmethod
    def svg(input=None, init=None):
        """
        .. code:: javascript

            const document = await d3.svg("example.svg");

        Source · Fetches the file at the specified input URL as text and then parses it as SVG.
        If init is specified, it is passed along to the underlying call to fetch; see
        RequestInit for allowed fields.

        See more informations `here <https://d3js.org/d3-fetch#svg>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (input, init))))
        return d3(f"d3.svg({arguments})")

    @staticmethod
    def text(input=None, init=None):
        """
        .. code:: javascript

            const text = await d3.text("example.txt");

        Source · Fetches the text file at the specified input URL. If init is specified, it is
        passed along to the underlying call to fetch; see RequestInit for allowed fields.

        See more informations `here <https://d3js.org/d3-fetch#text>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (input, init))))
        return d3(f"d3.text({arguments})")

    @staticmethod
    def tsv(input=None, init=None, row=None):
        """
        .. code:: javascript

            const data = await d3.tsv("example.tsv");

        Source · Equivalent to d3.dsv with the tab character as the delimiter.

        See more informations `here <https://d3js.org/d3-fetch#tsv>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (input, init, row))))
        return d3(f"d3.tsv({arguments})")

    @staticmethod
    def xml(input=None, init=None):
        """
        .. code:: javascript

            const document = await d3.xml("example.xml");

        Source · Fetches the file at the specified input URL as text and then parses it as XML.
        If init is specified, it is passed along to the underlying call to fetch; see
        RequestInit for allowed fields.

        See more informations `here <https://d3js.org/d3-fetch#xml>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (input, init))))
        return d3(f"d3.xml({arguments})")

    @staticmethod
    def format(specifier=None):
        """
        .. code:: javascript

            const f = d3.format(".2f");

        Source · An alias for locale.format on the default locale.

        See more informations `here <https://d3js.org/d3-format#format>`_.
        .. code:: javascript

            const f = d3.format(".2f");

        Source · Returns a new format function for the given string specifier. The returned
        function takes a number as the only argument, and returns a string representing the
        formatted number. The general form of a specifier is:
        .. code:: javascript

            [​[fill]align][sign][symbol][0][width][,][.precision][~][type]

        The fill can be any character. The presence of a fill character is signaled by the
        align character following it, which must be one of the following:
        The sign can be:
        The symbol can be:
        The zero (0) option enables zero-padding; this implicitly sets fill to 0 and align to
        =. The width defines the minimum field width; if not specified, then the width will be
        determined by the content. The comma (,) option enables the use of a group separator,
        such as a comma for thousands.
        Depending on the type, the precision either indicates the number of digits that follow
        the decimal point (types f and %), or the number of significant digits (types ​, e, g,
        r, s and p). If the precision is not specified, it defaults to 6 for all types except ​
        (none), which defaults to 12. Precision is ignored for integer formats (types b, o, d,
        x, and X) and character data (type c). See precisionFixed and precisionRound for help
        picking an appropriate precision.
        The ~ option trims insignificant trailing zeros across all format types. This is most
        commonly used in conjunction with types r, e, s and %. For example:
        .. code:: javascript

            d3.format("s")(1500) // "1.50000k"

        .. code:: javascript

            d3.format("~s")(1500) // "1.5k"

        The available type values are:
        The type ​ (none) is also supported as shorthand for ~g (with a default precision of 12
        instead of 6), and the type n is shorthand for ,g. For the g, n and ​ (none) types,
        decimal notation is used if the resulting string would have precision or fewer digits;
        otherwise, exponent notation is used. For example:
        .. code:: javascript

            d3.format(".2")(42) // "42"

        .. code:: javascript

            d3.format(".2")(4.2) // "4.2"

        .. code:: javascript

            d3.format(".1")(42) // "4e+1"

        .. code:: javascript

            d3.format(".1")(4.2) // "4"


        See more informations `here <https://d3js.org/d3-format#locale_format>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (specifier,))))
        return d3(f"d3.format({arguments})")

    @staticmethod
    def formatPrefix(specifier=None, value=None):
        """
        .. code:: javascript

            const f = d3.formatPrefix(",.0", 1e-6);

        Source · An alias for locale.formatPrefix on the default locale.

        See more informations `here <https://d3js.org/d3-format#formatPrefix>`_.
        .. code:: javascript

            const f = d3.formatPrefix(",.0", 1e-6);

        Source · Equivalent to locale.format, except the returned function will convert values
        to the units of the appropriate SI prefix for the specified numeric reference value
        before formatting in fixed point notation. The following prefixes are supported:
        Unlike locale.format with the s format type, this method returns a formatter with a
        consistent SI prefix, rather than computing the prefix dynamically for each number. In
        addition, the precision for the given specifier represents the number of digits past
        the decimal point (as with f fixed point notation), not the number of significant
        digits. For example:
        .. code:: javascript

            const f = d3.formatPrefix(",.0", 1e-6);
            f(0.00042); // "420µ"
            f(0.0042); // "4,200µ"

        This method is useful when formatting multiple numbers in the same units for easy
        comparison. See precisionPrefix for help picking an appropriate precision.

        See more informations `here <https://d3js.org/d3-format#locale_formatPrefix>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (specifier, value))))
        return d3(f"d3.formatPrefix({arguments})")

    @staticmethod
    def formatSpecifier(specifier=None):
        """
        .. code:: javascript

            d3.formatSpecifier(".1f")

        Source · Parses the specified specifier, returning an object with exposed fields that
        correspond to the format specification mini-language and a toString method that
        reconstructs the specifier. For example, formatSpecifier("s") returns:
        .. code:: javascript

            FormatSpecifier {
              "fill": " ",
              "align": ">",
              "sign": "-",
              "symbol": "",
              "zero": false,
              "width": undefined,
              "comma": false,
              "precision": undefined,
              "trim": false,
              "type": "s"
            }

        This method is useful for understanding how format specifiers are parsed and for
        deriving new specifiers. For example, you might compute an appropriate precision based
        on the numbers you want to format using precisionFixed and then create a new format:
        .. code:: javascript

            const s = d3.formatSpecifier("f");
            s.precision = d3.precisionFixed(0.01);
            const f = d3.format(s);
            f(42); // "42.00";


        See more informations `here <https://d3js.org/d3-format#formatSpecifier>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (specifier,))))
        return d3(f"d3.formatSpecifier({arguments})")

    @staticmethod
    def FormatSpecifier(specifier=None):
        """
        .. code:: javascript

            new d3.FormatSpecifier({type: "f", precision: 1})

        Source · Given the specified specifier object, returning an object with exposed fields
        that correspond to the format specification mini-language and a toString method that
        reconstructs the specifier. For example, new FormatSpecifier({type: "s"}) returns:
        .. code:: javascript

            FormatSpecifier {
              "fill": " ",
              "align": ">",
              "sign": "-",
              "symbol": "",
              "zero": false,
              "width": undefined,
              "comma": false,
              "precision": undefined,
              "trim": false,
              "type": "s"
            }


        See more informations `here <https://d3js.org/d3-format#FormatSpecifier>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (specifier,))))
        return d3(f"new d3.FormatSpecifier({arguments})")

    @staticmethod
    def precisionFixed(step=None):
        """
        .. code:: javascript

            d3.precisionFixed(0.01) // 2

        Source · Returns a suggested decimal precision for fixed point notation given the
        specified numeric step value. The step represents the minimum absolute difference
        between values that will be formatted. (This assumes that the values to be formatted
        are also multiples of step.) For example, given the numbers 1, 1.5, and 2, the step
        should be 0.5 and the suggested precision is 1:
        .. code:: javascript

            const p = d3.precisionFixed(0.5);
            const f = d3.format("." + p + "f");
            f(1);   // "1.0"
            f(1.5); // "1.5"
            f(2);   // "2.0"

        Whereas for the numbers 1, 2 and 3, the step should be 1 and the suggested precision is
        0:
        .. code:: javascript

            const p = d3.precisionFixed(1);
            const f = d3.format("." + p + "f");
            f(1); // "1"
            f(2); // "2"
            f(3); // "3"

        Note: for the % format type, subtract two:
        .. code:: javascript

            const p = Math.max(0, d3.precisionFixed(0.05) - 2);
            const f = d3.format("." + p + "%");
            f(0.45); // "45%"
            f(0.50); // "50%"
            f(0.55); // "55%"


        See more informations `here <https://d3js.org/d3-format#precisionFixed>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (step,))))
        return d3(f"d3.precisionFixed({arguments})")

    @staticmethod
    def precisionPrefix(step=None, value=None):
        """
        .. code:: javascript

            d3.precisionPrefix(1e5, 1.3e6) // 1

        Source · Returns a suggested decimal precision for use with locale.formatPrefix given
        the specified numeric step and reference value. The step represents the minimum
        absolute difference between values that will be formatted, and value determines which
        SI prefix will be used. (This assumes that the values to be formatted are also
        multiples of step.) For example, given the numbers 1.1e6, 1.2e6, and 1.3e6, the step
        should be 1e5, the value could be 1.3e6, and the suggested precision is 1:
        .. code:: javascript

            const p = d3.precisionPrefix(1e5, 1.3e6);
            const f = d3.formatPrefix("." + p, 1.3e6);
            f(1.1e6); // "1.1M"
            f(1.2e6); // "1.2M"
            f(1.3e6); // "1.3M"


        See more informations `here <https://d3js.org/d3-format#precisionPrefix>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (step, value))))
        return d3(f"d3.precisionPrefix({arguments})")

    @staticmethod
    def precisionRound(step=None, max=None):
        """
        .. code:: javascript

            d3.precisionRound(0.01, 1.01) // 3

        Source · Returns a suggested decimal precision for format types that round to
        significant digits given the specified numeric step and max values. The step represents
        the minimum absolute difference between values that will be formatted, and the max
        represents the largest absolute value that will be formatted. (This assumes that the
        values to be formatted are also multiples of step.) For example, given the numbers
        0.99, 1.0, and 1.01, the step should be 0.01, the max should be 1.01, and the suggested
        precision is 3:
        .. code:: javascript

            const p = d3.precisionRound(0.01, 1.01);
            const f = d3.format("." + p + "r");
            f(0.99); // "0.990"
            f(1.0);  // "1.00"
            f(1.01); // "1.01"

        Whereas for the numbers 0.9, 1.0, and 1.1, the step should be 0.1, the max should be
        1.1, and the suggested precision is 2:
        .. code:: javascript

            const p = d3.precisionRound(0.1, 1.1);
            const f = d3.format("." + p + "r");
            f(0.9); // "0.90"
            f(1.0); // "1.0"
            f(1.1); // "1.1"

        Note: for the e format type, subtract one:
        .. code:: javascript

            const p = Math.max(0, d3.precisionRound(0.01, 1.01) - 1);
            const f = d3.format("." + p + "e");
            f(0.01); // "1.00e-2"
            f(1.01); // "1.01e+0"


        See more informations `here <https://d3js.org/d3-format#precisionRound>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (step, max))))
        return d3(f"d3.precisionRound({arguments})")

    @staticmethod
    def formatLocale(definition=None):
        """
        .. code:: javascript

            const enUs = d3.formatLocale({
              thousands: ",",
              grouping: [3],
              currency: ["$", ""]
            });

        Source · Returns a locale object for the specified definition with locale.format and
        locale.formatPrefix methods. The definition must include the following properties:
        Note that the thousands property is a misnomer, as the grouping definition allows
        groups other than thousands.

        See more informations `here <https://d3js.org/d3-format#formatLocale>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (definition,))))
        return d3(f"d3.formatLocale({arguments})")

    @staticmethod
    def formatDefaultLocale(definition=None):
        """
        .. code:: javascript

            const enUs = d3.formatDefaultLocale({
              thousands: ",",
              grouping: [3],
              currency: ["$", ""]
            });

        Source · Equivalent to d3.formatLocale, except it also redefines d3.format and
        d3.formatPrefix to the new locale’s locale.format and locale.formatPrefix. If you do
        not set a default locale, it defaults to U.S. English.

        See more informations `here <https://d3js.org/d3-format#formatDefaultLocale>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (definition,))))
        return d3(f"d3.formatDefaultLocale({arguments})")

    @staticmethod
    def geoProjection(project=None):
        """
        Source · Constructs a new projection from the specified raw projection, project. The
        project function takes the longitude and latitude of a given point in radians, often
        referred to as lambda (λ) and phi (φ), and returns a two-element array [x, y]
        representing its unit projection. The project function does not need to scale or
        translate the point, as these are applied automatically by projection.scale,
        projection.translate, and projection.center. Likewise, the project function does not
        need to perform any spherical rotation, as projection.rotate is applied prior to
        projection.
        For example, a spherical Mercator projection can be implemented as:
        .. code:: javascript

            var mercator = d3.geoProjection(function(x, y) {
              return [x, Math.log(Math.tan(Math.PI / 4 + y / 2))];
            });

        If the project function exposes an invert method, the returned projection will also
        expose projection.invert.

        See more informations `here <https://d3js.org/d3-geo/projection#geoProjection>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (project,))))
        return d3(f"d3.geoProjection({arguments})")

    @staticmethod
    def geoProjectionMutator(factory=None):
        """
        Source · Constructs a new projection from the specified raw projection factory and
        returns a mutate function to call whenever the raw projection changes. The factory must
        return a raw projection. The returned mutate function returns the wrapped projection.
        For example, a conic projection typically has two configurable parallels. A suitable
        factory function, such as geoConicEqualAreaRaw, would have the form:
        .. code:: javascript

            // y0 and y1 represent two parallels
            function conicFactory(phi0, phi1) {
              return function conicRaw(lambda, phi) {
                return […, …];
              };
            }

        Using d3.geoProjectionMutator, you can implement a standard projection that allows the
        parallels to be changed, reassigning the raw projection used internally by
        geoProjection:
        .. code:: javascript

            function conicCustom() {
              var phi0 = 29.5,
                  phi1 = 45.5,
                  mutate = d3.geoProjectionMutator(conicFactory),
                  projection = mutate(phi0, phi1);

              projection.parallels = function(_) {
                return arguments.length ? mutate(phi0 = +_[0], phi1 = +_[1]) : [phi0, phi1];
              };

              return projection;
            }

        When creating a mutable projection, the mutate function is typically not exposed.

        See more informations `here <https://d3js.org/d3-geo/projection#geoProjectionMutator>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (factory,))))
        return d3(f"d3.geoProjectionMutator({arguments})")

    @staticmethod
    def geoTransform(methods=None):
        """
        Source · Defines an arbitrary transform using the methods defined on the specified
        methods object. Any undefined methods will use pass-through methods that propagate
        inputs to the output stream.
        For example, to reflect the y-dimension (see also projection.reflectY):
        .. code:: javascript

            const reflectY = d3.geoTransform({
              point(x, y) {
                this.stream.point(x, -y);
              }
            });

        Or to define an affine matrix transformation:
        .. code:: javascript

            function matrix(a, b, c, d, tx, ty) {
              return d3.geoTransform({
                point(x, y) {
                  this.stream.point(a * x + b * y + tx, c * x + d * y + ty);
                }
              });
            }

        A transform is a generalized projection; it implements projection.stream and can be
        passed to path.projection. However, it implements only a subset of the other projection
        methods, and represent arbitrary geometric transformations rather than projections from
        spherical to planar coordinates.

        See more informations `here <https://d3js.org/d3-geo/projection#geoTransform>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (methods,))))
        return d3(f"d3.geoTransform({arguments})")

    @staticmethod
    def geoClipAntimeridian():
        """
        Source · A clipping function which transforms a stream such that geometries (lines or
        polygons) that cross the antimeridian line are cut in two, one on each side. Typically
        used for pre-clipping.

        See more informations `here <https://d3js.org/d3-geo/projection#geoClipAntimeridian>`_.
        """
        return d3("d3.geoClipAntimeridian()")

    @staticmethod
    def geoClipCircle(angle=None):
        """
        Source · Generates a clipping function which transforms a stream such that geometries
        are bounded by a small circle of radius angle around the projection’s center. Typically
        used for pre-clipping.

        See more informations `here <https://d3js.org/d3-geo/projection#geoClipCircle>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (angle,))))
        return d3(f"d3.geoClipCircle({arguments})")

    @staticmethod
    def geoClipRectangle(x0=None, y0=None, x1=None, y1=None):
        """
        Source · Generates a clipping function which transforms a stream such that geometries
        are bounded by a rectangle of coordinates [[x0, y0], [x1, y1]]. Typically used for
        post-clipping.

        See more informations `here <https://d3js.org/d3-geo/projection#geoClipRectangle>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (x0, y0, x1, y1))))
        return d3(f"d3.geoClipRectangle({arguments})")

    @staticmethod
    def geoAzimuthalEqualArea():
        """
        Source · The azimuthal equal-area projection.

        See more informations `here <https://d3js.org/d3-geo/azimuthal#geoAzimuthalEqualArea>`_.
        """
        return d3("d3.geoAzimuthalEqualArea()")

    @staticmethod
    def geoAzimuthalEquidistant():
        """
        Source · The azimuthal equidistant projection.

        See more informations `here <https://d3js.org/d3-geo/azimuthal#geoAzimuthalEquidistant>`_.
        """
        return d3("d3.geoAzimuthalEquidistant()")

    @staticmethod
    def geoGnomonic():
        """
        Source · The gnomonic projection.

        See more informations `here <https://d3js.org/d3-geo/azimuthal#geoGnomonic>`_.
        """
        return d3("d3.geoGnomonic()")

    @staticmethod
    def geoOrthographic():
        """
        Source · The orthographic projection.

        See more informations `here <https://d3js.org/d3-geo/azimuthal#geoOrthographic>`_.
        """
        return d3("d3.geoOrthographic()")

    @staticmethod
    def geoStereographic():
        """
        Source · The stereographic projection.

        See more informations `here <https://d3js.org/d3-geo/azimuthal#geoStereographic>`_.
        """
        return d3("d3.geoStereographic()")

    @staticmethod
    def geoConicConformal():
        """
        Source · The conic conformal projection. The parallels default to [30°, 30°] resulting
        in flat top.

        See more informations `here <https://d3js.org/d3-geo/conic#geoConicConformal>`_.
        """
        return d3("d3.geoConicConformal()")

    @staticmethod
    def geoConicEqualArea():
        """
        Source · The Albers’ equal-area conic projection.

        See more informations `here <https://d3js.org/d3-geo/conic#geoConicEqualArea>`_.
        """
        return d3("d3.geoConicEqualArea()")

    @staticmethod
    def geoConicEquidistant():
        """
        Source · The conic equidistant projection.

        See more informations `here <https://d3js.org/d3-geo/conic#geoConicEquidistant>`_.
        """
        return d3("d3.geoConicEquidistant()")

    @staticmethod
    def geoAlbers():
        """
        Source · The Albers’ equal area-conic projection. This is a U.S.-centric configuration
        of geoConicEqualArea.

        See more informations `here <https://d3js.org/d3-geo/conic#geoAlbers>`_.
        """
        return d3("d3.geoAlbers()")

    @staticmethod
    def geoAlbersUsa():
        """
        Source · This is a U.S.-centric composite projection of three geoConicEqualArea
        projections: geoAlbers is used for the lower forty-eight states, and separate conic
        equal-area projections are used for Alaska and Hawaii. The scale for Alaska is
        diminished: it is projected at 0.35× its true relative area. See Albers USA with
        Territories for an extension to all US territories, and d3-composite-projections for
        more examples.
        The constituent projections have fixed clip, center and rotation, and thus this
        projection does not support projection.center, projection.rotate, projection.clipAngle,
        or projection.clipExtent.

        See more informations `here <https://d3js.org/d3-geo/conic#geoAlbersUsa>`_.
        """
        return d3("d3.geoAlbersUsa()")

    @staticmethod
    def geoEquirectangular():
        """
        Source · The equirectangular (plate carrée) projection.

        See more informations `here <https://d3js.org/d3-geo/cylindrical#geoEquirectangular>`_.
        """
        return d3("d3.geoEquirectangular()")

    @staticmethod
    def geoMercator():
        """
        Source · The spherical Mercator projection. Defines a default projection.clipExtent
        such that the world is projected to a square, clipped to approximately ±85° latitude.

        See more informations `here <https://d3js.org/d3-geo/cylindrical#geoMercator>`_.
        """
        return d3("d3.geoMercator()")

    @staticmethod
    def geoTransverseMercator():
        """
        Source · The transverse spherical Mercator projection. Defines a default
        projection.clipExtent such that the world is projected to a square, clipped to
        approximately ±85° latitude.

        See more informations `here <https://d3js.org/d3-geo/cylindrical#geoTransverseMercator>`_.
        """
        return d3("d3.geoTransverseMercator()")

    @staticmethod
    def geoEqualEarth():
        """
        Source · The Equal Earth projection, an equal-area projection, by Bojan Šavrič et al.,
        2018.

        See more informations `here <https://d3js.org/d3-geo/cylindrical#geoEqualEarth>`_.
        """
        return d3("d3.geoEqualEarth()")

    @staticmethod
    def geoNaturalEarth1():
        """
        Source · The Natural Earth projection is a pseudocylindrical projection designed by Tom
        Patterson. It is neither conformal nor equal-area, but appealing to the eye for
        small-scale maps of the whole world.

        See more informations `here <https://d3js.org/d3-geo/cylindrical#geoNaturalEarth1>`_.
        """
        return d3("d3.geoNaturalEarth1()")

    @staticmethod
    def geoGraticule10():
        """
        Source · A convenience method for directly generating the default 10° global graticule
        as a GeoJSON MultiLineString geometry object. Equivalent to:
        .. code:: javascript

            function geoGraticule10() {
              return d3.geoGraticule()();
            }


        See more informations `here <https://d3js.org/d3-geo/shape#geoGraticule10>`_.
        """
        return d3("d3.geoGraticule10()")

    @staticmethod
    def geoArea(object=None):
        """
        Source · Returns the spherical area of the specified GeoJSON object in steradians. This
        is the spherical equivalent of path.area.

        See more informations `here <https://d3js.org/d3-geo/math#geoArea>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (object,))))
        return d3(f"d3.geoArea({arguments})")

    @staticmethod
    def geoBounds(object=None):
        """
        Source · Returns the spherical bounding box for the specified GeoJSON object. The
        bounding box is represented by a two-dimensional array: [[left, bottom], [right, top]],
        where left is the minimum longitude, bottom is the minimum latitude, right is maximum
        longitude, and top is the maximum latitude. All coordinates are given in degrees. (Note
        that in projected planar coordinates, the minimum latitude is typically the maximum
        y-value, and the maximum latitude is typically the minimum y-value.) This is the
        spherical equivalent of path.bounds.

        See more informations `here <https://d3js.org/d3-geo/math#geoBounds>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (object,))))
        return d3(f"d3.geoBounds({arguments})")

    @staticmethod
    def geoCentroid(object=None):
        """
        Source · Returns the spherical centroid of the specified GeoJSON object. This is the
        spherical equivalent of path.centroid.

        See more informations `here <https://d3js.org/d3-geo/math#geoCentroid>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (object,))))
        return d3(f"d3.geoCentroid({arguments})")

    @staticmethod
    def geoDistance(a=None, b=None):
        """
        Source · Returns the great-arc distance in radians between the two points a and b. Each
        point must be specified as a two-element array [longitude, latitude] in degrees. This
        is the spherical equivalent of path.measure given a LineString of two points.

        See more informations `here <https://d3js.org/d3-geo/math#geoDistance>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (a, b))))
        return d3(f"d3.geoDistance({arguments})")

    @staticmethod
    def geoLength(object=None):
        """
        Source · Returns the great-arc length of the specified GeoJSON object in radians. For
        polygons, returns the perimeter of the exterior ring plus that of any interior rings.
        This is the spherical equivalent of path.measure.

        See more informations `here <https://d3js.org/d3-geo/math#geoLength>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (object,))))
        return d3(f"d3.geoLength({arguments})")

    @staticmethod
    def geoInterpolate(a=None, b=None):
        """
        Source · Returns an interpolator function given two points a and b. Each point must be
        specified as a two-element array [longitude, latitude] in degrees. The returned
        interpolator function takes a single argument t, where t is a number ranging from 0 to
        1; a value of 0 returns the point a, while a value of 1 returns the point b.
        Intermediate values interpolate from a to b along the great arc that passes through
        both a and b. If a and b are antipodes, an arbitrary great arc is chosen.

        See more informations `here <https://d3js.org/d3-geo/math#geoInterpolate>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (a, b))))
        return d3(f"d3.geoInterpolate({arguments})")

    @staticmethod
    def geoContains(object=None, point=None):
        """
        Source · Returns true if and only if the specified GeoJSON object contains the
        specified point, or false if the object does not contain the point. The point must be
        specified as a two-element array [longitude, latitude] in degrees. For Point and
        MultiPoint geometries, an exact test is used; for a Sphere, true is always returned;
        for other geometries, an epsilon threshold is applied.

        See more informations `here <https://d3js.org/d3-geo/math#geoContains>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (object, point))))
        return d3(f"d3.geoContains({arguments})")

    @staticmethod
    def geoRotation(angles=None):
        """
        Source · Returns a rotation function for the given angles, which must be a two- or
        three-element array of numbers [lambda, phi, gamma] specifying the rotation angles in
        degrees about each spherical axis. (These correspond to yaw, pitch and roll.) If the
        rotation angle gamma is omitted, it defaults to 0. See also projection.rotate.
        Source · Returns a new array [longitude, latitude] in degrees representing the rotated
        point of the given point. The point must be specified as a two-element array
        [longitude, latitude] in degrees.
        Source · Returns a new array [longitude, latitude] in degrees representing the point of
        the given rotated point; the inverse of rotation. The point must be specified as a
        two-element array [longitude, latitude] in degrees.

        See more informations `here <https://d3js.org/d3-geo/math#geoRotation>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (angles,))))
        return d3(f"d3.geoRotation({arguments})")

    @staticmethod
    def hierarchy(data=None, children=None):
        """
        Examples · Source · Constructs a root node from the specified hierarchical data. The
        specified data must be an object representing the root node. For example:
        .. code:: javascript

            const data = {
              name: "Eve",
              children: [
                {name: "Cain"},
                {name: "Seth", children: [{name: "Enos"}, {name: "Noam"}]},
                {name: "Abel"},
                {name: "Awan", children: [{name: "Enoch"}]},
                {name: "Azura"}
              ]
            };

        To construct a hierarchy:
        .. code:: javascript

            const root = d3.hierarchy(data);

        The specified children accessor function is invoked for each datum, starting with the
        root data, and must return an iterable of data representing the children, if any. If
        the children accessor is not specified, it defaults to:
        .. code:: javascript

            function children(d) {
              return d.children;
            }

        If data is a Map, it is implicitly converted to the entry [undefined, data], and the
        children accessor instead defaults to:
        .. code:: javascript

            function children(d) {
              return Array.isArray(d) ? d[1] : null;
            }

        This allows you to pass the result of group or rollup to hierarchy.
        The returned root node and each descendant has the following properties:
        This method can also be used to test if a node is an instanceof d3.hierarchy and to
        extend the node prototype.

        See more informations `here <https://d3js.org/d3-hierarchy/hierarchy#hierarchy>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (data, children))))
        return d3(f"d3.hierarchy({arguments})")

    @staticmethod
    def treemapBinary(node=None, x0=None, y0=None, x1=None, y1=None):
        """
        Source · Recursively partitions the specified nodes into an approximately-balanced
        binary tree, choosing horizontal partitioning for wide rectangles and vertical
        partitioning for tall rectangles.
        Source · Divides the rectangular area specified by x0, y0, x1, y1 horizontally
        according the value of each of the specified node’s children. The children are
        positioned in order, starting with the left edge (x0) of the given rectangle. If the
        sum of the children’s values is less than the specified node’s value (i.e., if the
        specified node has a non-zero internal value), the remaining empty space will be
        positioned on the right edge (x1) of the given rectangle.
        Source · Divides the rectangular area specified by x0, y0, x1, y1 vertically according
        the value of each of the specified node’s children. The children are positioned in
        order, starting with the top edge (y0) of the given rectangle. If the sum of the
        children’s values is less than the specified node’s value (i.e., if the specified node
        has a non-zero internal value), the remaining empty space will be positioned on the
        bottom edge (y1) of the given rectangle.
        Source · If the specified node has odd depth, delegates to treemapSlice; otherwise
        delegates to treemapDice.
        Source · Implements the squarified treemap algorithm by Bruls et al., which seeks to
        produce rectangles of a given aspect ratio.
        Examples · Source · Like treemapSquarify, except preserves the topology (node
        adjacencies) of the previous layout computed by d3.treemapResquarify, if there is one
        and it used the same target aspect ratio. This tiling method is good for animating
        changes to treemaps because it only changes node sizes and not their relative
        positions, thus avoiding distracting shuffling and occlusion. The downside of a stable
        update, however, is a suboptimal layout for subsequent updates: only the first layout
        uses the Bruls et al. squarified algorithm.
        Source · Specifies the desired aspect ratio of the generated rectangles. The ratio must
        be specified as a number greater than or equal to one. Note that the orientation of the
        generated rectangles (tall or wide) is not implied by the ratio; for example, a ratio
        of two will attempt to produce a mixture of rectangles whose width:height ratio is
        either 2:1 or 1:2. (However, you can approximately achieve this result by generating a
        square treemap at different dimensions, and then stretching the treemap to the desired
        aspect ratio.) Furthermore, the specified ratio is merely a hint to the tiling
        algorithm; the rectangles are not guaranteed to have the specified aspect ratio. If not
        specified, the aspect ratio defaults to the golden ratio, φ = (1 + sqrt(5)) / 2, per
        Kong et al.

        See more informations `here <https://d3js.org/d3-hierarchy/treemap#treemapBinary>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (node, x0, y0, x1, y1))))
        return d3(f"d3.treemapBinary({arguments})")

    @staticmethod
    def treemapDice(node=None, x0=None, y0=None, x1=None, y1=None):
        """
        Source · Divides the rectangular area specified by x0, y0, x1, y1 horizontally
        according the value of each of the specified node’s children. The children are
        positioned in order, starting with the left edge (x0) of the given rectangle. If the
        sum of the children’s values is less than the specified node’s value (i.e., if the
        specified node has a non-zero internal value), the remaining empty space will be
        positioned on the right edge (x1) of the given rectangle.
        Source · Divides the rectangular area specified by x0, y0, x1, y1 vertically according
        the value of each of the specified node’s children. The children are positioned in
        order, starting with the top edge (y0) of the given rectangle. If the sum of the
        children’s values is less than the specified node’s value (i.e., if the specified node
        has a non-zero internal value), the remaining empty space will be positioned on the
        bottom edge (y1) of the given rectangle.
        Source · If the specified node has odd depth, delegates to treemapSlice; otherwise
        delegates to treemapDice.
        Source · Implements the squarified treemap algorithm by Bruls et al., which seeks to
        produce rectangles of a given aspect ratio.
        Examples · Source · Like treemapSquarify, except preserves the topology (node
        adjacencies) of the previous layout computed by d3.treemapResquarify, if there is one
        and it used the same target aspect ratio. This tiling method is good for animating
        changes to treemaps because it only changes node sizes and not their relative
        positions, thus avoiding distracting shuffling and occlusion. The downside of a stable
        update, however, is a suboptimal layout for subsequent updates: only the first layout
        uses the Bruls et al. squarified algorithm.
        Source · Specifies the desired aspect ratio of the generated rectangles. The ratio must
        be specified as a number greater than or equal to one. Note that the orientation of the
        generated rectangles (tall or wide) is not implied by the ratio; for example, a ratio
        of two will attempt to produce a mixture of rectangles whose width:height ratio is
        either 2:1 or 1:2. (However, you can approximately achieve this result by generating a
        square treemap at different dimensions, and then stretching the treemap to the desired
        aspect ratio.) Furthermore, the specified ratio is merely a hint to the tiling
        algorithm; the rectangles are not guaranteed to have the specified aspect ratio. If not
        specified, the aspect ratio defaults to the golden ratio, φ = (1 + sqrt(5)) / 2, per
        Kong et al.

        See more informations `here <https://d3js.org/d3-hierarchy/treemap#treemapDice>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (node, x0, y0, x1, y1))))
        return d3(f"d3.treemapDice({arguments})")

    @staticmethod
    def treemapSlice(node=None, x0=None, y0=None, x1=None, y1=None):
        """
        Source · Divides the rectangular area specified by x0, y0, x1, y1 vertically according
        the value of each of the specified node’s children. The children are positioned in
        order, starting with the top edge (y0) of the given rectangle. If the sum of the
        children’s values is less than the specified node’s value (i.e., if the specified node
        has a non-zero internal value), the remaining empty space will be positioned on the
        bottom edge (y1) of the given rectangle.
        Source · If the specified node has odd depth, delegates to treemapSlice; otherwise
        delegates to treemapDice.
        Source · Implements the squarified treemap algorithm by Bruls et al., which seeks to
        produce rectangles of a given aspect ratio.
        Examples · Source · Like treemapSquarify, except preserves the topology (node
        adjacencies) of the previous layout computed by d3.treemapResquarify, if there is one
        and it used the same target aspect ratio. This tiling method is good for animating
        changes to treemaps because it only changes node sizes and not their relative
        positions, thus avoiding distracting shuffling and occlusion. The downside of a stable
        update, however, is a suboptimal layout for subsequent updates: only the first layout
        uses the Bruls et al. squarified algorithm.
        Source · Specifies the desired aspect ratio of the generated rectangles. The ratio must
        be specified as a number greater than or equal to one. Note that the orientation of the
        generated rectangles (tall or wide) is not implied by the ratio; for example, a ratio
        of two will attempt to produce a mixture of rectangles whose width:height ratio is
        either 2:1 or 1:2. (However, you can approximately achieve this result by generating a
        square treemap at different dimensions, and then stretching the treemap to the desired
        aspect ratio.) Furthermore, the specified ratio is merely a hint to the tiling
        algorithm; the rectangles are not guaranteed to have the specified aspect ratio. If not
        specified, the aspect ratio defaults to the golden ratio, φ = (1 + sqrt(5)) / 2, per
        Kong et al.

        See more informations `here <https://d3js.org/d3-hierarchy/treemap#treemapSlice>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (node, x0, y0, x1, y1))))
        return d3(f"d3.treemapSlice({arguments})")

    @staticmethod
    def treemapSliceDice(node=None, x0=None, y0=None, x1=None, y1=None):
        """
        Source · If the specified node has odd depth, delegates to treemapSlice; otherwise
        delegates to treemapDice.
        Source · Implements the squarified treemap algorithm by Bruls et al., which seeks to
        produce rectangles of a given aspect ratio.
        Examples · Source · Like treemapSquarify, except preserves the topology (node
        adjacencies) of the previous layout computed by d3.treemapResquarify, if there is one
        and it used the same target aspect ratio. This tiling method is good for animating
        changes to treemaps because it only changes node sizes and not their relative
        positions, thus avoiding distracting shuffling and occlusion. The downside of a stable
        update, however, is a suboptimal layout for subsequent updates: only the first layout
        uses the Bruls et al. squarified algorithm.
        Source · Specifies the desired aspect ratio of the generated rectangles. The ratio must
        be specified as a number greater than or equal to one. Note that the orientation of the
        generated rectangles (tall or wide) is not implied by the ratio; for example, a ratio
        of two will attempt to produce a mixture of rectangles whose width:height ratio is
        either 2:1 or 1:2. (However, you can approximately achieve this result by generating a
        square treemap at different dimensions, and then stretching the treemap to the desired
        aspect ratio.) Furthermore, the specified ratio is merely a hint to the tiling
        algorithm; the rectangles are not guaranteed to have the specified aspect ratio. If not
        specified, the aspect ratio defaults to the golden ratio, φ = (1 + sqrt(5)) / 2, per
        Kong et al.

        See more informations `here <https://d3js.org/d3-hierarchy/treemap#treemapSliceDice>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (node, x0, y0, x1, y1))))
        return d3(f"d3.treemapSliceDice({arguments})")

    @staticmethod
    def packSiblings(circles=None):
        """
        Source · Packs the specified array of circles, each of which must have a circle.r
        property specifying the circle’s radius. Assigns the following properties to each
        circle:
        The circles are positioned according to the front-chain packing algorithm by Wang et
        al.

        See more informations `here <https://d3js.org/d3-hierarchy/pack#packSiblings>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (circles,))))
        return d3(f"d3.packSiblings({arguments})")

    @staticmethod
    def packEnclose(circles=None):
        """
        Examples · Source · Computes the smallest circle that encloses the specified array of
        circles, each of which must have a circle.r property specifying the circle’s radius,
        and circle.x and circle.y properties specifying the circle’s center. The enclosing
        circle is computed using the Matoušek-Sharir-Welzl algorithm. (See also Apollonius’
        Problem.)

        See more informations `here <https://d3js.org/d3-hierarchy/pack#packEnclose>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (circles,))))
        return d3(f"d3.packEnclose({arguments})")

    @staticmethod
    @repr_wrapper
    def interpolate(a=None, b=None):
        """
        Examples · Source · Returns an interpolator between the two arbitrary values a and b.
        .. code:: javascript

            d3.interpolate("red", "blue")(0.5) // "rgb(128, 0, 128)"

        The interpolator implementation is based on the type of the end value b, using the
        following algorithm:
        Based on the chosen interpolator, a is coerced to the suitable corresponding type.

        See more informations `here <https://d3js.org/d3-interpolate/value#interpolate>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (a, b))))
        return d3(f"d3.interpolate({arguments})")

    @staticmethod
    @repr_wrapper
    def interpolateNumber(a=None, b=None):
        """
        Examples · Source · Returns an interpolator between the two numbers a and b.
        .. code:: javascript

            d3.interpolateNumber(20, 620)(0.8) // 500

        The returned interpolator is equivalent to:
        .. code:: javascript

            function interpolator(t) {
              return a * (1 - t) + b * t;
            }


        See more informations `here <https://d3js.org/d3-interpolate/value#interpolateNumber>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (a, b))))
        return d3(f"d3.interpolateNumber({arguments})")

    @staticmethod
    @repr_wrapper
    def interpolateRound(a=None, b=None):
        """
        Examples · Source · Returns an interpolator between the two numbers a and b.
        .. code:: javascript

            d3.interpolateRound(20, 620)(0.821) // 513

        The interpolator is similar to interpolateNumber except it will round the resulting
        value to the nearest integer.

        See more informations `here <https://d3js.org/d3-interpolate/value#interpolateRound>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (a, b))))
        return d3(f"d3.interpolateRound({arguments})")

    @staticmethod
    @repr_wrapper
    def interpolateString(a=None, b=None):
        """
        Examples · Source · Returns an interpolator between the two strings a and b.
        .. code:: javascript

            d3.interpolateString("20px", "32px")(0.5) // "26px"

        The string interpolator finds numbers embedded in a and b, where each number is of the
        form understood by JavaScript. A few examples of numbers that will be detected within a
        string: -1, 42, 3.14159, and 6.0221413e+23.
        For each number embedded in b, the interpolator will attempt to find a corresponding
        number in a. If a corresponding number is found, a numeric interpolator is created
        using interpolateNumber. The remaining parts of the string b are used as a template:
        the static parts of the string b remain constant for the interpolation, with the
        interpolated numeric values embedded in the template.
        For example, if a is "300 12px sans-serif", and b is "500 36px Comic-Sans", two
        embedded numbers are found. The remaining static parts (of string b) are a space
        between the two numbers (" "), and the suffix ("px Comic-Sans"). The result of the
        interpolator at t = 0.5 is "400 24px Comic-Sans".

        See more informations `here <https://d3js.org/d3-interpolate/value#interpolateString>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (a, b))))
        return d3(f"d3.interpolateString({arguments})")

    @staticmethod
    @repr_wrapper
    def interpolateDate(a=None, b=None):
        """
        Examples · Source · Returns an interpolator between the two dates a and b.
        .. code:: javascript

            d3.interpolateDate(new Date("2014-01-01"), new Date("2024-01-01"))(0.5) // 2019-01-01


        See more informations `here <https://d3js.org/d3-interpolate/value#interpolateDate>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (a, b))))
        return d3(f"d3.interpolateDate({arguments})")

    @staticmethod
    @repr_wrapper
    def interpolateArray(a=None, b=None):
        """
        Examples · Source · Returns an interpolator between the two arrays a and b.
        .. code:: javascript

            d3.interpolateArray([0, 0, 0], [1, 2, 3])(0.5) // [0.5, 1, 1.5]

        If b is a typed array (e.g., Float64Array), interpolateNumberArray is called instead.
        Internally, an array template is created that is the same length as b. For each element
        in b, if there exists a corresponding element in a, a generic interpolator is created
        for the two elements using interpolate. If there is no such element, the static value
        from b is used in the template. Then, for the given parameter t, the template’s
        embedded interpolators are evaluated. The updated array template is then returned.
        For example, if a is the array [0, 1] and b is the array [1, 10, 100], then the result
        of the interpolator for t = 0.5 is the array [0.5, 5.5, 100].

        See more informations `here <https://d3js.org/d3-interpolate/value#interpolateArray>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (a, b))))
        return d3(f"d3.interpolateArray({arguments})")

    @staticmethod
    @repr_wrapper
    def interpolateNumberArray(a=None, b=None):
        """
        Examples · Source · Returns an interpolator between the two arrays of numbers a and b.
        .. code:: javascript

            d3.interpolateNumberArray([0, 1], Float64Array.of(1, 3))(0.5) // [0.5, 2]

        Internally, an array template is created that is the same type and length as b. For
        each element in b, if there exists a corresponding element in a, the values are
        directly interpolated in the array template. If there is no such element, the static
        value from b is copied. The updated array template is then returned.

        See more informations `here <https://d3js.org/d3-interpolate/value#interpolateNumberArray>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (a, b))))
        return d3(f"d3.interpolateNumberArray({arguments})")

    @staticmethod
    @repr_wrapper
    def interpolateObject(a=None, b=None):
        """
        Examples · Source · Returns an interpolator between the two objects a and b.
        .. code:: javascript

            d3.interpolateObject({x: 0, y: 1}, {x: 1, y: 10, z: 100})(0.5) // {x: 0.5, y: 5.5, z: 100}

        Internally, an object template is created that has the same properties as b. For each
        property in b, if there exists a corresponding property in a, a generic interpolator is
        created for the two elements using interpolate. If there is no such property, the
        static value from b is used in the template. Then, for the given parameter t, the
        template's embedded interpolators are evaluated and the updated object template is then
        returned.
        For example, if a is the object {x: 0, y: 1} and b is the object {x: 1, y: 10, z: 100},
        the result of the interpolator for t = 0.5 is the object {x: 0.5, y: 5.5, z: 100}.
        Object interpolation is particularly useful for dataspace interpolation, where data is
        interpolated rather than attribute values. For example, you can interpolate an object
        which describes an arc in a pie chart, and then use arc to compute the new SVG path
        data.

        See more informations `here <https://d3js.org/d3-interpolate/value#interpolateObject>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (a, b))))
        return d3(f"d3.interpolateObject({arguments})")

    @staticmethod
    @repr_wrapper
    def interpolateBasis(values=None):
        """
        Examples · Source · Returns a uniform nonrational B-spline interpolator through the
        specified array of values, which must be numbers.
        .. code:: javascript

            d3.interpolateBasis([0, 0.1, 0.4, 1])(0.5) // 0.2604166666666667

        Implicit control points are generated such that the interpolator returns values[0] at t
        = 0 and values[values.length - 1] at t = 1. See also curveBasis and
        interpolateRgbBasis.

        See more informations `here <https://d3js.org/d3-interpolate/value#interpolateBasis>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (values,))))
        return d3(f"d3.interpolateBasis({arguments})")

    @staticmethod
    @repr_wrapper
    def interpolateBasisClosed(values=None):
        """
        Examples · Source · Returns a uniform nonrational B-spline interpolator through the
        specified array of values, which must be numbers.
        .. code:: javascript

            d3.interpolateBasisClosed([0, 0.1, 0.4, 1])(0.5) // 0.45

        The control points are implicitly repeated such that the resulting one-dimensional
        spline has cyclical C² continuity when repeated around t in [0,1]. See also
        curveBasisClosed and interpolateRgbBasisClosed.

        See more informations `here <https://d3js.org/d3-interpolate/value#interpolateBasisClosed>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (values,))))
        return d3(f"d3.interpolateBasisClosed({arguments})")

    @staticmethod
    @repr_wrapper
    def interpolateDiscrete(values=None):
        """
        Examples · Source · Returns a discrete interpolator for the given array of values.
        .. code:: javascript

            d3.interpolateDiscrete(["red", "blue", "green"])(0.5) // "blue"

        The returned interpolator maps t in [0, 1 / n) to values[0], t in [1 / n, 2 / n) to
        values[1], and so on, where n = values.length. In effect, this is a lightweight
        quantize scale with a fixed domain of [0, 1].

        See more informations `here <https://d3js.org/d3-interpolate/value#interpolateDiscrete>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (values,))))
        return d3(f"d3.interpolateDiscrete({arguments})")

    @staticmethod
    def quantize(interpolator=None, n=None):
        """
        Examples · Source · Returns n uniformly-spaced samples from the specified interpolator,
        where n is an integer greater than one.
        .. code:: javascript

            d3.quantize(d3.interpolate("red", "blue"), 4) // ["rgb(255, 0, 0)", "rgb(170, 0, 85)", "rgb(85, 0, 170)", "rgb(0, 0, 255)"]

        The first sample is always at t = 0, and the last sample is always at t = 1. This can
        be useful in generating a fixed number of samples from a given interpolator, such as to
        derive the range of a quantize scale from a continuous interpolator.

        See more informations `here <https://d3js.org/d3-interpolate/value#quantize>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (interpolator, n))))
        return d3(f"d3.quantize({arguments})")

    @staticmethod
    def piecewise(interpolate=None, values=None):
        """
        Examples · Source · Returns a piecewise interpolator, composing interpolators for each
        adjacent pair of values.
        .. code:: javascript

            d3.piecewise(d3.interpolateRgb.gamma(2.2), ["red", "green", "blue"])

        If interpolate is not specified, defaults to interpolate.
        .. code:: javascript

            d3.piecewise(["red", "green", "blue"])

        The returned interpolator maps t in [0, 1 / (n - 1)] to interpolate(values[0],
        values[1]), t in [1 / (n - 1), 2 / (n - 1)] to interpolate(values[1], values[2]), and
        so on, where n = values.length. In effect, this is a lightweight linear scale.

        See more informations `here <https://d3js.org/d3-interpolate/value#piecewise>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (interpolate, values))))
        return d3(f"d3.piecewise({arguments})")

    @staticmethod
    @repr_wrapper
    def interpolateRgb(a=None, b=None):
        """
        .. code:: javascript

            d3.interpolateRgb("purple", "orange")

        Examples · Source · Returns an RGB color space interpolator between the two colors a
        and b with a configurable gamma. If the gamma is not specified, it defaults to 1.0. The
        colors a and b need not be in RGB; they will be converted to RGB using d3.rgb. The
        return value of the interpolator is an RGB string.

        See more informations `here <https://d3js.org/d3-interpolate/color#interpolateRgb>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (a, b))))
        return d3(f"d3.interpolateRgb({arguments})")

    @staticmethod
    @repr_wrapper
    def interpolateRgbBasis(colors=None):
        """
        .. code:: javascript

            d3.interpolateRgbBasis(["purple", "green", "orange"])

        Examples · Source · Returns a uniform nonrational B-spline interpolator through the
        specified array of colors, which are converted to RGB color space. Implicit control
        points are generated such that the interpolator returns colors[0] at t = 0 and
        colors[colors.length - 1] at t = 1. Opacity interpolation is not currently supported.
        See also d3.interpolateBasis, and see d3-scale-chromatic for examples.

        See more informations `here <https://d3js.org/d3-interpolate/color#interpolateRgbBasis>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (colors,))))
        return d3(f"d3.interpolateRgbBasis({arguments})")

    @staticmethod
    @repr_wrapper
    def interpolateRgbBasisClosed(colors=None):
        """
        .. code:: javascript

            d3.interpolateRgbBasisClosed(["purple", "green", "orange"])

        Examples · Source · Returns a uniform nonrational B-spline interpolator through the
        specified array of colors, which are converted to RGB color space. The control points
        are implicitly repeated such that the resulting spline has cyclical C² continuity when
        repeated around t in [0,1]; this is useful, for example, to create cyclical color
        scales. Opacity interpolation is not currently supported. See also
        d3.interpolateBasisClosed, and see d3-scale-chromatic for examples.

        See more informations `here <https://d3js.org/d3-interpolate/color#interpolateRgbBasisClosed>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (colors,))))
        return d3(f"d3.interpolateRgbBasisClosed({arguments})")

    @staticmethod
    @repr_wrapper
    def interpolateHsl(a=None, b=None):
        """
        .. code:: javascript

            d3.interpolateHsl("purple", "orange")

        Examples · Source · Returns an HSL color space interpolator between the two colors a
        and b. The colors a and b need not be in HSL; they will be converted to HSL using
        d3.hsl. If either color’s hue or saturation is NaN, the opposing color’s channel value
        is used. The shortest path between hues is used. The return value of the interpolator
        is an RGB string.

        See more informations `here <https://d3js.org/d3-interpolate/color#interpolateHsl>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (a, b))))
        return d3(f"d3.interpolateHsl({arguments})")

    @staticmethod
    @repr_wrapper
    def interpolateHslLong(a=None, b=None):
        """
        .. code:: javascript

            d3.interpolateHslLong("purple", "orange")

        Examples · Source · Like interpolateHsl, but does not use the shortest path between
        hues.

        See more informations `here <https://d3js.org/d3-interpolate/color#interpolateHslLong>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (a, b))))
        return d3(f"d3.interpolateHslLong({arguments})")

    @staticmethod
    @repr_wrapper
    def interpolateLab(a=None, b=None):
        """
        .. code:: javascript

            d3.interpolateLab("purple", "orange")

        Examples · Source · Returns a CIELAB color space interpolator between the two colors a
        and b. The colors a and b need not be in CIELAB; they will be converted to CIELAB using
        d3.lab. The return value of the interpolator is an RGB string.

        See more informations `here <https://d3js.org/d3-interpolate/color#interpolateLab>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (a, b))))
        return d3(f"d3.interpolateLab({arguments})")

    @staticmethod
    @repr_wrapper
    def interpolateHcl(a=None, b=None):
        """
        .. code:: javascript

            d3.interpolateHcl("purple", "orange")

        Examples · Source · Returns a CIELChab color space interpolator between the two colors
        a and b. The colors a and b need not be in CIELChab; they will be converted to CIELChab
        using d3.hcl. If either color’s hue or chroma is NaN, the opposing color’s channel
        value is used. The shortest path between hues is used. The return value of the
        interpolator is an RGB string.

        See more informations `here <https://d3js.org/d3-interpolate/color#interpolateHcl>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (a, b))))
        return d3(f"d3.interpolateHcl({arguments})")

    @staticmethod
    @repr_wrapper
    def interpolateHclLong(a=None, b=None):
        """
        .. code:: javascript

            d3.interpolateHclLong("purple", "orange")

        Examples · Source · Like interpolateHcl, but does not use the shortest path between
        hues.

        See more informations `here <https://d3js.org/d3-interpolate/color#interpolateHclLong>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (a, b))))
        return d3(f"d3.interpolateHclLong({arguments})")

    @staticmethod
    @repr_wrapper
    def interpolateCubehelix(a=None, b=None):
        """
        .. code:: javascript

            d3.interpolateCubehelix("purple", "orange")

        .. code:: javascript

            d3.interpolateCubehelix.gamma(3)("purple", "orange")

        Examples · Source · Returns a Cubehelix color space interpolator between the two colors
        a and b using a configurable gamma. If the gamma is not specified, it defaults to 1.0.
        The colors a and b need not be in Cubehelix; they will be converted to Cubehelix using
        d3.cubehelix. If either color’s hue or saturation is NaN, the opposing color’s channel
        value is used. The shortest path between hues is used. The return value of the
        interpolator is an RGB string.

        See more informations `here <https://d3js.org/d3-interpolate/color#interpolateCubehelix>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (a, b))))
        return d3(f"d3.interpolateCubehelix({arguments})")

    @staticmethod
    @repr_wrapper
    def interpolateCubehelixLong(a=None, b=None):
        """
        .. code:: javascript

            d3.interpolateCubehelixLong("purple", "orange")

        .. code:: javascript

            d3.interpolateCubehelixLong.gamma(3)("purple", "orange")

        Examples · Source · Like interpolateCubehelix, but does not use the shortest path
        between hues.

        See more informations `here <https://d3js.org/d3-interpolate/color#interpolateCubehelixLong>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (a, b))))
        return d3(f"d3.interpolateCubehelixLong({arguments})")

    @staticmethod
    @repr_wrapper
    def interpolateHue(a=None, b=None):
        """
        .. code:: javascript

            d3.interpolateHue(20, 340)(0.5) // 0

        Examples · Source · Returns an interpolator between the two hue angles a and b. If
        either hue is NaN, the opposing value is used. The shortest path between hues is used.
        The return value of the interpolator is a number in [0, 360).
        Whereas standard interpolators blend from a starting value a at t = 0 to an ending
        value b at t = 1, spline interpolators smoothly blend multiple input values for t in
        [0,1] using piecewise polynomial functions. Only cubic uniform nonrational B-splines
        are currently supported, also known as basis splines.

        See more informations `here <https://d3js.org/d3-interpolate/color#interpolateHue>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (a, b))))
        return d3(f"d3.interpolateHue({arguments})")

    @staticmethod
    @repr_wrapper
    def interpolateTransformCss(a=None, b=None):
        """
        .. code:: javascript

            d3.interpolateTransformCss("translateY(12px) scale(2)", "translateX(30px) rotate(5deg)")(0.5) // "translate(15px,6px) rotate(2.5deg) scale(1.5,1.5)"

        Examples · Source · Returns an interpolator between the two 2D CSS transforms
        represented by a and b. Each transform is decomposed to a standard representation of
        translate, rotate, x-skew and scale; these component transformations are then
        interpolated.

        See more informations `here <https://d3js.org/d3-interpolate/transform#interpolateTransformCss>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (a, b))))
        return d3(f"d3.interpolateTransformCss({arguments})")

    @staticmethod
    @repr_wrapper
    def interpolateTransformSvg(a=None, b=None):
        """
        .. code:: javascript

            d3.interpolateTransformSvg("skewX(-60)", "skewX(60) translate(280,0)") // "translate(140,0) skewX(0)"

        Examples · Source · Returns an interpolator between the two 2D SVG transforms
        represented by a and b. Each transform is decomposed to a standard representation of
        translate, rotate, x-skew and scale; these component transformations are then
        interpolated.

        See more informations `here <https://d3js.org/d3-interpolate/transform#interpolateTransformSvg>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (a, b))))
        return d3(f"d3.interpolateTransformSvg({arguments})")

    @staticmethod
    def pathRound(digits=3):
        """
        Source · Like path, except limits the digits after the decimal to the specified number
        of digits. Useful for reducing the size of generated SVG path data.
        .. code:: javascript

            const path = d3.pathRound(3);


        See more informations `here <https://d3js.org/d3-path#pathRound>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (digits,))))
        return d3(f"d3.pathRound({arguments})")

    @staticmethod
    def polygonArea(polygon=None):
        """
        .. code:: javascript

            d3.polygonArea([[1, 1], [1.5, 0], [2, 1]]) // -0.5

        Source · Returns the signed area of the specified polygon. If the vertices of the
        polygon are in counterclockwise order (assuming a coordinate system where the origin is
        in the top-left corner), the returned area is positive; otherwise it is negative, or
        zero.

        See more informations `here <https://d3js.org/d3-polygon#polygonArea>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (polygon,))))
        return d3(f"d3.polygonArea({arguments})")

    @staticmethod
    def polygonCentroid(polygon=None):
        """
        .. code:: javascript

            d3.polygonCentroid([[1, 1], [1.5, 0], [2, 1]]) // [1.5, 0.6666666666666666]

        Source · Returns the centroid of the specified polygon.

        See more informations `here <https://d3js.org/d3-polygon#polygonCentroid>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (polygon,))))
        return d3(f"d3.polygonCentroid({arguments})")

    @staticmethod
    def polygonHull(points=None):
        """
        .. code:: javascript

            d3.polygonHull(points) // [[3.0872864263338777, -1.300100095019402], [1.6559368816733773, -2.5092525689499605], …]

        Source · Returns the convex hull of the specified points using Andrew’s monotone chain
        algorithm. The returned hull is represented as an array containing a subset of the
        input points arranged in counterclockwise order. Returns null if points has fewer than
        three elements.

        See more informations `here <https://d3js.org/d3-polygon#polygonHull>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (points,))))
        return d3(f"d3.polygonHull({arguments})")

    @staticmethod
    def polygonContains(polygon=None, point=None):
        """
        .. code:: javascript

            d3.polygonContains([[1, 1], [1.5, 0], [2, 1]], [1.5, 0.667]) // true

        Source · Returns true if and only if the specified point is inside the specified
        polygon.

        See more informations `here <https://d3js.org/d3-polygon#polygonContains>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (polygon, point))))
        return d3(f"d3.polygonContains({arguments})")

    @staticmethod
    def polygonLength(polygon=None):
        """
        .. code:: javascript

            d3.polygonLength([[1, 1], [1.5, 0], [2, 1]]) // 3.23606797749979

        Source · Returns the length of the perimeter of the specified polygon.

        See more informations `here <https://d3js.org/d3-polygon#polygonLength>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (polygon,))))
        return d3(f"d3.polygonLength({arguments})")

    @staticmethod
    def randomLcg(seed=None):
        """
        .. code:: javascript

            d3.randomLcg(42)

        Examples · Source · Returns a linear congruential generator; this function can be
        called repeatedly to obtain pseudorandom values well-distributed on the interval [0,1)
        and with a long period (up to 1 billion numbers), similar to Math.random. A seed can be
        specified as a real number in the interval [0,1) or as any integer. In the latter case,
        only the lower 32 bits are considered. Two generators instanced with the same seed
        generate the same sequence, allowing to create reproducible pseudo-random experiments.
        If the seed is not specified, one is chosen using Math.random.

        See more informations `here <https://d3js.org/d3-random#randomLcg>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (seed,))))
        return d3(f"d3.randomLcg({arguments})")

    @staticmethod
    def tickFormat(start=None, stop=None, count=None, specifier=None):
        """
        Examples · Source · Returns a number format function suitable for displaying a tick
        value, automatically computing the appropriate precision based on the fixed interval
        between tick values, as determined by d3.tickStep.
        .. code:: javascript

            const f = d3.tickFormat(0, 1, 20);
            f(1); // "1.00"

        An optional specifier allows a custom format where the precision of the format is
        automatically set by the scale as appropriate for the tick interval. For example, to
        format percentage change, you might say:
        .. code:: javascript

            const f = d3.tickFormat(-1, 1, 5, "+%");
            f(-0.5); // "-50%"

        If specifier uses the format type s, the scale will return a SI-prefix format based on
        the larger absolute value of start and stop. If the specifier already specifies a
        precision, this method is equivalent to locale.format.

        See more informations `here <https://d3js.org/d3-scale/linear#tickFormat>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (start, stop, count, specifier))))
        return d3(f"d3.tickFormat({arguments})")

    @staticmethod
    @repr_wrapper
    def schemeCategory10():
        """
        Source · An array of ten categorical colors represented as RGB hexadecimal strings.

        See more informations `here <https://d3js.org/d3-scale-chromatic/categorical#schemeCategory10>`_.
        """
        return d3("d3.schemeCategory10()")

    @staticmethod
    @repr_wrapper
    def schemeAccent():
        """
        Source · An array of eight categorical colors represented as RGB hexadecimal strings.

        See more informations `here <https://d3js.org/d3-scale-chromatic/categorical#schemeAccent>`_.
        """
        return d3("d3.schemeAccent()")

    @staticmethod
    @repr_wrapper
    def schemeDark2():
        """
        Source · An array of eight categorical colors represented as RGB hexadecimal strings.

        See more informations `here <https://d3js.org/d3-scale-chromatic/categorical#schemeDark2>`_.
        """
        return d3("d3.schemeDark2()")

    @staticmethod
    @repr_wrapper
    def schemeObservable10():
        """
        Source · An array of ten categorical colors represented as RGB hexadecimal strings.

        See more informations `here <https://d3js.org/d3-scale-chromatic/categorical#schemeObservable10>`_.
        """
        return d3("d3.schemeObservable10()")

    @staticmethod
    @repr_wrapper
    def schemePaired():
        """
        Source · An array of twelve categorical colors represented as RGB hexadecimal strings.

        See more informations `here <https://d3js.org/d3-scale-chromatic/categorical#schemePaired>`_.
        """
        return d3("d3.schemePaired()")

    @staticmethod
    @repr_wrapper
    def schemePastel1():
        """
        Source · An array of nine categorical colors represented as RGB hexadecimal strings.

        See more informations `here <https://d3js.org/d3-scale-chromatic/categorical#schemePastel1>`_.
        """
        return d3("d3.schemePastel1()")

    @staticmethod
    @repr_wrapper
    def schemePastel2():
        """
        Source · An array of eight categorical colors represented as RGB hexadecimal strings.

        See more informations `here <https://d3js.org/d3-scale-chromatic/categorical#schemePastel2>`_.
        """
        return d3("d3.schemePastel2()")

    @staticmethod
    @repr_wrapper
    def schemeSet1():
        """
        Source · An array of nine categorical colors represented as RGB hexadecimal strings.

        See more informations `here <https://d3js.org/d3-scale-chromatic/categorical#schemeSet1>`_.
        """
        return d3("d3.schemeSet1()")

    @staticmethod
    @repr_wrapper
    def schemeSet2():
        """
        Source · An array of eight categorical colors represented as RGB hexadecimal strings.

        See more informations `here <https://d3js.org/d3-scale-chromatic/categorical#schemeSet2>`_.
        """
        return d3("d3.schemeSet2()")

    @staticmethod
    @repr_wrapper
    def schemeSet3():
        """
        Source · An array of twelve categorical colors represented as RGB hexadecimal strings.

        See more informations `here <https://d3js.org/d3-scale-chromatic/categorical#schemeSet3>`_.
        """
        return d3("d3.schemeSet3()")

    @staticmethod
    @repr_wrapper
    def schemeTableau10():
        """
        Source · An array of ten categorical colors authored by Tableau as part of Tableau 10
        represented as RGB hexadecimal strings.

        See more informations `here <https://d3js.org/d3-scale-chromatic/categorical#schemeTableau10>`_.
        """
        return d3("d3.schemeTableau10()")

    @staticmethod
    @repr_wrapper
    def interpolateRainbow(t=None):
        """
        Source · Given a number t in the range [0,1], returns the corresponding color from
        d3.interpolateWarm scale from [0.0, 0.5] followed by the d3.interpolateCool scale from
        [0.5, 1.0], thus implementing the cyclical less-angry rainbow color scheme.

        See more informations `here <https://d3js.org/d3-scale-chromatic/cyclical#interpolateRainbow>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (t,))))
        return d3(f"d3.interpolateRainbow({arguments})")

    @staticmethod
    @repr_wrapper
    def interpolateSinebow(t=None):
        """
        Source · Given a number t in the range [0,1], returns the corresponding color from the
        “sinebow” color scheme by Jim Bumgardner and Charlie Loyd.

        See more informations `here <https://d3js.org/d3-scale-chromatic/cyclical#interpolateSinebow>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (t,))))
        return d3(f"d3.interpolateSinebow({arguments})")

    @staticmethod
    @repr_wrapper
    def interpolateBrBG(t=None):
        """
        Source · Given a number t in the range [0,1], returns the corresponding color from the
        “BrBG” diverging color scheme represented as an RGB string.

        See more informations `here <https://d3js.org/d3-scale-chromatic/diverging#interpolateBrBG>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (t,))))
        return d3(f"d3.interpolateBrBG({arguments})")

    @staticmethod
    @repr_wrapper
    def interpolatePiYG(t=None):
        """
        Source · Given a number t in the range [0,1], returns the corresponding color from the
        “PiYG” diverging color scheme represented as an RGB string.

        See more informations `here <https://d3js.org/d3-scale-chromatic/diverging#interpolatePiYG>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (t,))))
        return d3(f"d3.interpolatePiYG({arguments})")

    @staticmethod
    @repr_wrapper
    def interpolatePRGn(t=None):
        """
        Source · Given a number t in the range [0,1], returns the corresponding color from the
        “PRGn” diverging color scheme represented as an RGB string.

        See more informations `here <https://d3js.org/d3-scale-chromatic/diverging#interpolatePRGn>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (t,))))
        return d3(f"d3.interpolatePRGn({arguments})")

    @staticmethod
    @repr_wrapper
    def interpolatePuOr(t=None):
        """
        Source · Given a number t in the range [0,1], returns the corresponding color from the
        “PuOr” diverging color scheme represented as an RGB string.

        See more informations `here <https://d3js.org/d3-scale-chromatic/diverging#interpolatePuOr>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (t,))))
        return d3(f"d3.interpolatePuOr({arguments})")

    @staticmethod
    @repr_wrapper
    def interpolateRdBu(t=None):
        """
        Source · Given a number t in the range [0,1], returns the corresponding color from the
        “RdBu” diverging color scheme represented as an RGB string.

        See more informations `here <https://d3js.org/d3-scale-chromatic/diverging#interpolateRdBu>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (t,))))
        return d3(f"d3.interpolateRdBu({arguments})")

    @staticmethod
    @repr_wrapper
    def interpolateRdGy(t=None):
        """
        Source · Given a number t in the range [0,1], returns the corresponding color from the
        “RdGy” diverging color scheme represented as an RGB string.

        See more informations `here <https://d3js.org/d3-scale-chromatic/diverging#interpolateRdGy>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (t,))))
        return d3(f"d3.interpolateRdGy({arguments})")

    @staticmethod
    @repr_wrapper
    def interpolateRdYlBu(t=None):
        """
        Source · Given a number t in the range [0,1], returns the corresponding color from the
        “RdYlBu” diverging color scheme represented as an RGB string.

        See more informations `here <https://d3js.org/d3-scale-chromatic/diverging#interpolateRdYlBu>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (t,))))
        return d3(f"d3.interpolateRdYlBu({arguments})")

    @staticmethod
    @repr_wrapper
    def interpolateRdYlGn(t=None):
        """
        Source · Given a number t in the range [0,1], returns the corresponding color from the
        “RdYlGn” diverging color scheme represented as an RGB string.

        See more informations `here <https://d3js.org/d3-scale-chromatic/diverging#interpolateRdYlGn>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (t,))))
        return d3(f"d3.interpolateRdYlGn({arguments})")

    @staticmethod
    @repr_wrapper
    def interpolateSpectral(t=None):
        """
        Source · Given a number t in the range [0,1], returns the corresponding color from the
        “Spectral” diverging color scheme represented as an RGB string.

        See more informations `here <https://d3js.org/d3-scale-chromatic/diverging#interpolateSpectral>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (t,))))
        return d3(f"d3.interpolateSpectral({arguments})")

    @staticmethod
    @repr_wrapper
    def schemeBrBG():
        """
        Source · The “BrBG” discrete diverging color scheme of size k in 3–11.

        See more informations `here <https://d3js.org/d3-scale-chromatic/diverging#schemeBrBG>`_.
        """
        return d3("d3.schemeBrBG()")

    @staticmethod
    @repr_wrapper
    def schemePiYG():
        """
        Source · The “PiYG” discrete diverging color scheme of size k in 3–11.

        See more informations `here <https://d3js.org/d3-scale-chromatic/diverging#schemePiYG>`_.
        """
        return d3("d3.schemePiYG()")

    @staticmethod
    @repr_wrapper
    def schemePRGn():
        """
        Source · The “PRGn” discrete diverging color scheme of size k in 3–11.

        See more informations `here <https://d3js.org/d3-scale-chromatic/diverging#schemePRGn>`_.
        """
        return d3("d3.schemePRGn()")

    @staticmethod
    @repr_wrapper
    def schemePuOr():
        """
        Source · The “PuOr” discrete diverging color scheme of size k in 3–11.

        See more informations `here <https://d3js.org/d3-scale-chromatic/diverging#schemePuOr>`_.
        """
        return d3("d3.schemePuOr()")

    @staticmethod
    @repr_wrapper
    def schemeRdBu():
        """
        Source · The “RdBu” discrete diverging color scheme of size k in 3–11.

        See more informations `here <https://d3js.org/d3-scale-chromatic/diverging#schemeRdBu>`_.
        """
        return d3("d3.schemeRdBu()")

    @staticmethod
    @repr_wrapper
    def schemeRdGy():
        """
        Source · The “RdGy” discrete diverging color scheme of size k in 3–11.

        See more informations `here <https://d3js.org/d3-scale-chromatic/diverging#schemeRdGy>`_.
        """
        return d3("d3.schemeRdGy()")

    @staticmethod
    @repr_wrapper
    def schemeRdYlBu():
        """
        Source · The “RdYlBu” discrete diverging color scheme of size k in 3–11.

        See more informations `here <https://d3js.org/d3-scale-chromatic/diverging#schemeRdYlBu>`_.
        """
        return d3("d3.schemeRdYlBu()")

    @staticmethod
    @repr_wrapper
    def schemeRdYlGn():
        """
        Source · The “RdYlGn” discrete diverging color scheme of size k in 3–11.

        See more informations `here <https://d3js.org/d3-scale-chromatic/diverging#schemeRdYlGn>`_.
        """
        return d3("d3.schemeRdYlGn()")

    @staticmethod
    @repr_wrapper
    def schemeSpectral():
        """
        Source · The “Spectral” discrete diverging color scheme of size k in 3–11.

        See more informations `here <https://d3js.org/d3-scale-chromatic/diverging#schemeSpectral>`_.
        """
        return d3("d3.schemeSpectral()")

    @staticmethod
    @repr_wrapper
    def interpolateBlues(t=None):
        """
        Source · Given a number t in the range [0,1], returns the corresponding color from the
        “Blues” sequential color scheme represented as an RGB string.

        See more informations `here <https://d3js.org/d3-scale-chromatic/sequential#interpolateBlues>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (t,))))
        return d3(f"d3.interpolateBlues({arguments})")

    @staticmethod
    @repr_wrapper
    def interpolateGreens(t=None):
        """
        Source · Given a number t in the range [0,1], returns the corresponding color from the
        “Greens” sequential color scheme represented as an RGB string.

        See more informations `here <https://d3js.org/d3-scale-chromatic/sequential#interpolateGreens>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (t,))))
        return d3(f"d3.interpolateGreens({arguments})")

    @staticmethod
    @repr_wrapper
    def interpolateGreys(t=None):
        """
        Source · Given a number t in the range [0,1], returns the corresponding color from the
        “Greys” sequential color scheme represented as an RGB string.

        See more informations `here <https://d3js.org/d3-scale-chromatic/sequential#interpolateGreys>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (t,))))
        return d3(f"d3.interpolateGreys({arguments})")

    @staticmethod
    @repr_wrapper
    def interpolateOranges(t=None):
        """
        Source · Given a number t in the range [0,1], returns the corresponding color from the
        “Oranges” sequential color scheme represented as an RGB string.

        See more informations `here <https://d3js.org/d3-scale-chromatic/sequential#interpolateOranges>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (t,))))
        return d3(f"d3.interpolateOranges({arguments})")

    @staticmethod
    @repr_wrapper
    def interpolatePurples(t=None):
        """
        Source · Given a number t in the range [0,1], returns the corresponding color from the
        “Purples” sequential color scheme represented as an RGB string.

        See more informations `here <https://d3js.org/d3-scale-chromatic/sequential#interpolatePurples>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (t,))))
        return d3(f"d3.interpolatePurples({arguments})")

    @staticmethod
    @repr_wrapper
    def interpolateReds(t=None):
        """
        Source · Given a number t in the range [0,1], returns the corresponding color from the
        “Reds” sequential color scheme represented as an RGB string.

        See more informations `here <https://d3js.org/d3-scale-chromatic/sequential#interpolateReds>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (t,))))
        return d3(f"d3.interpolateReds({arguments})")

    @staticmethod
    @repr_wrapper
    def schemeBlues():
        """
        Source · The “Blues” discrete sequential color scheme of size k in 3–9.

        See more informations `here <https://d3js.org/d3-scale-chromatic/sequential#schemeBlues>`_.
        """
        return d3("d3.schemeBlues()")

    @staticmethod
    @repr_wrapper
    def schemeGreens():
        """
        Source · The “Greens” discrete sequential color scheme of size k in 3–9.

        See more informations `here <https://d3js.org/d3-scale-chromatic/sequential#schemeGreens>`_.
        """
        return d3("d3.schemeGreens()")

    @staticmethod
    @repr_wrapper
    def schemeGreys():
        """
        Source · The “Greys” discrete sequential color scheme of size k in 3–9.

        See more informations `here <https://d3js.org/d3-scale-chromatic/sequential#schemeGreys>`_.
        """
        return d3("d3.schemeGreys()")

    @staticmethod
    @repr_wrapper
    def schemeOranges():
        """
        Source · The “Oranges” discrete sequential color scheme of size k in 3–9.

        See more informations `here <https://d3js.org/d3-scale-chromatic/sequential#schemeOranges>`_.
        """
        return d3("d3.schemeOranges()")

    @staticmethod
    @repr_wrapper
    def schemePurples():
        """
        Source · The “Purples” discrete sequential color scheme of size k in 3–9.

        See more informations `here <https://d3js.org/d3-scale-chromatic/sequential#schemePurples>`_.
        """
        return d3("d3.schemePurples()")

    @staticmethod
    @repr_wrapper
    def schemeReds():
        """
        Source · The “Reds” discrete sequential color scheme of size k in 3–9.

        See more informations `here <https://d3js.org/d3-scale-chromatic/sequential#schemeReds>`_.
        """
        return d3("d3.schemeReds()")

    @staticmethod
    @repr_wrapper
    def interpolateBuGn(t=None):
        """
        Source · Given a number t in the range [0,1], returns the corresponding color from the
        “BuGn” sequential color scheme represented as an RGB string.

        See more informations `here <https://d3js.org/d3-scale-chromatic/sequential#interpolateBuGn>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (t,))))
        return d3(f"d3.interpolateBuGn({arguments})")

    @staticmethod
    @repr_wrapper
    def interpolateBuPu(t=None):
        """
        Source · Given a number t in the range [0,1], returns the corresponding color from the
        “BuPu” sequential color scheme represented as an RGB string.

        See more informations `here <https://d3js.org/d3-scale-chromatic/sequential#interpolateBuPu>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (t,))))
        return d3(f"d3.interpolateBuPu({arguments})")

    @staticmethod
    @repr_wrapper
    def interpolateCividis(t=None):
        """
        Source · Given a number t in the range [0,1], returns the corresponding color from the
        “cividis” color vision deficiency-optimized color scheme designed by Nuñez, Anderton,
        and Renslow, represented as an RGB string.

        See more informations `here <https://d3js.org/d3-scale-chromatic/sequential#interpolateCividis>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (t,))))
        return d3(f"d3.interpolateCividis({arguments})")

    @staticmethod
    @repr_wrapper
    def interpolateCool(t=None):
        """
        Source · Given a number t in the range [0,1], returns the corresponding color from
        Niccoli’s perceptual rainbow, represented as an RGB string.

        See more informations `here <https://d3js.org/d3-scale-chromatic/sequential#interpolateCool>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (t,))))
        return d3(f"d3.interpolateCool({arguments})")

    @staticmethod
    @repr_wrapper
    def interpolateCubehelixDefault(t=None):
        """
        Source · Given a number t in the range [0,1], returns the corresponding color from
        Green’s default Cubehelix represented as an RGB string.

        See more informations `here <https://d3js.org/d3-scale-chromatic/sequential#interpolateCubehelixDefault>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (t,))))
        return d3(f"d3.interpolateCubehelixDefault({arguments})")

    @staticmethod
    @repr_wrapper
    def interpolateGnBu(t=None):
        """
        Source · Given a number t in the range [0,1], returns the corresponding color from the
        “GnBu” sequential color scheme represented as an RGB string.

        See more informations `here <https://d3js.org/d3-scale-chromatic/sequential#interpolateGnBu>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (t,))))
        return d3(f"d3.interpolateGnBu({arguments})")

    @staticmethod
    @repr_wrapper
    def interpolateInferno(t=None):
        """
        Source · Given a number t in the range [0,1], returns the corresponding color from the
        “inferno” perceptually-uniform color scheme designed by van der Walt and Smith for
        matplotlib, represented as an RGB string.

        See more informations `here <https://d3js.org/d3-scale-chromatic/sequential#interpolateInferno>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (t,))))
        return d3(f"d3.interpolateInferno({arguments})")

    @staticmethod
    @repr_wrapper
    def interpolateMagma(t=None):
        """
        Source · Given a number t in the range [0,1], returns the corresponding color from the
        “magma” perceptually-uniform color scheme designed by van der Walt and Smith for
        matplotlib, represented as an RGB string.

        See more informations `here <https://d3js.org/d3-scale-chromatic/sequential#interpolateMagma>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (t,))))
        return d3(f"d3.interpolateMagma({arguments})")

    @staticmethod
    @repr_wrapper
    def interpolateOrRd(t=None):
        """
        Source · Given a number t in the range [0,1], returns the corresponding color from the
        “OrRd” sequential color scheme represented as an RGB string.

        See more informations `here <https://d3js.org/d3-scale-chromatic/sequential#interpolateOrRd>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (t,))))
        return d3(f"d3.interpolateOrRd({arguments})")

    @staticmethod
    @repr_wrapper
    def interpolatePlasma(t=None):
        """
        Source · Given a number t in the range [0,1], returns the corresponding color from the
        “plasma” perceptually-uniform color scheme designed by van der Walt and Smith for
        matplotlib, represented as an RGB string.

        See more informations `here <https://d3js.org/d3-scale-chromatic/sequential#interpolatePlasma>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (t,))))
        return d3(f"d3.interpolatePlasma({arguments})")

    @staticmethod
    @repr_wrapper
    def interpolatePuBu(t=None):
        """
        Source · Given a number t in the range [0,1], returns the corresponding color from the
        “PuBu” sequential color scheme represented as an RGB string.

        See more informations `here <https://d3js.org/d3-scale-chromatic/sequential#interpolatePuBu>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (t,))))
        return d3(f"d3.interpolatePuBu({arguments})")

    @staticmethod
    @repr_wrapper
    def interpolatePuBuGn(t=None):
        """
        Source · Given a number t in the range [0,1], returns the corresponding color from the
        “PuBuGn” sequential color scheme represented as an RGB string.

        See more informations `here <https://d3js.org/d3-scale-chromatic/sequential#interpolatePuBuGn>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (t,))))
        return d3(f"d3.interpolatePuBuGn({arguments})")

    @staticmethod
    @repr_wrapper
    def interpolatePuRd(t=None):
        """
        Source · Given a number t in the range [0,1], returns the corresponding color from the
        “PuRd” sequential color scheme represented as an RGB string.

        See more informations `here <https://d3js.org/d3-scale-chromatic/sequential#interpolatePuRd>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (t,))))
        return d3(f"d3.interpolatePuRd({arguments})")

    @staticmethod
    @repr_wrapper
    def interpolateRdPu(t=None):
        """
        Source · Given a number t in the range [0,1], returns the corresponding color from the
        “RdPu” sequential color scheme represented as an RGB string.

        See more informations `here <https://d3js.org/d3-scale-chromatic/sequential#interpolateRdPu>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (t,))))
        return d3(f"d3.interpolateRdPu({arguments})")

    @staticmethod
    @repr_wrapper
    def interpolateTurbo(t=None):
        """
        Source · Given a number t in the range [0,1], returns the corresponding color from the
        “turbo” color scheme by Anton Mikhailov.

        See more informations `here <https://d3js.org/d3-scale-chromatic/sequential#interpolateTurbo>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (t,))))
        return d3(f"d3.interpolateTurbo({arguments})")

    @staticmethod
    @repr_wrapper
    def interpolateViridis(t=None):
        """
        Source · Given a number t in the range [0,1], returns the corresponding color from the
        “viridis” perceptually-uniform color scheme designed by van der Walt, Smith and Firing
        for matplotlib, represented as an RGB string.

        See more informations `here <https://d3js.org/d3-scale-chromatic/sequential#interpolateViridis>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (t,))))
        return d3(f"d3.interpolateViridis({arguments})")

    @staticmethod
    @repr_wrapper
    def interpolateWarm(t=None):
        """
        Source · Given a number t in the range [0,1], returns the corresponding color from a
        180° rotation of Niccoli’s perceptual rainbow, represented as an RGB string.

        See more informations `here <https://d3js.org/d3-scale-chromatic/sequential#interpolateWarm>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (t,))))
        return d3(f"d3.interpolateWarm({arguments})")

    @staticmethod
    @repr_wrapper
    def interpolateYlGn(t=None):
        """
        Source · Given a number t in the range [0,1], returns the corresponding color from the
        “YlGn” sequential color scheme represented as an RGB string.

        See more informations `here <https://d3js.org/d3-scale-chromatic/sequential#interpolateYlGn>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (t,))))
        return d3(f"d3.interpolateYlGn({arguments})")

    @staticmethod
    @repr_wrapper
    def interpolateYlGnBu(t=None):
        """
        Source · Given a number t in the range [0,1], returns the corresponding color from the
        “YlGnBu” sequential color scheme represented as an RGB string.

        See more informations `here <https://d3js.org/d3-scale-chromatic/sequential#interpolateYlGnBu>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (t,))))
        return d3(f"d3.interpolateYlGnBu({arguments})")

    @staticmethod
    @repr_wrapper
    def interpolateYlOrBr(t=None):
        """
        Source · Given a number t in the range [0,1], returns the corresponding color from the
        “YlOrBr” sequential color scheme represented as an RGB string.

        See more informations `here <https://d3js.org/d3-scale-chromatic/sequential#interpolateYlOrBr>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (t,))))
        return d3(f"d3.interpolateYlOrBr({arguments})")

    @staticmethod
    @repr_wrapper
    def interpolateYlOrRd(t=None):
        """
        Source · Given a number t in the range [0,1], returns the corresponding color from the
        “YlOrRd” sequential color scheme represented as an RGB string.

        See more informations `here <https://d3js.org/d3-scale-chromatic/sequential#interpolateYlOrRd>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (t,))))
        return d3(f"d3.interpolateYlOrRd({arguments})")

    @staticmethod
    @repr_wrapper
    def schemeBuGn():
        """
        Source · The “BuGn” discrete sequential color scheme of size k in 3–9.

        See more informations `here <https://d3js.org/d3-scale-chromatic/sequential#schemeBuGn>`_.
        """
        return d3("d3.schemeBuGn()")

    @staticmethod
    @repr_wrapper
    def schemeBuPu():
        """
        Source · The “BuPu” discrete sequential color scheme of size k in 3–9.

        See more informations `here <https://d3js.org/d3-scale-chromatic/sequential#schemeBuPu>`_.
        """
        return d3("d3.schemeBuPu()")

    @staticmethod
    @repr_wrapper
    def schemeGnBu():
        """
        Source · The “GnBu” discrete sequential color scheme of size k in 3–9.

        See more informations `here <https://d3js.org/d3-scale-chromatic/sequential#schemeGnBu>`_.
        """
        return d3("d3.schemeGnBu()")

    @staticmethod
    @repr_wrapper
    def schemeOrRd():
        """
        Source · The “OrRd” discrete sequential color scheme of size k in 3–9.

        See more informations `here <https://d3js.org/d3-scale-chromatic/sequential#schemeOrRd>`_.
        """
        return d3("d3.schemeOrRd()")

    @staticmethod
    @repr_wrapper
    def schemePuBu():
        """
        Source · The “PuBu” discrete sequential color scheme of size k in 3–9.

        See more informations `here <https://d3js.org/d3-scale-chromatic/sequential#schemePuBu>`_.
        """
        return d3("d3.schemePuBu()")

    @staticmethod
    @repr_wrapper
    def schemePuBuGn():
        """
        Source · The “PuBuGn” discrete sequential color scheme of size k in 3–9.

        See more informations `here <https://d3js.org/d3-scale-chromatic/sequential#schemePuBuGn>`_.
        """
        return d3("d3.schemePuBuGn()")

    @staticmethod
    @repr_wrapper
    def schemePuRd():
        """
        Source · The “PuRd” discrete sequential color scheme of size k in 3–9.

        See more informations `here <https://d3js.org/d3-scale-chromatic/sequential#schemePuRd>`_.
        """
        return d3("d3.schemePuRd()")

    @staticmethod
    @repr_wrapper
    def schemeRdPu():
        """
        Source · The “RdPu” discrete sequential color scheme of size k in 3–9.

        See more informations `here <https://d3js.org/d3-scale-chromatic/sequential#schemeRdPu>`_.
        """
        return d3("d3.schemeRdPu()")

    @staticmethod
    @repr_wrapper
    def schemeYlGn():
        """
        Source · The “YlGn” discrete sequential color scheme of size k in 3–9.

        See more informations `here <https://d3js.org/d3-scale-chromatic/sequential#schemeYlGn>`_.
        """
        return d3("d3.schemeYlGn()")

    @staticmethod
    @repr_wrapper
    def schemeYlGnBu():
        """
        Source · The “YlGnBu” discrete sequential color scheme of size k in 3–9.

        See more informations `here <https://d3js.org/d3-scale-chromatic/sequential#schemeYlGnBu>`_.
        """
        return d3("d3.schemeYlGnBu()")

    @staticmethod
    @repr_wrapper
    def schemeYlOrBr():
        """
        Source · The “YlOrBr” discrete sequential color scheme of size k in 3–9.

        See more informations `here <https://d3js.org/d3-scale-chromatic/sequential#schemeYlOrBr>`_.
        """
        return d3("d3.schemeYlOrBr()")

    @staticmethod
    @repr_wrapper
    def schemeYlOrRd():
        """
        Source · The “YlOrRd” discrete sequential color scheme of size k in 3–9.

        See more informations `here <https://d3js.org/d3-scale-chromatic/sequential#schemeYlOrRd>`_.
        """
        return d3("d3.schemeYlOrRd()")

    @staticmethod
    def matcher(selector=None):
        """
        Source · Given the specified selector, returns a function which returns true if this
        element matches the specified selector. This method is used internally by
        selection.filter. For example, this:
        .. code:: javascript

            const div = selection.filter("div");

        Is equivalent to:
        .. code:: javascript

            const div = selection.filter(d3.matcher("div"));

        (Although D3 is not a compatibility layer, this implementation does support
        vendor-prefixed implementations due to the recent standardization of element.matches.)

        See more informations `here <https://d3js.org/d3-selection/selecting#matcher>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (selector,))))
        return d3(f"d3.matcher({arguments})")

    @staticmethod
    def selector(selector=None):
        """
        Source · Given the specified selector, returns a function which returns the first
        descendant of this element that matches the specified selector. This method is used
        internally by selection.select. For example, this:
        .. code:: javascript

            const div = selection.select("div");

        Is equivalent to:
        .. code:: javascript

            const div = selection.select(d3.selector("div"));


        See more informations `here <https://d3js.org/d3-selection/selecting#selector>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (selector,))))
        return d3(f"d3.selector({arguments})")

    @staticmethod
    def selectorAll(selector=None):
        """
        Source · Given the specified selector, returns a function which returns all descendants
        of this element that match the specified selector. This method is used internally by
        selection.selectAll. For example, this:
        .. code:: javascript

            const div = selection.selectAll("div");

        Is equivalent to:
        .. code:: javascript

            const div = selection.selectAll(d3.selectorAll("div"));


        See more informations `here <https://d3js.org/d3-selection/selecting#selectorAll>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (selector,))))
        return d3(f"d3.selectorAll({arguments})")

    @staticmethod
    def window(node=None):
        """
        Source · Returns the owner window for the specified node. If node is a node, returns
        the owner document’s default view; if node is a document, returns its default view;
        otherwise returns the node.

        See more informations `here <https://d3js.org/d3-selection/selecting#window>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (node,))))
        return d3(f"d3.window({arguments})")

    @staticmethod
    def style(node=None, name=None):
        """
        Source · Returns the value of the style property with the specified name for the
        specified node. If the node has an inline style with the specified name, its value is
        returned; otherwise, the computed property value is returned. See also selection.style.

        See more informations `here <https://d3js.org/d3-selection/selecting#style>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (node, name))))
        return d3(f"d3.style({arguments})")

    @staticmethod
    def create(name=None):
        """
        Source · Given the specified element name, returns a single-element selection
        containing a detached element of the given name in the current document. This method
        assumes the HTML namespace, so you must specify a namespace explicitly when creating
        SVG or other non-HTML elements; see namespace for details on supported namespace
        prefixes.
        .. code:: javascript

            d3.create("svg") // equivalent to svg:svg

        .. code:: javascript

            d3.create("svg:svg") // more explicitly

        .. code:: javascript

            d3.create("svg:g") // an SVG G element

        .. code:: javascript

            d3.create("g") // an HTML G (unknown) element


        See more informations `here <https://d3js.org/d3-selection/modifying#create>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (name,))))
        return d3(f"d3.create({arguments})")

    @staticmethod
    def creator(name=None):
        """
        Source · Given the specified element name, returns a function which creates an element
        of the given name, assuming that this is the parent element. This method is used
        internally by selection.append and selection.insert to create new elements. For
        example, this:
        .. code:: javascript

            selection.append("div");

        Is equivalent to:
        .. code:: javascript

            selection.append(d3.creator("div"));

        See namespace for details on supported namespace prefixes, such as for SVG elements.

        See more informations `here <https://d3js.org/d3-selection/modifying#creator>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (name,))))
        return d3(f"d3.creator({arguments})")

    @staticmethod
    def pointer(event=None, target=None):
        """
        Source · Returns a two-element array of numbers [x, y] representing the coordinates of
        the specified event relative to the specified target.
        .. code:: javascript

            const [x, y] = d3.pointer(event);

        event can be a MouseEvent, a PointerEvent, a Touch, or a custom event holding a UIEvent
        as event.sourceEvent.
        If target is not specified, it defaults to the source event’s currentTarget property,
        if available. If the target is an SVG element, the event’s coordinates are transformed
        using the inverse of the screen coordinate transformation matrix. If the target is an
        HTML element, the event’s coordinates are translated relative to the top-left corner of
        the target’s bounding client rectangle. (As such, the coordinate system can only be
        translated relative to the client coordinates. See also GeometryUtils.) Otherwise,
        [event.pageX, event.pageY] is returned.

        See more informations `here <https://d3js.org/d3-selection/events#pointer>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (event, target))))
        return d3(f"d3.pointer({arguments})")

    @staticmethod
    def pointers(event=None, target=None):
        """
        Source · Returns an array [[x0, y0], [x1, y1]…] of coordinates of the specified event’s
        pointer locations relative to the specified target.
        .. code:: javascript

            const points = d3.pointers(event);

        For touch events, the returned array of positions corresponds to the event.touches
        array; for other events, returns a single-element array.
        If target is not specified, it defaults to the source event’s currentTarget property,
        if any.

        See more informations `here <https://d3js.org/d3-selection/events#pointers>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (event, target))))
        return d3(f"d3.pointers({arguments})")

    @staticmethod
    def namespace(name=None):
        """
        Source · Qualifies the specified name, which may or may not have a namespace prefix.
        .. code:: javascript

            d3.namespace("svg:text") // {space: "http://www.w3.org/2000/svg", local: "text"}

        If the name contains a colon (:), the substring before the colon is interpreted as the
        namespace prefix, which must be registered in d3.namespaces. Returns an object space
        and local attributes describing the full namespace URL and the local name. If the name
        does not contain a colon, this function merely returns the input name.

        See more informations `here <https://d3js.org/d3-selection/namespaces#namespace>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (name,))))
        return d3(f"d3.namespace({arguments})")

    @staticmethod
    def namespaces():
        """
        Source · The map of registered namespace prefixes. The initial value is:
        .. code:: javascript

            {
              svg: "http://www.w3.org/2000/svg",
              xhtml: "http://www.w3.org/1999/xhtml",
              xlink: "http://www.w3.org/1999/xlink",
              xml: "http://www.w3.org/XML/1998/namespace",
              xmlns: "http://www.w3.org/2000/xmlns/"
            }

        Additional prefixes may be assigned as needed to create elements or attributes in other
        namespaces.

        See more informations `here <https://d3js.org/d3-selection/namespaces#namespaces>`_.
        """
        return d3("d3.namespaces()")

    @staticmethod
    def symbolsFill():
        """
        Source · An array containing a set of symbol types designed for filling: circle, cross,
        diamond, square, star, triangle, and wye. Useful for a categorical shape encoding with
        an ordinal scale.
        .. code:: javascript

            const symbolType = d3.scaleOrdinal(d3.symbolsFill);


        See more informations `here <https://d3js.org/d3-shape/symbol#symbolsFill>`_.
        """
        return d3("d3.symbolsFill()")

    @staticmethod
    def symbolsStroke():
        """
        Source · An array containing a set of symbol types designed for stroking: circle, plus,
        times, triangle2, asterisk, square2, and diamond2. Useful for a categorical shape
        encoding with an ordinal scale.
        .. code:: javascript

            const symbolType = d3.scaleOrdinal(d3.symbolsStroke);


        See more informations `here <https://d3js.org/d3-shape/symbol#symbolsStroke>`_.
        """
        return d3("d3.symbolsStroke()")

    @staticmethod
    def symbolAsterisk():
        """
        Source · The asterisk symbol type; intended for stroking.

        See more informations `here <https://d3js.org/d3-shape/symbol#symbolAsterisk>`_.
        """
        return d3("d3.symbolAsterisk()")

    @staticmethod
    def symbolCircle():
        """
        Source · The circle symbol type; intended for either filling or stroking.

        See more informations `here <https://d3js.org/d3-shape/symbol#symbolCircle>`_.
        """
        return d3("d3.symbolCircle()")

    @staticmethod
    def symbolCross():
        """
        Source · The Greek cross symbol type, with arms of equal length; intended for filling.

        See more informations `here <https://d3js.org/d3-shape/symbol#symbolCross>`_.
        """
        return d3("d3.symbolCross()")

    @staticmethod
    def symbolDiamond():
        """
        Source · The rhombus symbol type; intended for filling.

        See more informations `here <https://d3js.org/d3-shape/symbol#symbolDiamond>`_.
        """
        return d3("d3.symbolDiamond()")

    @staticmethod
    def symbolDiamond2():
        """
        Source · The rotated square symbol type; intended for stroking.

        See more informations `here <https://d3js.org/d3-shape/symbol#symbolDiamond2>`_.
        """
        return d3("d3.symbolDiamond2()")

    @staticmethod
    def symbolPlus():
        """
        Source · The plus symbol type; intended for stroking.

        See more informations `here <https://d3js.org/d3-shape/symbol#symbolPlus>`_.
        """
        return d3("d3.symbolPlus()")

    @staticmethod
    def symbolSquare():
        """
        Source · The square symbol type; intended for filling.

        See more informations `here <https://d3js.org/d3-shape/symbol#symbolSquare>`_.
        """
        return d3("d3.symbolSquare()")

    @staticmethod
    def symbolSquare2():
        """
        Source · The square2 symbol type; intended for stroking.

        See more informations `here <https://d3js.org/d3-shape/symbol#symbolSquare2>`_.
        """
        return d3("d3.symbolSquare2()")

    @staticmethod
    def symbolStar():
        """
        Source · The pentagonal star (pentagram) symbol type; intended for filling.

        See more informations `here <https://d3js.org/d3-shape/symbol#symbolStar>`_.
        """
        return d3("d3.symbolStar()")

    @staticmethod
    def symbolTriangle():
        """
        Source · The up-pointing triangle symbol type; intended for filling.

        See more informations `here <https://d3js.org/d3-shape/symbol#symbolTriangle>`_.
        """
        return d3("d3.symbolTriangle()")

    @staticmethod
    def symbolTriangle2():
        """
        Source · The up-pointing triangle symbol type; intended for stroking.

        See more informations `here <https://d3js.org/d3-shape/symbol#symbolTriangle2>`_.
        """
        return d3("d3.symbolTriangle2()")

    @staticmethod
    def symbolWye():
        """
        Source · The Y-shape symbol type; intended for filling.

        See more informations `here <https://d3js.org/d3-shape/symbol#symbolWye>`_.
        """
        return d3("d3.symbolWye()")

    @staticmethod
    def pointRadial(angle=None, radius=None):
        """
        Examples · Source · Returns the point [x, y] for the given angle in radians, with 0 at
        -y (12 o’clock) and positive angles proceeding clockwise, and the given radius.
        .. code:: javascript

            d3.pointRadial(Math.PI / 3, 100) // [86.60254037844386, -50]


        See more informations `here <https://d3js.org/d3-shape/symbol#pointRadial>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (angle, radius))))
        return d3(f"d3.pointRadial({arguments})")

    @staticmethod
    def stackOrderAppearance(series=None):
        """
        .. code:: javascript

            const stack = d3.stack().order(d3.stackOrderAppearance);

        Source · Returns a series order such that the earliest series (according to the maximum
        value) is at the bottom.
        .. code:: javascript

            const stack = d3.stack().order(d3.stackOrderAscending);

        Source · Returns a series order such that the smallest series (according to the sum of
        values) is at the bottom.
        .. code:: javascript

            const stack = d3.stack().order(d3.stackOrderDescending);

        Source · Returns a series order such that the largest series (according to the sum of
        values) is at the bottom.
        .. code:: javascript

            const stack = d3.stack().order(d3.stackOrderInsideOut);

        Source · Returns a series order such that the earliest series (according to the maximum
        value) are on the inside and the later series are on the outside. This order is
        recommended for streamgraphs in conjunction with the wiggle offset. See Stacked Graphs
        — Geometry & Aesthetics by Byron & Wattenberg for more information.
        .. code:: javascript

            const stack = d3.stack().order(d3.stackOrderNone);

        Source · Returns the given series order [0, 1, … n - 1] where n is the number of
        elements in series. Thus, the stack order is given by the key accessor.
        .. code:: javascript

            const stack = d3.stack().order(d3.stackOrderReverse);

        Source · Returns the reverse of the given series order [n - 1, n - 2, … 0] where n is
        the number of elements in series. Thus, the stack order is given by the reverse of the
        key accessor.

        See more informations `here <https://d3js.org/d3-shape/stack#stackOrderAppearance>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (series,))))
        return d3(f"d3.stackOrderAppearance({arguments})")

    @staticmethod
    def stackOrderAscending(series=None):
        """
        .. code:: javascript

            const stack = d3.stack().order(d3.stackOrderAscending);

        Source · Returns a series order such that the smallest series (according to the sum of
        values) is at the bottom.
        .. code:: javascript

            const stack = d3.stack().order(d3.stackOrderDescending);

        Source · Returns a series order such that the largest series (according to the sum of
        values) is at the bottom.
        .. code:: javascript

            const stack = d3.stack().order(d3.stackOrderInsideOut);

        Source · Returns a series order such that the earliest series (according to the maximum
        value) are on the inside and the later series are on the outside. This order is
        recommended for streamgraphs in conjunction with the wiggle offset. See Stacked Graphs
        — Geometry & Aesthetics by Byron & Wattenberg for more information.
        .. code:: javascript

            const stack = d3.stack().order(d3.stackOrderNone);

        Source · Returns the given series order [0, 1, … n - 1] where n is the number of
        elements in series. Thus, the stack order is given by the key accessor.
        .. code:: javascript

            const stack = d3.stack().order(d3.stackOrderReverse);

        Source · Returns the reverse of the given series order [n - 1, n - 2, … 0] where n is
        the number of elements in series. Thus, the stack order is given by the reverse of the
        key accessor.

        See more informations `here <https://d3js.org/d3-shape/stack#stackOrderAscending>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (series,))))
        return d3(f"d3.stackOrderAscending({arguments})")

    @staticmethod
    def stackOrderDescending(series=None):
        """
        .. code:: javascript

            const stack = d3.stack().order(d3.stackOrderDescending);

        Source · Returns a series order such that the largest series (according to the sum of
        values) is at the bottom.
        .. code:: javascript

            const stack = d3.stack().order(d3.stackOrderInsideOut);

        Source · Returns a series order such that the earliest series (according to the maximum
        value) are on the inside and the later series are on the outside. This order is
        recommended for streamgraphs in conjunction with the wiggle offset. See Stacked Graphs
        — Geometry & Aesthetics by Byron & Wattenberg for more information.
        .. code:: javascript

            const stack = d3.stack().order(d3.stackOrderNone);

        Source · Returns the given series order [0, 1, … n - 1] where n is the number of
        elements in series. Thus, the stack order is given by the key accessor.
        .. code:: javascript

            const stack = d3.stack().order(d3.stackOrderReverse);

        Source · Returns the reverse of the given series order [n - 1, n - 2, … 0] where n is
        the number of elements in series. Thus, the stack order is given by the reverse of the
        key accessor.

        See more informations `here <https://d3js.org/d3-shape/stack#stackOrderDescending>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (series,))))
        return d3(f"d3.stackOrderDescending({arguments})")

    @staticmethod
    def stackOrderInsideOut(series=None):
        """
        .. code:: javascript

            const stack = d3.stack().order(d3.stackOrderInsideOut);

        Source · Returns a series order such that the earliest series (according to the maximum
        value) are on the inside and the later series are on the outside. This order is
        recommended for streamgraphs in conjunction with the wiggle offset. See Stacked Graphs
        — Geometry & Aesthetics by Byron & Wattenberg for more information.
        .. code:: javascript

            const stack = d3.stack().order(d3.stackOrderNone);

        Source · Returns the given series order [0, 1, … n - 1] where n is the number of
        elements in series. Thus, the stack order is given by the key accessor.
        .. code:: javascript

            const stack = d3.stack().order(d3.stackOrderReverse);

        Source · Returns the reverse of the given series order [n - 1, n - 2, … 0] where n is
        the number of elements in series. Thus, the stack order is given by the reverse of the
        key accessor.

        See more informations `here <https://d3js.org/d3-shape/stack#stackOrderInsideOut>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (series,))))
        return d3(f"d3.stackOrderInsideOut({arguments})")

    @staticmethod
    def stackOrderNone(series=None):
        """
        .. code:: javascript

            const stack = d3.stack().order(d3.stackOrderNone);

        Source · Returns the given series order [0, 1, … n - 1] where n is the number of
        elements in series. Thus, the stack order is given by the key accessor.
        .. code:: javascript

            const stack = d3.stack().order(d3.stackOrderReverse);

        Source · Returns the reverse of the given series order [n - 1, n - 2, … 0] where n is
        the number of elements in series. Thus, the stack order is given by the reverse of the
        key accessor.

        See more informations `here <https://d3js.org/d3-shape/stack#stackOrderNone>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (series,))))
        return d3(f"d3.stackOrderNone({arguments})")

    @staticmethod
    def stackOrderReverse(series=None):
        """
        .. code:: javascript

            const stack = d3.stack().order(d3.stackOrderReverse);

        Source · Returns the reverse of the given series order [n - 1, n - 2, … 0] where n is
        the number of elements in series. Thus, the stack order is given by the reverse of the
        key accessor.

        See more informations `here <https://d3js.org/d3-shape/stack#stackOrderReverse>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (series,))))
        return d3(f"d3.stackOrderReverse({arguments})")

    @staticmethod
    def stackOffsetExpand(series=None, order=None):
        """
        .. code:: javascript

            const stack = d3.stack().offset(d3.stackOffsetExpand);

        Source · Applies a zero baseline and normalizes the values for each point such that the
        topline is always one.
        .. code:: javascript

            const stack = d3.stack().offset(d3.stackOffsetDiverging);

        Source · Positive values are stacked above zero, negative values are stacked below
        zero, and zero values are stacked at zero.
        .. code:: javascript

            const stack = d3.stack().offset(d3.stackOffsetNone);

        Source · Applies a zero baseline.
        .. code:: javascript

            const stack = d3.stack().offset(d3.stackOffsetSilhouette);

        Source · Shifts the baseline down such that the center of the streamgraph is always at
        zero.
        .. code:: javascript

            const stack = d3.stack().offset(d3.stackOffsetWiggle);

        Source · Shifts the baseline so as to minimize the weighted wiggle of layers. This
        offset is recommended for streamgraphs in conjunction with the inside-out order. See
        Stacked Graphs — Geometry & Aesthetics by Bryon & Wattenberg for more information.

        See more informations `here <https://d3js.org/d3-shape/stack#stackOffsetExpand>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (series, order))))
        return d3(f"d3.stackOffsetExpand({arguments})")

    @staticmethod
    def stackOffsetDiverging(series=None, order=None):
        """
        .. code:: javascript

            const stack = d3.stack().offset(d3.stackOffsetDiverging);

        Source · Positive values are stacked above zero, negative values are stacked below
        zero, and zero values are stacked at zero.
        .. code:: javascript

            const stack = d3.stack().offset(d3.stackOffsetNone);

        Source · Applies a zero baseline.
        .. code:: javascript

            const stack = d3.stack().offset(d3.stackOffsetSilhouette);

        Source · Shifts the baseline down such that the center of the streamgraph is always at
        zero.
        .. code:: javascript

            const stack = d3.stack().offset(d3.stackOffsetWiggle);

        Source · Shifts the baseline so as to minimize the weighted wiggle of layers. This
        offset is recommended for streamgraphs in conjunction with the inside-out order. See
        Stacked Graphs — Geometry & Aesthetics by Bryon & Wattenberg for more information.

        See more informations `here <https://d3js.org/d3-shape/stack#stackOffsetDiverging>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (series, order))))
        return d3(f"d3.stackOffsetDiverging({arguments})")

    @staticmethod
    def stackOffsetNone(series=None, order=None):
        """
        .. code:: javascript

            const stack = d3.stack().offset(d3.stackOffsetNone);

        Source · Applies a zero baseline.
        .. code:: javascript

            const stack = d3.stack().offset(d3.stackOffsetSilhouette);

        Source · Shifts the baseline down such that the center of the streamgraph is always at
        zero.
        .. code:: javascript

            const stack = d3.stack().offset(d3.stackOffsetWiggle);

        Source · Shifts the baseline so as to minimize the weighted wiggle of layers. This
        offset is recommended for streamgraphs in conjunction with the inside-out order. See
        Stacked Graphs — Geometry & Aesthetics by Bryon & Wattenberg for more information.

        See more informations `here <https://d3js.org/d3-shape/stack#stackOffsetNone>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (series, order))))
        return d3(f"d3.stackOffsetNone({arguments})")

    @staticmethod
    def stackOffsetSilhouette(series=None, order=None):
        """
        .. code:: javascript

            const stack = d3.stack().offset(d3.stackOffsetSilhouette);

        Source · Shifts the baseline down such that the center of the streamgraph is always at
        zero.
        .. code:: javascript

            const stack = d3.stack().offset(d3.stackOffsetWiggle);

        Source · Shifts the baseline so as to minimize the weighted wiggle of layers. This
        offset is recommended for streamgraphs in conjunction with the inside-out order. See
        Stacked Graphs — Geometry & Aesthetics by Bryon & Wattenberg for more information.

        See more informations `here <https://d3js.org/d3-shape/stack#stackOffsetSilhouette>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (series, order))))
        return d3(f"d3.stackOffsetSilhouette({arguments})")

    @staticmethod
    def stackOffsetWiggle(series=None, order=None):
        """
        .. code:: javascript

            const stack = d3.stack().offset(d3.stackOffsetWiggle);

        Source · Shifts the baseline so as to minimize the weighted wiggle of layers. This
        offset is recommended for streamgraphs in conjunction with the inside-out order. See
        Stacked Graphs — Geometry & Aesthetics by Bryon & Wattenberg for more information.

        See more informations `here <https://d3js.org/d3-shape/stack#stackOffsetWiggle>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (series, order))))
        return d3(f"d3.stackOffsetWiggle({arguments})")

    @staticmethod
    def timeMillisecond():
        """
        Source · Milliseconds in local time; the shortest available time unit.

        See more informations `here <https://d3js.org/d3-time#timeMillisecond>`_.
        """
        return d3("d3.timeMillisecond()")

    @staticmethod
    def timeSecond():
        """
        Source · Seconds in local time (e.g., 01:23:45.0000 AM); 1,000 milliseconds.

        See more informations `here <https://d3js.org/d3-time#timeSecond>`_.
        """
        return d3("d3.timeSecond()")

    @staticmethod
    def timeMinute():
        """
        Source · Minutes in local time (e.g., 01:02:00 AM); 60 seconds. Note that ECMAScript
        ignores leap seconds.

        See more informations `here <https://d3js.org/d3-time#timeMinute>`_.
        """
        return d3("d3.timeMinute()")

    @staticmethod
    def timeHour():
        """
        Source · Hours in local time (e.g., 01:00 AM); 60 minutes. Note that advancing time by
        one hour in local time can return the same hour or skip an hour due to daylight saving.

        See more informations `here <https://d3js.org/d3-time#timeHour>`_.
        """
        return d3("d3.timeHour()")

    @staticmethod
    def timeDay():
        """
        Source · Days in local time (e.g., February 7, 2012 at 12:00 AM); typically 24 hours.
        Days in local time may range from 23 to 25 hours due to daylight saving. d3.unixDay is
        like d3.utcDay, except it counts days since the UNIX epoch (January 1, 1970) such that
        interval.every returns uniformly-spaced dates rather than varying based on
        day-of-month.

        See more informations `here <https://d3js.org/d3-time#timeDay>`_.
        """
        return d3("d3.timeDay()")

    @staticmethod
    def timeWeek():
        """
        Source · Alias for d3.timeSunday; 7 days and typically 168 hours. Weeks in local time
        may range from 167 to 169 hours due to daylight saving.

        See more informations `here <https://d3js.org/d3-time#timeWeek>`_.
        """
        return d3("d3.timeWeek()")

    @staticmethod
    def timeSunday():
        """
        Source · Sunday-based weeks in local time (e.g., February 5, 2012 at 12:00 AM).

        See more informations `here <https://d3js.org/d3-time#timeSunday>`_.
        """
        return d3("d3.timeSunday()")

    @staticmethod
    def timeMonday():
        """
        Source · Monday-based weeks in local time (e.g., February 6, 2012 at 12:00 AM).

        See more informations `here <https://d3js.org/d3-time#timeMonday>`_.
        """
        return d3("d3.timeMonday()")

    @staticmethod
    def timeTuesday():
        """
        Source · Tuesday-based weeks in local time (e.g., February 7, 2012 at 12:00 AM).

        See more informations `here <https://d3js.org/d3-time#timeTuesday>`_.
        """
        return d3("d3.timeTuesday()")

    @staticmethod
    def timeWednesday():
        """
        Source · Wednesday-based weeks in local time (e.g., February 8, 2012 at 12:00 AM).

        See more informations `here <https://d3js.org/d3-time#timeWednesday>`_.
        """
        return d3("d3.timeWednesday()")

    @staticmethod
    def timeThursday():
        """
        Source · Thursday-based weeks in local time (e.g., February 9, 2012 at 12:00 AM).

        See more informations `here <https://d3js.org/d3-time#timeThursday>`_.
        """
        return d3("d3.timeThursday()")

    @staticmethod
    def timeFriday():
        """
        Source · Friday-based weeks in local time (e.g., February 10, 2012 at 12:00 AM).

        See more informations `here <https://d3js.org/d3-time#timeFriday>`_.
        """
        return d3("d3.timeFriday()")

    @staticmethod
    def timeSaturday():
        """
        Source · Saturday-based weeks in local time (e.g., February 11, 2012 at 12:00 AM).

        See more informations `here <https://d3js.org/d3-time#timeSaturday>`_.
        """
        return d3("d3.timeSaturday()")

    @staticmethod
    def timeMonth():
        """
        Source · Months in local time (e.g., February 1, 2012 at 12:00 AM); ranges from 28 to
        31 days.

        See more informations `here <https://d3js.org/d3-time#timeMonth>`_.
        """
        return d3("d3.timeMonth()")

    @staticmethod
    def timeYear():
        """
        Source · Years in local time (e.g., January 1, 2012 at 12:00 AM); ranges from 365 to
        366 days.

        See more informations `here <https://d3js.org/d3-time#timeYear>`_.
        """
        return d3("d3.timeYear()")

    @staticmethod
    def utcMillisecond():
        """
        Source · Milliseconds in local time; the shortest available time unit.

        See more informations `here <https://d3js.org/d3-time#timeMillisecond>`_.
        """
        return d3("d3.utcMillisecond()")

    @staticmethod
    def utcSecond():
        """
        Source · Seconds in local time (e.g., 01:23:45.0000 AM); 1,000 milliseconds.

        See more informations `here <https://d3js.org/d3-time#timeSecond>`_.
        """
        return d3("d3.utcSecond()")

    @staticmethod
    def utcMinute():
        """
        Source · Minutes in local time (e.g., 01:02:00 AM); 60 seconds. Note that ECMAScript
        ignores leap seconds.

        See more informations `here <https://d3js.org/d3-time#timeMinute>`_.
        """
        return d3("d3.utcMinute()")

    @staticmethod
    def utcHour():
        """
        Source · Hours in local time (e.g., 01:00 AM); 60 minutes. Note that advancing time by
        one hour in local time can return the same hour or skip an hour due to daylight saving.

        See more informations `here <https://d3js.org/d3-time#timeHour>`_.
        """
        return d3("d3.utcHour()")

    @staticmethod
    def utcDay():
        """
        Source · Days in local time (e.g., February 7, 2012 at 12:00 AM); typically 24 hours.
        Days in local time may range from 23 to 25 hours due to daylight saving. d3.unixDay is
        like d3.utcDay, except it counts days since the UNIX epoch (January 1, 1970) such that
        interval.every returns uniformly-spaced dates rather than varying based on
        day-of-month.

        See more informations `here <https://d3js.org/d3-time#timeDay>`_.
        """
        return d3("d3.utcDay()")

    @staticmethod
    def utcWeek():
        """
        Source · Alias for d3.timeSunday; 7 days and typically 168 hours. Weeks in local time
        may range from 167 to 169 hours due to daylight saving.

        See more informations `here <https://d3js.org/d3-time#timeWeek>`_.
        """
        return d3("d3.utcWeek()")

    @staticmethod
    def utcSunday():
        """
        Source · Sunday-based weeks in local time (e.g., February 5, 2012 at 12:00 AM).

        See more informations `here <https://d3js.org/d3-time#timeSunday>`_.
        """
        return d3("d3.utcSunday()")

    @staticmethod
    def utcMonday():
        """
        Source · Monday-based weeks in local time (e.g., February 6, 2012 at 12:00 AM).

        See more informations `here <https://d3js.org/d3-time#timeMonday>`_.
        """
        return d3("d3.utcMonday()")

    @staticmethod
    def utcTuesday():
        """
        Source · Tuesday-based weeks in local time (e.g., February 7, 2012 at 12:00 AM).

        See more informations `here <https://d3js.org/d3-time#timeTuesday>`_.
        """
        return d3("d3.utcTuesday()")

    @staticmethod
    def utcWednesday():
        """
        Source · Wednesday-based weeks in local time (e.g., February 8, 2012 at 12:00 AM).

        See more informations `here <https://d3js.org/d3-time#timeWednesday>`_.
        """
        return d3("d3.utcWednesday()")

    @staticmethod
    def utcThursday():
        """
        Source · Thursday-based weeks in local time (e.g., February 9, 2012 at 12:00 AM).

        See more informations `here <https://d3js.org/d3-time#timeThursday>`_.
        """
        return d3("d3.utcThursday()")

    @staticmethod
    def utcFriday():
        """
        Source · Friday-based weeks in local time (e.g., February 10, 2012 at 12:00 AM).

        See more informations `here <https://d3js.org/d3-time#timeFriday>`_.
        """
        return d3("d3.utcFriday()")

    @staticmethod
    def utcSaturday():
        """
        Source · Saturday-based weeks in local time (e.g., February 11, 2012 at 12:00 AM).

        See more informations `here <https://d3js.org/d3-time#timeSaturday>`_.
        """
        return d3("d3.utcSaturday()")

    @staticmethod
    def utcMonth():
        """
        Source · Months in local time (e.g., February 1, 2012 at 12:00 AM); ranges from 28 to
        31 days.

        See more informations `here <https://d3js.org/d3-time#timeMonth>`_.
        """
        return d3("d3.utcMonth()")

    @staticmethod
    def utcYear():
        """
        Source · Years in local time (e.g., January 1, 2012 at 12:00 AM); ranges from 365 to
        366 days.

        See more informations `here <https://d3js.org/d3-time#timeYear>`_.
        """
        return d3("d3.utcYear()")

    @staticmethod
    def unixDay():
        """
        Source · Days in local time (e.g., February 7, 2012 at 12:00 AM); typically 24 hours.
        Days in local time may range from 23 to 25 hours due to daylight saving. d3.unixDay is
        like d3.utcDay, except it counts days since the UNIX epoch (January 1, 1970) such that
        interval.every returns uniformly-spaced dates rather than varying based on
        day-of-month.

        See more informations `here <https://d3js.org/d3-time#timeDay>`_.
        """
        return d3("d3.unixDay()")

    @staticmethod
    def timeMilliseconds(start=None, stop=None, step=None):
        """
        Alias for d3.timeMillisecond.range.

        See more informations `here <https://d3js.org/d3-time#timeMilliseconds>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (start, stop, step))))
        return d3(f"d3.timeMilliseconds({arguments})")

    @staticmethod
    def timeSeconds(start=None, stop=None, step=None):
        """
        Alias for d3.timeSecond.range.

        See more informations `here <https://d3js.org/d3-time#timeSeconds>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (start, stop, step))))
        return d3(f"d3.timeSeconds({arguments})")

    @staticmethod
    def timeMinutes(start=None, stop=None, step=None):
        """
        Alias for d3.timeMinute.range.

        See more informations `here <https://d3js.org/d3-time#timeMinutes>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (start, stop, step))))
        return d3(f"d3.timeMinutes({arguments})")

    @staticmethod
    def timeHours(start=None, stop=None, step=None):
        """
        Alias for d3.timeHour.range.

        See more informations `here <https://d3js.org/d3-time#timeHours>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (start, stop, step))))
        return d3(f"d3.timeHours({arguments})")

    @staticmethod
    def timeDays():
        """
        Source · Days in local time (e.g., February 7, 2012 at 12:00 AM); typically 24 hours.
        Days in local time may range from 23 to 25 hours due to daylight saving. d3.unixDay is
        like d3.utcDay, except it counts days since the UNIX epoch (January 1, 1970) such that
        interval.every returns uniformly-spaced dates rather than varying based on
        day-of-month.

        See more informations `here <https://d3js.org/d3-time#timeDay>`_.
        """
        return d3("d3.timeDays()")

    @staticmethod
    def timeWeeks():
        """
        Source · Alias for d3.timeSunday; 7 days and typically 168 hours. Weeks in local time
        may range from 167 to 169 hours due to daylight saving.

        See more informations `here <https://d3js.org/d3-time#timeWeek>`_.
        """
        return d3("d3.timeWeeks()")

    @staticmethod
    def timeSundays():
        """
        Source · Sunday-based weeks in local time (e.g., February 5, 2012 at 12:00 AM).

        See more informations `here <https://d3js.org/d3-time#timeSunday>`_.
        """
        return d3("d3.timeSundays()")

    @staticmethod
    def timeMondays():
        """
        Source · Monday-based weeks in local time (e.g., February 6, 2012 at 12:00 AM).

        See more informations `here <https://d3js.org/d3-time#timeMonday>`_.
        """
        return d3("d3.timeMondays()")

    @staticmethod
    def timeTuesdays():
        """
        Source · Tuesday-based weeks in local time (e.g., February 7, 2012 at 12:00 AM).

        See more informations `here <https://d3js.org/d3-time#timeTuesday>`_.
        """
        return d3("d3.timeTuesdays()")

    @staticmethod
    def timeWednesdays():
        """
        Source · Wednesday-based weeks in local time (e.g., February 8, 2012 at 12:00 AM).

        See more informations `here <https://d3js.org/d3-time#timeWednesday>`_.
        """
        return d3("d3.timeWednesdays()")

    @staticmethod
    def timeThursdays():
        """
        Source · Thursday-based weeks in local time (e.g., February 9, 2012 at 12:00 AM).

        See more informations `here <https://d3js.org/d3-time#timeThursday>`_.
        """
        return d3("d3.timeThursdays()")

    @staticmethod
    def timeFridays():
        """
        Source · Friday-based weeks in local time (e.g., February 10, 2012 at 12:00 AM).

        See more informations `here <https://d3js.org/d3-time#timeFriday>`_.
        """
        return d3("d3.timeFridays()")

    @staticmethod
    def timeSaturdays():
        """
        Source · Saturday-based weeks in local time (e.g., February 11, 2012 at 12:00 AM).

        See more informations `here <https://d3js.org/d3-time#timeSaturday>`_.
        """
        return d3("d3.timeSaturdays()")

    @staticmethod
    def timeMonths():
        """
        Source · Months in local time (e.g., February 1, 2012 at 12:00 AM); ranges from 28 to
        31 days.

        See more informations `here <https://d3js.org/d3-time#timeMonth>`_.
        """
        return d3("d3.timeMonths()")

    @staticmethod
    def timeYears():
        """
        Source · Years in local time (e.g., January 1, 2012 at 12:00 AM); ranges from 365 to
        366 days.

        See more informations `here <https://d3js.org/d3-time#timeYear>`_.
        """
        return d3("d3.timeYears()")

    @staticmethod
    def utcMilliseconds():
        """
        Source · Milliseconds in local time; the shortest available time unit.

        See more informations `here <https://d3js.org/d3-time#timeMillisecond>`_.
        """
        return d3("d3.utcMilliseconds()")

    @staticmethod
    def utcSeconds():
        """
        Source · Seconds in local time (e.g., 01:23:45.0000 AM); 1,000 milliseconds.

        See more informations `here <https://d3js.org/d3-time#timeSecond>`_.
        """
        return d3("d3.utcSeconds()")

    @staticmethod
    def utcMinutes():
        """
        Source · Minutes in local time (e.g., 01:02:00 AM); 60 seconds. Note that ECMAScript
        ignores leap seconds.

        See more informations `here <https://d3js.org/d3-time#timeMinute>`_.
        """
        return d3("d3.utcMinutes()")

    @staticmethod
    def utcHours():
        """
        Source · Hours in local time (e.g., 01:00 AM); 60 minutes. Note that advancing time by
        one hour in local time can return the same hour or skip an hour due to daylight saving.

        See more informations `here <https://d3js.org/d3-time#timeHour>`_.
        """
        return d3("d3.utcHours()")

    @staticmethod
    def utcDays():
        """
        Source · Days in local time (e.g., February 7, 2012 at 12:00 AM); typically 24 hours.
        Days in local time may range from 23 to 25 hours due to daylight saving. d3.unixDay is
        like d3.utcDay, except it counts days since the UNIX epoch (January 1, 1970) such that
        interval.every returns uniformly-spaced dates rather than varying based on
        day-of-month.

        See more informations `here <https://d3js.org/d3-time#timeDay>`_.
        """
        return d3("d3.utcDays()")

    @staticmethod
    def utcWeeks():
        """
        Source · Alias for d3.timeSunday; 7 days and typically 168 hours. Weeks in local time
        may range from 167 to 169 hours due to daylight saving.

        See more informations `here <https://d3js.org/d3-time#timeWeek>`_.
        """
        return d3("d3.utcWeeks()")

    @staticmethod
    def utcSundays():
        """
        Source · Sunday-based weeks in local time (e.g., February 5, 2012 at 12:00 AM).

        See more informations `here <https://d3js.org/d3-time#timeSunday>`_.
        """
        return d3("d3.utcSundays()")

    @staticmethod
    def utcMondays():
        """
        Source · Monday-based weeks in local time (e.g., February 6, 2012 at 12:00 AM).

        See more informations `here <https://d3js.org/d3-time#timeMonday>`_.
        """
        return d3("d3.utcMondays()")

    @staticmethod
    def utcTuesdays():
        """
        Source · Tuesday-based weeks in local time (e.g., February 7, 2012 at 12:00 AM).

        See more informations `here <https://d3js.org/d3-time#timeTuesday>`_.
        """
        return d3("d3.utcTuesdays()")

    @staticmethod
    def utcWednesdays():
        """
        Source · Wednesday-based weeks in local time (e.g., February 8, 2012 at 12:00 AM).

        See more informations `here <https://d3js.org/d3-time#timeWednesday>`_.
        """
        return d3("d3.utcWednesdays()")

    @staticmethod
    def utcThursdays():
        """
        Source · Thursday-based weeks in local time (e.g., February 9, 2012 at 12:00 AM).

        See more informations `here <https://d3js.org/d3-time#timeThursday>`_.
        """
        return d3("d3.utcThursdays()")

    @staticmethod
    def utcFridays():
        """
        Source · Friday-based weeks in local time (e.g., February 10, 2012 at 12:00 AM).

        See more informations `here <https://d3js.org/d3-time#timeFriday>`_.
        """
        return d3("d3.utcFridays()")

    @staticmethod
    def utcSaturdays():
        """
        Source · Saturday-based weeks in local time (e.g., February 11, 2012 at 12:00 AM).

        See more informations `here <https://d3js.org/d3-time#timeSaturday>`_.
        """
        return d3("d3.utcSaturdays()")

    @staticmethod
    def utcMonths():
        """
        Source · Months in local time (e.g., February 1, 2012 at 12:00 AM); ranges from 28 to
        31 days.

        See more informations `here <https://d3js.org/d3-time#timeMonth>`_.
        """
        return d3("d3.utcMonths()")

    @staticmethod
    def utcYears():
        """
        Source · Years in local time (e.g., January 1, 2012 at 12:00 AM); ranges from 365 to
        366 days.

        See more informations `here <https://d3js.org/d3-time#timeYear>`_.
        """
        return d3("d3.utcYears()")

    @staticmethod
    def unixDays():
        """
        Source · Days in local time (e.g., February 7, 2012 at 12:00 AM); typically 24 hours.
        Days in local time may range from 23 to 25 hours due to daylight saving. d3.unixDay is
        like d3.utcDay, except it counts days since the UNIX epoch (January 1, 1970) such that
        interval.every returns uniformly-spaced dates rather than varying based on
        day-of-month.

        See more informations `here <https://d3js.org/d3-time#timeDay>`_.
        """
        return d3("d3.unixDays()")

    @staticmethod
    def timeTicks(start=None, stop=None, count=None):
        """
        Source · Equivalent to d3.utcTicks, but in local time.

        See more informations `here <https://d3js.org/d3-time#timeTicks>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (start, stop, count))))
        return d3(f"d3.timeTicks({arguments})")

    @staticmethod
    def utcTicks(start=None, stop=None, count=None):
        """
        Source · Returns an array of approximately count dates at regular intervals between
        start and stop (inclusive). If stop is before start, dates are returned in reverse
        chronological order; otherwise dates are returned in chronological order. The following
        UTC time intervals are considered:
        Multiples of milliseconds (for small ranges) and years (for large ranges) are also
        considered, following the rules of d3.ticks. The interval producing the number of dates
        that is closest to count is used. For example:
        .. code:: javascript

            const start = new Date("1970-03-01");
            const stop = new Date("1996-03-19");
            const count = 4;
            const ticks = d3.utcTicks(start, stop, count); // [1975-01-01, 1980-01-01, 1985-01-01, 1990-01-01, 1995-01-01]

        If count is a time interval, this function behaves similarly to interval.range except
        that both start and stop are inclusive and it may return dates in reverse chronological
        order if stop is before start.

        See more informations `here <https://d3js.org/d3-time#utcTicks>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (start, stop, count))))
        return d3(f"d3.utcTicks({arguments})")

    @staticmethod
    def timeTickInterval(start=None, stop=None, count=None):
        """
        Source · Returns the time interval that would be used by d3.timeTicks given the same
        arguments.

        See more informations `here <https://d3js.org/d3-time#timeTickInterval>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (start, stop, count))))
        return d3(f"d3.timeTickInterval({arguments})")

    @staticmethod
    def utcTickInterval(start=None, stop=None, count=None):
        """
        Source · Returns the time interval that would be used by d3.utcTicks given the same
        arguments. If there is no associated interval, such as when start or stop is invalid,
        returns null.
        .. code:: javascript

            const start = new Date("1970-03-01");
            const stop = new Date("1996-03-19");
            const count = 4;
            const interval = d3.utcTickInterval(start, stop, count); // d3.utcYear.every(5)


        See more informations `here <https://d3js.org/d3-time#utcTickInterval>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (start, stop, count))))
        return d3(f"d3.utcTickInterval({arguments})")

    @staticmethod
    def timeFormat(specifier=None):
        """
        .. code:: javascript

            d3.timeFormat("%b %d")

        An alias for locale.format on the default locale.

        See more informations `here <https://d3js.org/d3-time-format#timeFormat>`_.
        .. code:: javascript

            d3.timeFormat("%b %d")

        Source · Returns a new formatter for the given string specifier. The specifier string
        may contain the following directives:
        Directives marked with an asterisk (*) may be affected by the locale definition.
        For %U, all days in a new year preceding the first Sunday are considered to be in week
        0. For %W, all days in a new year preceding the first Monday are considered to be in
        week 0. Week numbers are computed using interval.count. For example, 2015-52 and
        2016-00 represent Monday, December 28, 2015, while 2015-53 and 2016-01 represent
        Monday, January 4, 2016. This differs from the ISO week date specification (%V), which
        uses a more complicated definition!
        For %V,%g and %G, per the strftime man page:
        The % sign indicating a directive may be immediately followed by a padding modifier:
        If no padding modifier is specified, the default is 0 for all directives except %e,
        which defaults to _. (In some implementations of strftime and strptime, a directive may
        include an optional field width or precision; this feature is not yet implemented.)
        The returned function formats a specified date, returning the corresponding string.
        .. code:: javascript

            const formatMonth = d3.timeFormat("%B"),
                formatDay = d3.timeFormat("%A"),
                date = new Date(2014, 4, 1); // Thu May 01 2014 00:00:00 GMT-0700 (PDT)

            formatMonth(date); // "May"
            formatDay(date); // "Thursday"


        See more informations `here <https://d3js.org/d3-time-format#locale_format>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (specifier,))))
        return d3(f"d3.timeFormat({arguments})")

    @staticmethod
    def timeParse(specifier=None):
        """
        .. code:: javascript

            d3.timeParse("%b %d")

        An alias for locale.parse on the default locale.

        See more informations `here <https://d3js.org/d3-time-format#timeParse>`_.
        .. code:: javascript

            d3.timeParse("%b %d")

        Source · Returns a new parser for the given string specifier. The specifier string may
        contain the same directives as locale.format. The %d and %e directives are considered
        equivalent for parsing.
        The returned function parses a specified string, returning the corresponding date or
        null if the string could not be parsed according to this format’s specifier. Parsing is
        strict: if the specified string does not exactly match the associated specifier, this
        method returns null. For example, if the associated specifier is %Y-%m-%dT%H:%M:%SZ,
        then the string "2011-07-01T19:15:28Z" will be parsed as expected, but
        "2011-07-01T19:15:28", "2011-07-01 19:15:28" and "2011-07-01" will return null. (Note
        that the literal Z here is different from the time zone offset directive %Z.) If a more
        flexible parser is desired, try multiple formats sequentially until one returns
        non-null.

        See more informations `here <https://d3js.org/d3-time-format#locale_parse>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (specifier,))))
        return d3(f"d3.timeParse({arguments})")

    @staticmethod
    def utcFormat(specifier=None):
        """
        .. code:: javascript

            d3.utcFormat("%b %d")

        An alias for locale.utcFormat on the default locale.

        See more informations `here <https://d3js.org/d3-time-format#utcFormat>`_.
        .. code:: javascript

            d3.utcFormat("%b %d")

        Source · Equivalent to locale.format, except all directives are interpreted as
        Coordinated Universal Time (UTC) rather than local time.

        See more informations `here <https://d3js.org/d3-time-format#locale_utcFormat>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (specifier,))))
        return d3(f"d3.utcFormat({arguments})")

    @staticmethod
    def utcParse(specifier=None):
        """
        .. code:: javascript

            d3.utcParse("%b %d")

        An alias for locale.utcParse on the default locale.

        See more informations `here <https://d3js.org/d3-time-format#utcParse>`_.
        .. code:: javascript

            d3.utcParse("%b %d")

        Source · Equivalent to locale.parse, except all directives are interpreted as
        Coordinated Universal Time (UTC) rather than local time.

        See more informations `here <https://d3js.org/d3-time-format#locale_utcParse>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (specifier,))))
        return d3(f"d3.utcParse({arguments})")

    @staticmethod
    def isoFormat():
        """
        .. code:: javascript

            d3.isoFormat(new Date()) // "2023-05-31T18:17:36.788Z"

        Source · The full ISO 8601 UTC time formatter. Where available, this method will use
        Date.toISOString to format.

        See more informations `here <https://d3js.org/d3-time-format#isoFormat>`_.
        """
        return d3("d3.isoFormat()")

    @staticmethod
    def isoParse():
        """
        .. code:: javascript

            d3.isoParse("2023-05-31T18:17:36.788Z")

        Source · The full ISO 8601 UTC time parser. Where available, this method will use the
        Date constructor to parse strings. If you depend on strict validation of the input
        format according to ISO 8601, you should construct a UTC parser function:
        .. code:: javascript

            const strictIsoParse = d3.utcParse("%Y-%m-%dT%H:%M:%S.%LZ");


        See more informations `here <https://d3js.org/d3-time-format#isoParse>`_.
        """
        return d3("d3.isoParse()")

    @staticmethod
    def timeFormatLocale(definition=None):
        """
        .. code:: javascript

            const enUs = d3.timeFormatLocale({
              dateTime: "%x, %X",
              date: "%-m/%-d/%Y",
              time: "%-I:%M:%S %p",
              periods: ["AM", "PM"],
              days: ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"],
              shortDays: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"],
              months: ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"],
              shortMonths: ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]
            });

        Source · Returns a locale object for the specified definition with locale.format,
        locale.parse, locale.utcFormat, locale.utcParse methods. The definition must include
        the following properties:

        See more informations `here <https://d3js.org/d3-time-format#timeFormatLocale>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (definition,))))
        return d3(f"d3.timeFormatLocale({arguments})")

    @staticmethod
    def timeFormatDefaultLocale(definition=None):
        """
        .. code:: javascript

            const enUs = d3.timeFormatDefaultLocale({
              dateTime: "%x, %X",
              date: "%-m/%-d/%Y",
              time: "%-I:%M:%S %p",
              periods: ["AM", "PM"],
              days: ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"],
              shortDays: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"],
              months: ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"],
              shortMonths: ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]
            });

        Source · Equivalent to d3.timeFormatLocale, except it also redefines d3.timeFormat,
        d3.timeParse, d3.utcFormat and d3.utcParse to the new locale’s locale.format,
        locale.parse, locale.utcFormat and locale.utcParse. If you do not set a default locale,
        it defaults to U.S. English.

        See more informations `here <https://d3js.org/d3-time-format#timeFormatDefaultLocale>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (definition,))))
        return d3(f"d3.timeFormatDefaultLocale({arguments})")

    @staticmethod
    def now():
        """
        Source · Returns the current time as defined by performance.now if available, and
        Date.now if not.
        .. code:: javascript

            d3.now() // 1236.3000000715256

        The current time is updated at the start of a frame; it is thus consistent during the
        frame, and any timers scheduled during the same frame will be synchronized. If this
        method is called outside of a frame, such as in response to a user event, the current
        time is calculated and then fixed until the next frame, again ensuring consistent
        timing during event handling.

        See more informations `here <https://d3js.org/d3-timer#now>`_.
        """
        return d3("d3.now()")

    @staticmethod
    def timerFlush():
        """
        Source · Immediately invoke any eligible timer callbacks. Note that zero-delay timers
        are normally first executed after one frame (~17ms). This can cause a brief flicker
        because the browser renders the page twice: once at the end of the first event loop,
        then again immediately on the first timer callback. By flushing the timer queue at the
        end of the first event loop, you can run any zero-delay timers immediately and avoid
        the flicker.

        See more informations `here <https://d3js.org/d3-timer#timerFlush>`_.
        """
        return d3("d3.timerFlush()")

    @staticmethod
    def timeout(callback=None, delay=None, time=None):
        """
        Source · Like timer, except the timer automatically stops on its first callback. A
        suitable replacement for setTimeout that is guaranteed to not run in the background.
        The callback is passed the elapsed time.

        See more informations `here <https://d3js.org/d3-timer#timeout>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (callback, delay, time))))
        return d3(f"d3.timeout({arguments})")

    @staticmethod
    def interval(callback=None, delay=None, time=None):
        """
        Source · Like timer, except the callback is invoked only every delay milliseconds; if
        delay is not specified, this is equivalent to timer. A suitable replacement for
        setInterval that is guaranteed to not run in the background. The callback is passed the
        elapsed time.

        See more informations `here <https://d3js.org/d3-timer#interval>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (callback, delay, time))))
        return d3(f"d3.interval({arguments})")

    @staticmethod
    def interrupt(node=None, name=None):
        """
        Source · Interrupts the active transition of the specified name on the specified node,
        and cancels any pending transitions with the specified name, if any. If a name is not
        specified, null is used. See also selection.interrupt.

        See more informations `here <https://d3js.org/d3-transition/control-flow#interrupt>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (node, name))))
        return d3(f"d3.interrupt({arguments})")

    @staticmethod
    def active(node=None, name=None):
        """
        Examples · Source · Returns the active transition on the specified node with the
        specified name, if any. If no name is specified, null is used. Returns null if there is
        no such active transition on the specified node. This method is useful for creating
        chained transitions. For example, to initiate disco mode:
        .. code:: javascript

            d3.selectAll("circle").transition()
                .delay((d, i) => i * 50)
                .on("start", function repeat() {
                    d3.active(this)
                        .style("fill", "red")
                      .transition()
                        .style("fill", "green")
                      .transition()
                        .style("fill", "blue")
                      .transition()
                        .on("start", repeat);
                  });


        See more informations `here <https://d3js.org/d3-transition/selecting#active>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (node, name))))
        return d3(f"d3.active({arguments})")

    @staticmethod
    def zoomIdentity():
        """
        Source · The identity transform, where k = 1, tx = ty = 0.

        See more informations `here <https://d3js.org/d3-zoom#zoomIdentity>`_.
        """
        return d3("d3.zoomIdentity()")


    @staticmethod
    def Adder():
        """
        .. code:: javascript

            const adder = new d3.Adder();

        Examples · Source · Creates a new adder with an initial value of 0.

        See more informations `here <https://d3js.org/d3-array/add#Adder>`_.
        """
        return Adder("new d3.Adder()")

    @staticmethod
    def bin(data=None):
        """
        .. code:: javascript

            const bin = d3.bin().value((d) => d.culmen_length_mm);

        Examples · Source · Constructs a new bin generator with the default settings. The
        returned bin generator supports method chaining, so this constructor is typically
        chained with bin.value to assign a value accessor. The returned generator is also a
        function; pass it data to bin.

        See more informations `here <https://d3js.org/d3-array/bin#bin>`_.
        .. code:: javascript

            const bins = d3.bin().value((d) => d.culmen_length_mm)(penguins);

        Bins the given iterable of data samples. Returns an array of bins, where each bin is an
        array containing the associated elements from the input data. Thus, the length of the
        bin is the number of elements in that bin. Each bin has two additional attributes:
        Any null or non-comparable values in the given data, or those outside the domain, are
        ignored.

        See more informations `here <https://d3js.org/d3-array/bin#_bin>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (data,))))
        return _bin(f"d3.bin({arguments})")

    @staticmethod
    def bisector(array=None, x=None, lo=None, hi=None):
        """
        Examples · Source · Returns a new bisector using the specified accessor function.
        .. code:: javascript

            const bisector = d3.bisector((d) => d.Date);

        If the given accessor takes two arguments, it is interpreted as a comparator function
        for comparing an element d in the data with a search value x. Use a comparator rather
        than an accessor if you want values to be sorted in an order different than natural
        order, such as in descending rather than ascending order. The above is equivalent to:
        .. code:: javascript

            const bisector = d3.bisector((d, x) => d.Date - x);

        The bisector can be used to bisect sorted arrays of objects (in contrast to bisect,
        which is for bisecting primitives).

        See more informations `here <https://d3js.org/d3-array/bisect#bisector>`_.
        .. code:: javascript

            d3.bisect(aapl.map((d) => d.Date), new Date("2014-01-02")) // 163

        Alias for bisectRight.

        See more informations `here <https://d3js.org/d3-array/bisect#bisect>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (array, x, lo, hi))))
        return bisector(f"d3.bisector({arguments})")

    @staticmethod
    def axisTop(context=None):
        """
        Source · Constructs a new top-oriented axis generator for the given scale, with empty
        tick arguments, a tick size of 6 and padding of 3. In this orientation, ticks are drawn
        above the horizontal domain path.

        See more informations `here <https://d3js.org/d3-axis#axisTop>`_.
        Source · Render the axis to the given context, which may be either a selection of SVG
        containers (either SVG or G elements) or a corresponding transition.
        .. code:: javascript

            svg.append("g")
                .attr("transform", `translate(0,${height - marginBottom})`)
                .call(d3.axisBottom(x));


        See more informations `here <https://d3js.org/d3-axis#_axis>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (context,))))
        return axisTop(f"d3.axisTop({arguments})")

    @staticmethod
    def axisRight(scale=None):
        """
        Source · Constructs a new right-oriented axis generator for the given scale, with empty
        tick arguments, a tick size of 6 and padding of 3. In this orientation, ticks are drawn
        to the right of the vertical domain path.

        See more informations `here <https://d3js.org/d3-axis#axisRight>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (scale,))))
        return axisRight(f"d3.axisRight({arguments})")

    @staticmethod
    def axisBottom(scale=None):
        """
        Source · Constructs a new bottom-oriented axis generator for the given scale, with
        empty tick arguments, a tick size of 6 and padding of 3. In this orientation, ticks are
        drawn below the horizontal domain path.

        See more informations `here <https://d3js.org/d3-axis#axisBottom>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (scale,))))
        return axisBottom(f"d3.axisBottom({arguments})")

    @staticmethod
    def axisLeft(scale=None):
        """
        Source · Constructs a new left-oriented axis generator for the given scale, with empty
        tick arguments, a tick size of 6 and padding of 3. In this orientation, ticks are drawn
        to the left of the vertical domain path.

        See more informations `here <https://d3js.org/d3-axis#axisLeft>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (scale,))))
        return axisLeft(f"d3.axisLeft({arguments})")

    @staticmethod
    def brush(group=None):
        """
        Examples · Source · Creates a new two-dimensional brush.

        See more informations `here <https://d3js.org/d3-brush#brush>`_.
        Examples · Source · Applies the brush to the specified group, which must be a selection
        of SVG G elements. This function is typically not invoked directly, and is instead
        invoked via selection.call. For example, to render a brush:
        .. code:: javascript

            svg.append("g")
                .attr("class", "brush")
                .call(d3.brush().on("brush", brushed));

        Internally, the brush uses selection.on to bind the necessary event listeners for
        dragging. The listeners use the name .brush, so you can subsequently unbind the brush
        event listeners as follows:
        .. code:: javascript

            group.on(".brush", null);

        The brush also creates the SVG elements necessary to display the brush selection and to
        receive input events for interaction. You can add, remove or modify these elements as
        desired to change the brush appearance; you can also apply stylesheets to modify the
        brush appearance. The structure of a two-dimensional brush is as follows:
        .. code:: javascript

            <g class="brush" fill="none" pointer-events="all" style="-webkit-tap-highlight-color: rgba(0, 0, 0, 0);">
              <rect class="overlay" pointer-events="all" cursor="crosshair" x="0" y="0" width="960" height="500"></rect>
              <rect class="selection" cursor="move" fill="#777" fill-opacity="0.3" stroke="#fff" shape-rendering="crispEdges" x="112" y="194" width="182" height="83"></rect>
              <rect class="handle handle--n" cursor="ns-resize" x="107" y="189" width="192" height="10"></rect>
              <rect class="handle handle--e" cursor="ew-resize" x="289" y="189" width="10" height="93"></rect>
              <rect class="handle handle--s" cursor="ns-resize" x="107" y="272" width="192" height="10"></rect>
              <rect class="handle handle--w" cursor="ew-resize" x="107" y="189" width="10" height="93"></rect>
              <rect class="handle handle--nw" cursor="nwse-resize" x="107" y="189" width="10" height="10"></rect>
              <rect class="handle handle--ne" cursor="nesw-resize" x="289" y="189" width="10" height="10"></rect>
              <rect class="handle handle--se" cursor="nwse-resize" x="289" y="272" width="10" height="10"></rect>
              <rect class="handle handle--sw" cursor="nesw-resize" x="107" y="272" width="10" height="10"></rect>
            </g>

        The overlay rect covers the brushable area defined by brush.extent. The selection rect
        covers the area defined by the current brush selection. The handle rects cover the
        edges and corners of the brush selection, allowing the corresponding value in the brush
        selection to be modified interactively. To modify the brush selection programmatically,
        use brush.move.

        See more informations `here <https://d3js.org/d3-brush#_brush>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (group,))))
        return brush(f"d3.brush({arguments})")

    @staticmethod
    def brushX():
        """
        Examples · Source · Creates a new one-dimensional brush along the x-dimension.

        See more informations `here <https://d3js.org/d3-brush#brushX>`_.
        """
        return brushX("d3.brushX()")

    @staticmethod
    def brushY():
        """
        Source · Creates a new one-dimensional brush along the y-dimension.

        See more informations `here <https://d3js.org/d3-brush#brushY>`_.
        """
        return brushY("d3.brushY()")

    @staticmethod
    def chord(matrix=None):
        """
        Source · Constructs a new chord layout with the default settings.
        .. code:: javascript

            const chord = d3.chord();


        See more informations `here <https://d3js.org/d3-chord/chord#chord>`_.
        Source · Computes the chord layout for the specified square matrix of size n×n, where
        the matrix represents the directed flow amongst a network (a complete digraph) of n
        nodes.
        The return value of chord(matrix) is an array of chords, where each chord represents
        the combined bidirectional flow between two nodes i and j (where i may be equal to j)
        and is an object with the following properties:
        Each source and target subgroup is also an object with the following properties:
        The chords are typically passed to ribbon to display the network relationships.
        The returned array includes only chord objects for which the value matrix[i][j] or
        matrix[j][i] is non-zero. Furthermore, the returned array only contains unique chords:
        a given chord ij represents the bidirectional flow from i to j and from j to i, and
        does not contain a duplicate chord ji; i and j are chosen such that the chord’s source
        always represents the larger of matrix[i][j] and matrix[j][i].
        The chords array also defines a secondary array of length n, chords.groups, where each
        group represents the combined outflow for node i, corresponding to the elements
        matrix[i][0 … n - 1], and is an object with the following properties:
        The groups are typically passed to arc to produce a donut chart around the
        circumference of the chord layout.

        See more informations `here <https://d3js.org/d3-chord/chord#_chord>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (matrix,))))
        return chord(f"d3.chord({arguments})")

    @staticmethod
    def ribbon(*arguments):
        """
        Source · Creates a new ribbon generator with the default settings.
        .. code:: javascript

            const ribbon = d3.ribbon();


        See more informations `here <https://d3js.org/d3-chord/ribbon#ribbon>`_.
        Source · Generates a ribbon for the given arguments. The arguments are arbitrary; they
        are propagated to the ribbon generator’s accessor functions along with the this object.
        For example, with the default settings, a chord object is expected:
        .. code:: javascript

            ribbon({
              source: {startAngle: 0.7524114, endAngle: 1.1212972, radius: 240},
              target: {startAngle: 1.8617078, endAngle: 1.9842927, radius: 240}
            }) // "M164.0162810494058,-175.21032946354026A240,240,0,0,1,216.1595644740915,-104.28347273835429Q0,0,229.9158815306728,68.8381247563705A240,240,0,0,1,219.77316791012538,96.43523560788266Q0,0,164.0162810494058,-175.21032946354026Z"

        If the ribbon generator has a context, then the ribbon is rendered to this context as a
        sequence of path method calls and this function returns void. Otherwise, a path data
        string is returned.

        See more informations `here <https://d3js.org/d3-chord/ribbon#_ribbon>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (*arguments,))))
        return ribbon(f"d3.ribbon({arguments})")

    @staticmethod
    def ribbonArrow():
        """
        Source · Creates a new arrow ribbon generator with the default settings. See also
        chordDirected.

        See more informations `here <https://d3js.org/d3-chord/ribbon#ribbonArrow>`_.
        """
        return ribbonArrow("d3.ribbonArrow()")

    @staticmethod
    def color(specifier=None):
        """
        .. code:: javascript

            d3.color("steelblue") // {r: 70, g: 130, b: 180, opacity: 1}

        Source · Parses the specified CSS Color Module Level 3 specifier string, returning an
        RGB or HSL color, along with CSS Color Module Level 4 hex specifier strings. If the
        specifier was not valid, null is returned. Some examples:
        The list of supported named colors is specified by CSS.
        Note: this function may also be used with instanceof to test if an object is a color
        instance. The same is true of color subclasses, allowing you to test whether a color is
        in a particular color space.

        See more informations `here <https://d3js.org/d3-color#color>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (specifier,))))
        return color(f"d3.color({arguments})")

    @staticmethod
    def rgb(color=None):
        """
        .. code:: javascript

            d3.rgb("hsl(60, 100%, 50%)") // {r: 255, g: 255, b: 0, opacity: 1}

        Source · Constructs a new RGB color. The channel values are exposed as r, g and b
        properties on the returned instance. Use the RGB color picker to explore this color
        space.
        If r, g and b are specified, these represent the channel values of the returned color;
        an opacity may also be specified. If a CSS Color Module Level 3 specifier string is
        specified, it is parsed and then converted to the RGB color space. See color for
        examples. If a color instance is specified, it is converted to the RGB color space
        using color.rgb. Note that unlike color.rgb this method always returns a new instance,
        even if color is already an RGB color.

        See more informations `here <https://d3js.org/d3-color#rgb>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (color,))))
        return rgb(f"d3.rgb({arguments})")

    @staticmethod
    def hsl(color=None):
        """
        .. code:: javascript

            d3.hsl("yellow") // {h: 60, s: 1, l: 0.5, opacity: 1}

        Source · Constructs a new HSL color. The channel values are exposed as h, s and l
        properties on the returned instance. Use the HSL color picker to explore this color
        space.
        If h, s and l are specified, these represent the channel values of the returned color;
        an opacity may also be specified. If a CSS Color Module Level 3 specifier string is
        specified, it is parsed and then converted to the HSL color space. See color for
        examples. If a color instance is specified, it is converted to the RGB color space
        using color.rgb and then converted to HSL. (Colors already in the HSL color space skip
        the conversion to RGB.)

        See more informations `here <https://d3js.org/d3-color#hsl>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (color,))))
        return hsl(f"d3.hsl({arguments})")

    @staticmethod
    def contours(values=None):
        """
        Examples · Source · Constructs a new contour generator with the default settings.
        .. code:: javascript

            const contours = d3.contours()
                .size([width, height])
                .thresholds([0, 1, 2, 3, 4]);


        See more informations `here <https://d3js.org/d3-contour/contour#contours>`_.
        Source · Computes the contours for the given array of values, returning an array of
        GeoJSON MultiPolygon geometry objects.
        .. code:: javascript

            const polygons = contours(grid);

        Each geometry object represents the area where the input values are greater than or
        equal to the corresponding threshold value; the threshold value for each geometry
        object is exposed as geometry.value.
        The input values must be an array of length n×m where [n, m] is the contour generator’s
        size; furthermore, each values[i + jn] must represent the value at the position ⟨i, j⟩.
        For example, to construct a 256×256 grid for the Goldstein–Price function where -2 ≤ x
        ≤ 2 and -2 ≤ y ≤ 1:
        .. code:: javascript

            var n = 256, m = 256, values = new Array(n * m);
            for (var j = 0.5, k = 0; j < m; ++j) {
              for (var i = 0.5; i < n; ++i, ++k) {
                values[k] = goldsteinPrice(i / n * 4 - 2, 1 - j / m * 3);
              }
            }

        .. code:: javascript

            function goldsteinPrice(x, y) {
              return (1 + Math.pow(x + y + 1, 2) * (19 - 14 * x + 3 * x * x - 14 * y + 6 * x * x + 3 * y * y))
                  * (30 + Math.pow(2 * x - 3 * y, 2) * (18 - 32 * x + 12 * x * x + 48 * y - 36 * x * y + 27 * y * y));
            }

        The returned geometry objects are typically passed to geoPath to display, using null or
        geoIdentity as the associated projection.

        See more informations `here <https://d3js.org/d3-contour/contour#_contours>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (values,))))
        return contours(f"d3.contours({arguments})")

    @staticmethod
    def contourDensity(data=None):
        """
        Examples · Source · Constructs a new density estimator with the default settings.

        See more informations `here <https://d3js.org/d3-contour/density#contourDensity>`_.
        Source · Estimates the density contours for the given array of data, returning an array
        of GeoJSON MultiPolygon geometry objects.
        Each geometry object represents the area where the estimated number of points per
        square pixel is greater than or equal to the corresponding threshold value; the
        threshold value for each geometry object is exposed as geometry.value. The returned
        geometry objects are typically passed to geoPath to display, using null or geoIdentity
        as the associated projection. See also contours.
        The x and y coordinate for each data point are computed using density.x and density.y.
        In addition, density.weight indicates the relative contribution of each data point
        (default 1). The generated contours are only accurate within the estimator’s defined
        size.

        See more informations `here <https://d3js.org/d3-contour/density#_density>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (data,))))
        return contourDensity(f"d3.contourDensity({arguments})")

    @staticmethod
    def Delaunay(points=None):
        """
        Source · Returns the Delaunay triangulation for the given flat array [x0, y0, x1, y1,
        …] of points.
        .. code:: javascript

            const delaunay = new d3.Delaunay(Float64Array.of(0, 0, 0, 1, 1, 0, 1, 1));

        The given points may be any array-like type, but is typically a Float64Array.
        The coordinates of the points as an array [x0, y0, x1, y1, …].
        The halfedge indexes as an Int32Array [j0, j1, …]. For each index 0 ≤ i <
        halfedges.length, there is a halfedge from triangle vertex j = halfedges[i] to triangle
        vertex i. Equivalently, this means that triangle ⌊i / 3⌋ is adjacent to triangle ⌊j /
        3⌋. If j is negative, then triangle ⌊i / 3⌋ is an exterior triangle on the convex hull.
        For example, to render the internal edges of the Delaunay triangulation:
        .. code:: javascript

            const {points, halfedges, triangles} = delaunay;
            for (let i = 0, n = halfedges.length; i < n; ++i) {
              const j = halfedges[i];
              if (j < i) continue;
              const ti = triangles[i];
              const tj = triangles[j];
              context.moveTo(points[ti * 2], points[ti * 2 + 1]);
              context.lineTo(points[tj * 2], points[tj * 2 + 1]);
            }

        See also delaunay.render.
        An Int32Array of point indexes that form the convex hull in counterclockwise order. If
        the points are collinear, returns them ordered.
        See also delaunay.renderHull.
        The triangle vertex indexes as an Uint32Array [i0, j0, k0, i1, j1, k1, …]. Each
        contiguous triplet of indexes i, j, k forms a counterclockwise triangle. The
        coordinates of the triangle’s points can be found by going through delaunay.points. For
        example, to render triangle i:
        .. code:: javascript

            const {points, triangles} = delaunay;
            const t0 = triangles[i * 3 + 0];
            const t1 = triangles[i * 3 + 1];
            const t2 = triangles[i * 3 + 2];
            context.moveTo(points[t0 * 2], points[t0 * 2 + 1]);
            context.lineTo(points[t1 * 2], points[t1 * 2 + 1]);
            context.lineTo(points[t2 * 2], points[t2 * 2 + 1]);
            context.closePath();

        See also delaunay.renderTriangle.
        The incoming halfedge indexes as a Int32Array [e0, e1, e2, …]. For each point i,
        inedges[i] is the halfedge index e of an incoming halfedge. For coincident points, the
        halfedge index is -1; for points on the convex hull, the incoming halfedge is on the
        convex hull; for other points, the choice of incoming halfedge is arbitrary. The
        inedges table can be used to traverse the Delaunay triangulation; see also
        delaunay.neighbors.

        See more informations `here <https://d3js.org/d3-delaunay/delaunay#Delaunay>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (points,))))
        return Delaunay(f"new d3.Delaunay({arguments})")

    @staticmethod
    def voronoi():
        """
        See more informations `here <https://d3js.org/d3-delaunay/voronoi#voronoi_delaunay>`_.
        """
        return voronoi("d3.voronoi()")

    @staticmethod
    def dispatch(*types):
        """
        Source · Creates a new dispatch for the specified event types. Each type is a string,
        such as "start" or "end".

        See more informations `here <https://d3js.org/d3-dispatch#dispatch>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (*types,))))
        return dispatch(f"d3.dispatch({arguments})")

    @staticmethod
    def drag(selection=None):
        """
        Source · Creates a new drag behavior. The returned behavior, drag, is both an object
        and a function, and is typically applied to selected elements via selection.call.
        .. code:: javascript

            const drag = d3.drag();


        See more informations `here <https://d3js.org/d3-drag#drag>`_.
        Source · Applies this drag behavior to the specified selection. This function is
        typically not invoked directly, and is instead invoked via selection.call. For example,
        to instantiate a drag behavior and apply it to a selection:
        .. code:: javascript

            d3.selectAll(".node").call(d3.drag().on("start", started));

        Internally, the drag behavior uses selection.on to bind the necessary event listeners
        for dragging. The listeners use the name .drag, so you can subsequently unbind the drag
        behavior as follows:
        .. code:: javascript

            selection.on(".drag", null);

        Applying the drag behavior also sets the -webkit-tap-highlight-color style to
        transparent, disabling the tap highlight on iOS. If you want a different tap highlight
        color, remove or re-apply this style after applying the drag behavior.

        See more informations `here <https://d3js.org/d3-drag#_drag>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (selection,))))
        return drag(f"d3.drag({arguments})")

    @staticmethod
    def event():
        """
        See more informations `here <https://d3js.org/d3-drag#event_on>`_.
        """
        return event("d3.event()")

    @staticmethod
    def dsvFormat(delimiter=None):
        """
        .. code:: javascript

            const csv = d3.dsvFormat(",");

        Source · Constructs a new DSV parser and formatter for the specified delimiter. The
        delimiter must be a single character (i.e., a single 16-bit code unit); so, ASCII
        delimiters are fine, but emoji delimiters are not.

        See more informations `here <https://d3js.org/d3-dsv#dsvFormat>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (delimiter,))))
        return dsvFormat(f"d3.dsvFormat({arguments})")

    @staticmethod
    def easePolyIn():
        """
        Polynomial easing; raises t to the specified exponent. If the exponent is not
        specified, it defaults to 3, equivalent to easeCubicIn.
        Reverse polynomial easing; equivalent to 1 - easePolyIn(1 - t). If the exponent is not
        specified, it defaults to 3, equivalent to easeCubicOut.
        Symmetric polynomial easing; scales easePolyIn for t in 0–0.5 and easePolyOut for t in
        0.5–1. If the exponent is not specified, it defaults to 3, equivalent to easeCubic.
        Exponent:2.00
        Returns a new polynomial easing with the specified exponent e. For example, to create
        equivalents of easeLinear, easeQuad, and easeCubic:
        .. code:: javascript

            const linear = d3.easePoly.exponent(1);
            const quad = d3.easePoly.exponent(2);
            const cubic = d3.easePoly.exponent(3);


        See more informations `here <https://d3js.org/d3-ease#easePolyIn>`_.
        """
        return easePolyIn("d3.easePolyIn()")

    @staticmethod
    def easePolyOut():
        """
        Reverse polynomial easing; equivalent to 1 - easePolyIn(1 - t). If the exponent is not
        specified, it defaults to 3, equivalent to easeCubicOut.
        Symmetric polynomial easing; scales easePolyIn for t in 0–0.5 and easePolyOut for t in
        0.5–1. If the exponent is not specified, it defaults to 3, equivalent to easeCubic.
        Exponent:2.00
        Returns a new polynomial easing with the specified exponent e. For example, to create
        equivalents of easeLinear, easeQuad, and easeCubic:
        .. code:: javascript

            const linear = d3.easePoly.exponent(1);
            const quad = d3.easePoly.exponent(2);
            const cubic = d3.easePoly.exponent(3);


        See more informations `here <https://d3js.org/d3-ease#easePolyOut>`_.
        """
        return easePolyOut("d3.easePolyOut()")

    @staticmethod
    def easePoly():
        """
        Source · Alias for easePolyInOut.
        Polynomial easing; raises t to the specified exponent. If the exponent is not
        specified, it defaults to 3, equivalent to easeCubicIn.
        Reverse polynomial easing; equivalent to 1 - easePolyIn(1 - t). If the exponent is not
        specified, it defaults to 3, equivalent to easeCubicOut.
        Symmetric polynomial easing; scales easePolyIn for t in 0–0.5 and easePolyOut for t in
        0.5–1. If the exponent is not specified, it defaults to 3, equivalent to easeCubic.
        Exponent:2.00
        Returns a new polynomial easing with the specified exponent e. For example, to create
        equivalents of easeLinear, easeQuad, and easeCubic:
        .. code:: javascript

            const linear = d3.easePoly.exponent(1);
            const quad = d3.easePoly.exponent(2);
            const cubic = d3.easePoly.exponent(3);


        See more informations `here <https://d3js.org/d3-ease#easePoly>`_.
        """
        return easePoly("d3.easePoly()")

    @staticmethod
    def easePolyInOut():
        """
        Symmetric polynomial easing; scales easePolyIn for t in 0–0.5 and easePolyOut for t in
        0.5–1. If the exponent is not specified, it defaults to 3, equivalent to easeCubic.
        Exponent:2.00
        Returns a new polynomial easing with the specified exponent e. For example, to create
        equivalents of easeLinear, easeQuad, and easeCubic:
        .. code:: javascript

            const linear = d3.easePoly.exponent(1);
            const quad = d3.easePoly.exponent(2);
            const cubic = d3.easePoly.exponent(3);


        See more informations `here <https://d3js.org/d3-ease#easePolyInOut>`_.
        """
        return easePolyInOut("d3.easePolyInOut()")

    @staticmethod
    def easeElasticIn():
        """
        Elastic easing, like a rubber band. The amplitude and period of the oscillation are
        configurable; if not specified, they default to 1 and 0.3, respectively.
        Reverse elastic easing; equivalent to 1 - elasticIn(1 - t).
        Symmetric elastic easing; scales elasticIn for t in 0–0.5 and elasticOut for t in
        0.5–1.
        Amplitude:1.00
        Returns a new elastic easing with the specified amplitude a. The amplitude a must be
        greater than or equal to 1.
        Period:0.30
        Returns a new elastic easing with the specified period p.

        See more informations `here <https://d3js.org/d3-ease#easeElasticIn>`_.
        """
        return easeElasticIn("d3.easeElasticIn()")

    @staticmethod
    def easeElastic():
        """
        Source · Alias for easeElasticOut.
        Elastic easing, like a rubber band. The amplitude and period of the oscillation are
        configurable; if not specified, they default to 1 and 0.3, respectively.
        Reverse elastic easing; equivalent to 1 - elasticIn(1 - t).
        Symmetric elastic easing; scales elasticIn for t in 0–0.5 and elasticOut for t in
        0.5–1.
        Amplitude:1.00
        Returns a new elastic easing with the specified amplitude a. The amplitude a must be
        greater than or equal to 1.
        Period:0.30
        Returns a new elastic easing with the specified period p.

        See more informations `here <https://d3js.org/d3-ease#easeElastic>`_.
        """
        return easeElastic("d3.easeElastic()")

    @staticmethod
    def easeElasticOut():
        """
        Reverse elastic easing; equivalent to 1 - elasticIn(1 - t).
        Symmetric elastic easing; scales elasticIn for t in 0–0.5 and elasticOut for t in
        0.5–1.
        Amplitude:1.00
        Returns a new elastic easing with the specified amplitude a. The amplitude a must be
        greater than or equal to 1.
        Period:0.30
        Returns a new elastic easing with the specified period p.

        See more informations `here <https://d3js.org/d3-ease#easeElasticOut>`_.
        """
        return easeElasticOut("d3.easeElasticOut()")

    @staticmethod
    def easeElasticInOut():
        """
        Symmetric elastic easing; scales elasticIn for t in 0–0.5 and elasticOut for t in
        0.5–1.
        Amplitude:1.00
        Returns a new elastic easing with the specified amplitude a. The amplitude a must be
        greater than or equal to 1.
        Period:0.30
        Returns a new elastic easing with the specified period p.

        See more informations `here <https://d3js.org/d3-ease#easeElasticInOut>`_.
        """
        return easeElasticInOut("d3.easeElasticInOut()")

    @staticmethod
    def easeBackIn():
        """
        Anticipatory easing like a dancer bending her knees before jumping off the floor. The
        degree of overshoot is configurable; if not specified, it defaults to 1.70158.
        Reverse anticipatory easing; equivalent to 1 - easeBackIn(1 - t).
        Symmetric anticipatory easing; scales easeBackIn for t in 0–0.5 and easeBackOut for t
        in 0.5–1.
        Overshoot:1.70
        Returns a new back easing with the specified overshoot s.

        See more informations `here <https://d3js.org/d3-ease#easeBackIn>`_.
        """
        return easeBackIn("d3.easeBackIn()")

    @staticmethod
    def easeBackOut():
        """
        Reverse anticipatory easing; equivalent to 1 - easeBackIn(1 - t).
        Symmetric anticipatory easing; scales easeBackIn for t in 0–0.5 and easeBackOut for t
        in 0.5–1.
        Overshoot:1.70
        Returns a new back easing with the specified overshoot s.

        See more informations `here <https://d3js.org/d3-ease#easeBackOut>`_.
        """
        return easeBackOut("d3.easeBackOut()")

    @staticmethod
    def easeBack():
        """
        Source · Alias for easeBackInOut.
        Anticipatory easing like a dancer bending her knees before jumping off the floor. The
        degree of overshoot is configurable; if not specified, it defaults to 1.70158.
        Reverse anticipatory easing; equivalent to 1 - easeBackIn(1 - t).
        Symmetric anticipatory easing; scales easeBackIn for t in 0–0.5 and easeBackOut for t
        in 0.5–1.
        Overshoot:1.70
        Returns a new back easing with the specified overshoot s.

        See more informations `here <https://d3js.org/d3-ease#easeBack>`_.
        """
        return easeBack("d3.easeBack()")

    @staticmethod
    def easeBackInOut():
        """
        Symmetric anticipatory easing; scales easeBackIn for t in 0–0.5 and easeBackOut for t
        in 0.5–1.
        Overshoot:1.70
        Returns a new back easing with the specified overshoot s.

        See more informations `here <https://d3js.org/d3-ease#easeBackInOut>`_.
        """
        return easeBackInOut("d3.easeBackInOut()")

    @staticmethod
    def forceSimulation(alpha=None):
        """
        Source · Creates a new simulation with the specified array of nodes and no forces. If
        nodes is not specified, it defaults to the empty array.
        .. code:: javascript

            const simulation = d3.forceSimulation(nodes);

        The simulator starts automatically; use simulation.on to listen for tick events as the
        simulation runs. If you wish to run the simulation manually instead, call
        simulation.stop, and then call simulation.tick as desired.

        See more informations `here <https://d3js.org/d3-force/simulation#forceSimulation>`_.
        Applies this force, optionally observing the specified alpha. Typically, the force is
        applied to the array of nodes previously passed to force.initialize, however, some
        forces may apply to a subset of nodes, or behave differently. For example, forceLink
        applies to the source and target of each link.
        Supplies the array of nodes and random source to this force. This method is called when
        a force is bound to a simulation via simulation.force and when the simulation’s nodes
        change via simulation.nodes. A force may perform necessary work during initialization,
        such as evaluating per-node parameters, to avoid repeatedly performing work during each
        application of the force.

        See more informations `here <https://d3js.org/d3-force/simulation#_force>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (alpha,))))
        return forceSimulation(f"d3.forceSimulation({arguments})")

    @staticmethod
    def forceCenter(x=None, y=None):
        """
        Source · Creates a new center force with the specified x- and y- coordinates. If x and
        y are not specified, they default to ⟨0,0⟩.
        .. code:: javascript

            const center = d3.forceCenter(width / 2, height / 2);


        See more informations `here <https://d3js.org/d3-force/center#forceCenter>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (x, y))))
        return forceCenter(f"d3.forceCenter({arguments})")

    @staticmethod
    def forceCollide(radius=None):
        """
        Source · Creates a new circle collide force with the specified radius. If radius is not
        specified, it defaults to the constant one for all nodes.
        .. code:: javascript

            const collide = d3.forceCollide((d) => d.r);


        See more informations `here <https://d3js.org/d3-force/collide#forceCollide>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (radius,))))
        return forceCollide(f"d3.forceCollide({arguments})")

    @staticmethod
    def forceLink(links=None):
        """
        Source · Creates a new link force with the specified links and default parameters. If
        links is not specified, it defaults to the empty array.
        .. code:: javascript

            const link = d3.forceLink(links).id((d) => d.id);


        See more informations `here <https://d3js.org/d3-force/link#forceLink>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (links,))))
        return forceLink(f"d3.forceLink({arguments})")

    @staticmethod
    def forceManyBody():
        """
        Source · Creates a new many-body force with the default parameters.
        .. code:: javascript

            const manyBody = d3.forceManyBody().strength(-100);


        See more informations `here <https://d3js.org/d3-force/many-body#forceManyBody>`_.
        """
        return forceManyBody("d3.forceManyBody()")

    @staticmethod
    def forceX(x=None):
        """
        Source · Creates a new position force along the x-axis towards the given position x. If
        x is not specified, it defaults to 0.
        .. code:: javascript

            const x = d3.forceX(width / 2);


        See more informations `here <https://d3js.org/d3-force/position#forceX>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (x,))))
        return forceX(f"d3.forceX({arguments})")

    @staticmethod
    def forceY(y=None):
        """
        Source · Creates a new position force along the y-axis towards the given position y. If
        y is not specified, it defaults to 0.
        .. code:: javascript

            const y = d3.forceY(height / 2);


        See more informations `here <https://d3js.org/d3-force/position#forceY>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (y,))))
        return forceY(f"d3.forceY({arguments})")

    @staticmethod
    def forceRadial(radius=None, x=None, y=None):
        """
        Source · Creates a new position force towards a circle of the specified radius centered
        at ⟨x,y⟩. If x and y are not specified, they default to ⟨0,0⟩.
        .. code:: javascript

            const radial = d3.forceRadial(r, width / 2, height / 2);


        See more informations `here <https://d3js.org/d3-force/position#forceRadial>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (radius, x, y))))
        return forceRadial(f"d3.forceRadial({arguments})")

    @staticmethod
    def geoPath(object=None, *arguments):
        """
        Source · Creates a new geographic path generator with the default settings. If
        projection is specified, sets the current projection. If context is specified, sets the
        current context.
        .. code:: javascript

            const path = d3.geoPath(projection); // for SVG

        .. code:: javascript

            const path = d3.geoPath(projection, context); // for canvas


        See more informations `here <https://d3js.org/d3-geo/path#geoPath>`_.
        Source · Renders the given object, which may be any GeoJSON feature or geometry object:
        The type Sphere is also supported, which is useful for rendering the outline of the
        globe; a sphere has no coordinates. Any additional arguments are passed along to the
        pointRadius accessor.
        To display multiple features, combine them into a feature collection:
        .. code:: javascript

            svg.append("path")
                .datum({type: "FeatureCollection", features: features})
                .attr("d", d3.geoPath());

        Or use multiple path elements:
        .. code:: javascript

            svg.selectAll()
              .data(features)
              .join("path")
                .attr("d", d3.geoPath());

        Separate path elements are typically slower than a single path element. However,
        distinct path elements are useful for styling and interaction (e.g., click or
        mouseover). Canvas rendering (see path.context) is typically faster than SVG, but
        requires more effort to implement styling and interaction.

        See more informations `here <https://d3js.org/d3-geo/path#_path>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (object, *arguments))))
        return geoPath(f"d3.geoPath({arguments})")

    @staticmethod
    def projection():
        """
        Source · The identity transform can be used to scale, translate and clip planar
        geometry. It implements projection.scale, projection.translate, projection.fitExtent,
        projection.fitSize, projection.fitWidth, projection.fitHeight, projection.clipExtent,
        projection.angle, projection.reflectX and projection.reflectY.

        See more informations `here <https://d3js.org/d3-geo/projection#geoIdentity>`_.
        """
        return projection("d3.projection()")

    @staticmethod
    def project(lambda_=None, phi=None):
        """
        Projects the specified point [lambda, phi] in radians, returning a new point [x, y] in
        unitless coordinates.
        The inverse of project.

        See more informations `here <https://d3js.org/d3-geo/projection#_project>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (lambda_, phi))))
        return project(f"d3.project({arguments})")

    @staticmethod
    def geoIdentity(point=None):
        """
        Source · Returns a new array [x, y] (typically in pixels) representing the projected
        point of the given point. The point must be specified as a two-element array
        [longitude, latitude] in degrees. May return null if the specified point has no defined
        projected position, such as when the point is outside the clipping bounds of the
        projection.

        See more informations `here <https://d3js.org/d3-geo/projection#_projection>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (point,))))
        return geoIdentity(f"d3.geoIdentity({arguments})")

    @staticmethod
    def conic():
        """
        See more informations `here <https://d3js.org/d3-geo/conic#conic_parallels>`_.
        """
        return conic("d3.conic()")

    @staticmethod
    def geoStream(object=None, stream=None):
        """
        Source · Streams the specified GeoJSON object to the specified projection stream. While
        both features and geometry objects are supported as input, the stream interface only
        describes the geometry, and thus additional feature properties are not visible to
        streams.

        See more informations `here <https://d3js.org/d3-geo/stream#geoStream>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (object, stream))))
        return geoStream(f"d3.geoStream({arguments})")

    @staticmethod
    def geoGraticule():
        """
        Source · Constructs a geometry generator for creating graticules: a uniform grid of
        meridians and parallels for showing projection distortion. The default graticule has
        meridians and parallels every 10° between ±80° latitude; for the polar regions, there
        are meridians every 90°.

        See more informations `here <https://d3js.org/d3-geo/shape#geoGraticule>`_.
        Source · Returns a GeoJSON MultiLineString geometry object representing all meridians
        and parallels for this graticule.

        See more informations `here <https://d3js.org/d3-geo/shape#_graticule>`_.
        """
        return geoGraticule("d3.geoGraticule()")

    @staticmethod
    def geoCircle(*arguments):
        """
        Source · Returns a new circle generator.

        See more informations `here <https://d3js.org/d3-geo/shape#geoCircle>`_.
        Source · Returns a new GeoJSON geometry object of type “Polygon” approximating a circle
        on the surface of a sphere, with the current center, radius and precision. Any
        arguments are passed to the accessors.

        See more informations `here <https://d3js.org/d3-geo/shape#_circle>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (*arguments,))))
        return geoCircle(f"d3.geoCircle({arguments})")

    @staticmethod
    def node():
        """
        See more informations `here <https://d3js.org/d3-hierarchy/hierarchy#node_ancestors>`_.
        """
        return node("d3.node()")

    @staticmethod
    def stratify(data=None):
        """
        Source · Constructs a new stratify operator with the default settings.
        .. code:: javascript

            const stratify = d3.stratify();


        See more informations `here <https://d3js.org/d3-hierarchy/stratify#stratify>`_.
        Source · Generates a new hierarchy from the specified tabular data.
        .. code:: javascript

            const root = stratify(data);


        See more informations `here <https://d3js.org/d3-hierarchy/stratify#_stratify>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (data,))))
        return stratify(f"d3.stratify({arguments})")

    @staticmethod
    def cluster(root=None):
        """
        Source · Creates a new cluster layout with default settings.

        See more informations `here <https://d3js.org/d3-hierarchy/cluster#cluster>`_.
        Source · Lays out the specified root hierarchy, assigning the following properties on
        root and its descendants:
        The coordinates x and y represent an arbitrary coordinate system; for example, you can
        treat x as an angle and y as a radius to produce a radial layout. You may want to call
        root.sort before passing the hierarchy to the cluster layout.

        See more informations `here <https://d3js.org/d3-hierarchy/cluster#_cluster>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (root,))))
        return cluster(f"d3.cluster({arguments})")

    @staticmethod
    def tree(root=None):
        """
        Source · Creates a new tree layout with default settings.

        See more informations `here <https://d3js.org/d3-hierarchy/tree#tree>`_.
        Source · Lays out the specified root hierarchy, assigning the following properties on
        root and its descendants:
        The coordinates x and y represent an arbitrary coordinate system; for example, you can
        treat x as an angle and y as a radius to produce a radial layout. You may want to call
        root.sort before passing the hierarchy to the tree layout.

        See more informations `here <https://d3js.org/d3-hierarchy/tree#_tree>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (root,))))
        return tree(f"d3.tree({arguments})")

    @staticmethod
    def treemap(root=None):
        """
        Source · Creates a new treemap layout with default settings.

        See more informations `here <https://d3js.org/d3-hierarchy/treemap#treemap>`_.
        Source · Lays out the specified root hierarchy, assigning the following properties on
        root and its descendants:
        You must call root.sum before passing the hierarchy to the treemap layout. You probably
        also want to call root.sort to order the hierarchy before computing the layout.

        See more informations `here <https://d3js.org/d3-hierarchy/treemap#_treemap>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (root,))))
        return treemap(f"d3.treemap({arguments})")

    @staticmethod
    def treemapSquarify(node=None, x0=None, y0=None, x1=None, y1=None):
        """
        Source · Implements the squarified treemap algorithm by Bruls et al., which seeks to
        produce rectangles of a given aspect ratio.
        Examples · Source · Like treemapSquarify, except preserves the topology (node
        adjacencies) of the previous layout computed by d3.treemapResquarify, if there is one
        and it used the same target aspect ratio. This tiling method is good for animating
        changes to treemaps because it only changes node sizes and not their relative
        positions, thus avoiding distracting shuffling and occlusion. The downside of a stable
        update, however, is a suboptimal layout for subsequent updates: only the first layout
        uses the Bruls et al. squarified algorithm.
        Source · Specifies the desired aspect ratio of the generated rectangles. The ratio must
        be specified as a number greater than or equal to one. Note that the orientation of the
        generated rectangles (tall or wide) is not implied by the ratio; for example, a ratio
        of two will attempt to produce a mixture of rectangles whose width:height ratio is
        either 2:1 or 1:2. (However, you can approximately achieve this result by generating a
        square treemap at different dimensions, and then stretching the treemap to the desired
        aspect ratio.) Furthermore, the specified ratio is merely a hint to the tiling
        algorithm; the rectangles are not guaranteed to have the specified aspect ratio. If not
        specified, the aspect ratio defaults to the golden ratio, φ = (1 + sqrt(5)) / 2, per
        Kong et al.

        See more informations `here <https://d3js.org/d3-hierarchy/treemap#treemapSquarify>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (node, x0, y0, x1, y1))))
        return treemapSquarify(f"d3.treemapSquarify({arguments})")

    @staticmethod
    def treemapResquarify(node=None, x0=None, y0=None, x1=None, y1=None):
        """
        Examples · Source · Like treemapSquarify, except preserves the topology (node
        adjacencies) of the previous layout computed by d3.treemapResquarify, if there is one
        and it used the same target aspect ratio. This tiling method is good for animating
        changes to treemaps because it only changes node sizes and not their relative
        positions, thus avoiding distracting shuffling and occlusion. The downside of a stable
        update, however, is a suboptimal layout for subsequent updates: only the first layout
        uses the Bruls et al. squarified algorithm.
        Source · Specifies the desired aspect ratio of the generated rectangles. The ratio must
        be specified as a number greater than or equal to one. Note that the orientation of the
        generated rectangles (tall or wide) is not implied by the ratio; for example, a ratio
        of two will attempt to produce a mixture of rectangles whose width:height ratio is
        either 2:1 or 1:2. (However, you can approximately achieve this result by generating a
        square treemap at different dimensions, and then stretching the treemap to the desired
        aspect ratio.) Furthermore, the specified ratio is merely a hint to the tiling
        algorithm; the rectangles are not guaranteed to have the specified aspect ratio. If not
        specified, the aspect ratio defaults to the golden ratio, φ = (1 + sqrt(5)) / 2, per
        Kong et al.

        See more informations `here <https://d3js.org/d3-hierarchy/treemap#treemapResquarify>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (node, x0, y0, x1, y1))))
        return treemapResquarify(f"d3.treemapResquarify({arguments})")

    @staticmethod
    def partition(root=None):
        """
        Source · Creates a new partition layout with the default settings.

        See more informations `here <https://d3js.org/d3-hierarchy/partition#partition>`_.
        Source · Lays out the specified root hierarchy, assigning the following properties on
        root and its descendants:
        You must call root.sum before passing the hierarchy to the partition layout. You
        probably also want to call root.sort to order the hierarchy before computing the
        layout.

        See more informations `here <https://d3js.org/d3-hierarchy/partition#_partition>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (root,))))
        return partition(f"d3.partition({arguments})")

    @staticmethod
    def pack(root=None):
        """
        Source · Creates a new pack layout with the default settings.
        Source · Lays out the specified root hierarchy, assigning the following properties on
        root and its descendants:
        You must call root.sum before passing the hierarchy to the pack layout. You probably
        also want to call root.sort to order the hierarchy before computing the layout.

        See more informations `here <https://d3js.org/d3-hierarchy/pack#pack>`_.
        Source · Lays out the specified root hierarchy, assigning the following properties on
        root and its descendants:
        You must call root.sum before passing the hierarchy to the pack layout. You probably
        also want to call root.sort to order the hierarchy before computing the layout.

        See more informations `here <https://d3js.org/d3-hierarchy/pack#_pack>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (root,))))
        return pack(f"d3.pack({arguments})")

    @staticmethod
    def interpolateColor():
        """
        See more informations `here <https://d3js.org/d3-interpolate/color#interpolateColor_gamma>`_.
        """
        return interpolateColor("d3.interpolateColor()")

    @staticmethod
    def interpolateZoom(a=None, b=None):
        """
        .. code:: javascript

            d3.interpolateZoom([30, 30, 40], [135, 85, 60])(0.5) // [72, 52, 126.04761005270991]

        Examples · Source · Returns an interpolator between the two views a and b. Each view is
        defined as an array of three numbers: cx, cy and width. The first two coordinates cx,
        cy represent the center of the viewport; the last coordinate width represents the size
        of the viewport.
        The returned interpolator exposes a interpolate.duration property which encodes the
        recommended transition duration in milliseconds. This duration is based on the path
        length of the curved trajectory through xy space. If you want a slower or faster
        transition, multiply this by an arbitrary scale factor (V as described in the original
        paper).

        See more informations `here <https://d3js.org/d3-interpolate/zoom#interpolateZoom>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (a, b))))
        return interpolateZoom(f"d3.interpolateZoom({arguments})")

    @staticmethod
    def path():
        """
        Source · Constructs a new path serializer that implements CanvasPathMethods.

        See more informations `here <https://d3js.org/d3-path#path>`_.
        """
        return path("d3.path()")

    @staticmethod
    def quadtree(data=None, x=None, y=None):
        """
        Source · Creates a new, empty quadtree with an empty extent and the default x and y
        accessors. If data is specified, adds the specified iterable of data to the quadtree.
        .. code:: javascript

            const tree = d3.quadtree(data);

        This is equivalent to:
        .. code:: javascript

            const tree = d3.quadtree().addAll(data);

        If x and y are also specified, sets the x and y accessors to the specified functions
        before adding the specified iterable of data to the quadtree, equivalent to:
        .. code:: javascript

            const tree = d3.quadtree().x(x).y(y).addAll(data);


        See more informations `here <https://d3js.org/d3-quadtree#quadtree>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (data, x, y))))
        return quadtree(f"d3.quadtree({arguments})")

    @staticmethod
    def randomUniform(min=None, max=None):
        """
        .. code:: javascript

            d3.randomUniform(6) // generate numbers ≥0 and <6

        Examples · Source · Returns a function for generating random numbers with a uniform
        distribution. The minimum allowed value of a returned number is min (inclusive), and
        the maximum is max (exclusive). If min is not specified, it defaults to 0; if max is
        not specified, it defaults to 1. For example:

        See more informations `here <https://d3js.org/d3-random#randomUniform>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (min, max))))
        return randomUniform(f"d3.randomUniform({arguments})")

    @staticmethod
    def randomInt(min=None, max=None):
        """
        .. code:: javascript

            d3.randomInt(100) // generate integers ≥0 and <100

        Examples · Source · Returns a function for generating random integers with a uniform
        distribution. The minimum allowed value of a returned number is ⌊min⌋ (inclusive), and
        the maximum is ⌊max - 1⌋ (inclusive). If min is not specified, it defaults to 0. For
        example:

        See more informations `here <https://d3js.org/d3-random#randomInt>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (min, max))))
        return randomInt(f"d3.randomInt({arguments})")

    @staticmethod
    def randomNormal(mu=None, sigma=None):
        """
        .. code:: javascript

            d3.randomNormal(0, 1) // mean of 0, and standard deviation of 1

        Examples · Source · Returns a function for generating random numbers with a normal
        (Gaussian) distribution. The expected value of the generated numbers is mu, with the
        given standard deviation sigma. If mu is not specified, it defaults to 0; if sigma is
        not specified, it defaults to 1.

        See more informations `here <https://d3js.org/d3-random#randomNormal>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (mu, sigma))))
        return randomNormal(f"d3.randomNormal({arguments})")

    @staticmethod
    def randomLogNormal(mu=None, sigma=None):
        """
        .. code:: javascript

            d3.randomLogNormal(0, 1)

        Examples · Source · Returns a function for generating random numbers with a log-normal
        distribution. The expected value of the random variable’s natural logarithm is mu, with
        the given standard deviation sigma. If mu is not specified, it defaults to 0; if sigma
        is not specified, it defaults to 1.

        See more informations `here <https://d3js.org/d3-random#randomLogNormal>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (mu, sigma))))
        return randomLogNormal(f"d3.randomLogNormal({arguments})")

    @staticmethod
    def randomBates(n=None):
        """
        .. code:: javascript

            d3.randomBates(3) // generates numbers between 0 and 1

        Examples · Source · Returns a function for generating random numbers with a Bates
        distribution with n independent variables. The case of fractional n is handled as with
        d3.randomIrwinHall, and d3.randomBates(0) is equivalent to d3.randomUniform().

        See more informations `here <https://d3js.org/d3-random#randomBates>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (n,))))
        return randomBates(f"d3.randomBates({arguments})")

    @staticmethod
    def randomIrwinHall(n=None):
        """
        .. code:: javascript

            d3.randomIrwinHall(3) // generates numbers between 0 and 3

        Examples · Source · Returns a function for generating random numbers with an Irwin–Hall
        distribution with n independent variables. If the fractional part of n is non-zero,
        this is treated as adding d3.randomUniform() times that fractional part to the integral
        part.

        See more informations `here <https://d3js.org/d3-random#randomIrwinHall>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (n,))))
        return randomIrwinHall(f"d3.randomIrwinHall({arguments})")

    @staticmethod
    def randomExponential(lambda_=None):
        """
        .. code:: javascript

            d3.randomExponential(1 / 40)

        Examples · Source · Returns a function for generating random numbers with an
        exponential distribution with the rate lambda; equivalent to time between events in a
        Poisson process with a mean of 1 / lambda. For example, randomExponential(1 / 40)
        generates random times between events where, on average, one event occurs every 40
        units of time.

        See more informations `here <https://d3js.org/d3-random#randomExponential>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (lambda_,))))
        return randomExponential(f"d3.randomExponential({arguments})")

    @staticmethod
    def randomPareto(alpha=None):
        """
        .. code:: javascript

            d3.randomPareto(6)

        Examples · Source · Returns a function for generating random numbers with a Pareto
        distribution with the shape alpha. The value alpha must be a positive value.

        See more informations `here <https://d3js.org/d3-random#randomPareto>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (alpha,))))
        return randomPareto(f"d3.randomPareto({arguments})")

    @staticmethod
    def randomBernoulli(p=None):
        """
        .. code:: javascript

            d3.randomBernoulli(0.5)

        Examples · Source · Returns a function for generating either 1 or 0 according to a
        Bernoulli distribution with 1 being returned with success probability p and 0 with
        failure probability q = 1 - p. The value p is in the range [0, 1].

        See more informations `here <https://d3js.org/d3-random#randomBernoulli>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (p,))))
        return randomBernoulli(f"d3.randomBernoulli({arguments})")

    @staticmethod
    def randomGeometric(p=None):
        """
        .. code:: javascript

            d3.randomGeometric(0.1)

        Examples · Source · Returns a function for generating numbers with a geometric
        distribution with success probability p. The value p is in the range [0, 1].

        See more informations `here <https://d3js.org/d3-random#randomGeometric>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (p,))))
        return randomGeometric(f"d3.randomGeometric({arguments})")

    @staticmethod
    def randomBinomial(n=None, p=None):
        """
        .. code:: javascript

            d3.randomBinomial(40, 0.5)

        Examples · Source · Returns a function for generating random numbers with a binomial
        distribution with n the number of trials and p the probability of success in each
        trial. The value n is greater or equal to 0, and the value p is in the range [0, 1].

        See more informations `here <https://d3js.org/d3-random#randomBinomial>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (n, p))))
        return randomBinomial(f"d3.randomBinomial({arguments})")

    @staticmethod
    def randomGamma(k=None, theta=None):
        """
        .. code:: javascript

            d3.randomGamma(2, 1)

        Examples · Source · Returns a function for generating random numbers with a gamma
        distribution with k the shape parameter and theta the scale parameter. The value k must
        be a positive value; if theta is not specified, it defaults to 1.

        See more informations `here <https://d3js.org/d3-random#randomGamma>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (k, theta))))
        return randomGamma(f"d3.randomGamma({arguments})")

    @staticmethod
    def randomBeta(alpha=None, beta=None):
        """
        .. code:: javascript

            d3.randomBeta(3, 1.5)

        Examples · Source · Returns a function for generating random numbers with a beta
        distribution with alpha and beta shape parameters, which must both be positive.

        See more informations `here <https://d3js.org/d3-random#randomBeta>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (alpha, beta))))
        return randomBeta(f"d3.randomBeta({arguments})")

    @staticmethod
    def randomWeibull(k=None, a=None, b=None):
        """
        .. code:: javascript

            d3.randomWeibull(10)

        Examples · Source · Returns a function for generating random numbers with one of the
        generalized extreme value distributions, depending on k:
        In all three cases, a is the location parameter and b is the scale parameter. If a is
        not specified, it defaults to 0; if b is not specified, it defaults to 1.

        See more informations `here <https://d3js.org/d3-random#randomWeibull>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (k, a, b))))
        return randomWeibull(f"d3.randomWeibull({arguments})")

    @staticmethod
    def randomCauchy(a=None, b=None):
        """
        .. code:: javascript

            d3.randomCauchy(0, 1) // above, clipped to [-5, 5] because “fat tails”

        Examples · Source · Returns a function for generating random numbers with a Cauchy
        distribution. a and b have the same meanings and default values as in d3.randomWeibull.

        See more informations `here <https://d3js.org/d3-random#randomCauchy>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (a, b))))
        return randomCauchy(f"d3.randomCauchy({arguments})")

    @staticmethod
    def randomLogistic(a=None, b=None):
        """
        .. code:: javascript

            d3.randomLogistic(0, 1)

        Examples · Source · Returns a function for generating random numbers with a logistic
        distribution. a and b have the same meanings and default values as in d3.randomWeibull.

        See more informations `here <https://d3js.org/d3-random#randomLogistic>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (a, b))))
        return randomLogistic(f"d3.randomLogistic({arguments})")

    @staticmethod
    def randomPoisson(lambda_=None):
        """
        .. code:: javascript

            d3.randomPoisson(400)

        Examples · Source · Returns a function for generating random numbers with a Poisson
        distribution with mean lambda.

        See more informations `here <https://d3js.org/d3-random#randomPoisson>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (lambda_,))))
        return randomPoisson(f"d3.randomPoisson({arguments})")

    @staticmethod
    def scaleLinear(value=None):
        """
        Examples · Source · Constructs a new linear scale with the specified domain and range,
        the default interpolator, and clamping disabled.
        .. code:: javascript

            d3.scaleLinear([0, 100], ["red", "blue"])

        If a single argument is specified, it is interpreted as the range. If either domain or
        range are not specified, each defaults to [0, 1].
        .. code:: javascript

            d3.scaleLinear(["red", "blue"]) // default domain of [0, 1]


        See more informations `here <https://d3js.org/d3-scale/linear#scaleLinear>`_.
        Examples · Source · Given a value from the domain, returns the corresponding value from
        the range. For example, to apply a position encoding:
        .. code:: javascript

            const x = d3.scaleLinear([10, 130], [0, 960]);
            x(20); // 80
            x(50); // 320

        To apply a color encoding:
        .. code:: javascript

            const color = d3.scaleLinear([10, 100], ["brown", "steelblue"]);
            color(20); // "rgb(154, 52, 57)"
            color(50); // "rgb(123, 81, 103)"

        If the given value is outside the domain, and clamping is not enabled, the mapping will
        be extrapolated such that the returned value is outside the range.

        See more informations `here <https://d3js.org/d3-scale/linear#_linear>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (value,))))
        return scaleLinear(f"d3.scaleLinear({arguments})")

    @staticmethod
    def scaleIdentity(range=None):
        """
        Examples · Source · Constructs a new identity scale with the specified range (and by
        extension, domain).
        .. code:: javascript

            const x = d3.scaleIdentity([0, 960]);

        Identity scales are a special case of linear scales where the domain and range are
        identical; the scale and its invert method are thus the identity function. These scales
        are occasionally useful when working with pixel coordinates, say in conjunction with an
        axis. Identity scales do not support rangeRound, clamp or interpolate.
        If range is not specified, it defaults to [0, 1].

        See more informations `here <https://d3js.org/d3-scale/linear#scaleIdentity>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (range,))))
        return scaleIdentity(f"d3.scaleIdentity({arguments})")

    @staticmethod
    def scaleRadial(domain=None, range=None):
        """
        Examples · Source · Constructs a new radial scale with the specified domain and range.
        .. code:: javascript

            const r = d3.scaleRadial([100, 200], [0, 480]);

        Radial scales are a variant of linear scales where the range is internally squared so
        that an input value corresponds linearly to the squared output value. These scales are
        useful when you want the input value to correspond to the area of a graphical mark and
        the mark is specified by radius, as in a radial bar chart. Radial scales do not support
        interpolate.
        If domain or range is not specified, each defaults to [0, 1].

        See more informations `here <https://d3js.org/d3-scale/linear#scaleRadial>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (domain, range))))
        return scaleRadial(f"d3.scaleRadial({arguments})")

    @staticmethod
    def scalePow(domain=None, range=None):
        """
        Examples · Source · Constructs a new pow scale with the specified domain and range, the
        exponent 1, the default interpolator and clamping disabled.
        .. code:: javascript

            const x = d3.scalePow([0, 100], ["red", "blue"]).exponent(2);

        If either domain or range are not specified, each defaults to [0, 1].
        Examples · Source · Constructs a new pow scale with the specified domain and range, the
        exponent 0.5, the default interpolator and clamping disabled.
        .. code:: javascript

            const x = d3.scaleSqrt([0, 100], ["red", "blue"]);

        If either domain or range are not specified, each defaults to [0, 1]. This is a
        convenience method equivalent to d3.scalePow(…).exponent(0.5).
        Examples · Source · If exponent is specified, sets the current exponent to the given
        numeric value and returns this scale.
        .. code:: javascript

            const x = d3.scalePow([0, 100], ["red", "blue"]).exponent(2);

        If exponent is not specified, returns the current exponent, which defaults to 1.
        .. code:: javascript

            x.exponent() // 2

        If the exponent is 1, the pow scale is effectively a linear scale.

        See more informations `here <https://d3js.org/d3-scale/pow#scalePow>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (domain, range))))
        return scalePow(f"d3.scalePow({arguments})")

    @staticmethod
    def scaleSqrt(domain=None, range=None):
        """
        Examples · Source · Constructs a new pow scale with the specified domain and range, the
        exponent 0.5, the default interpolator and clamping disabled.
        .. code:: javascript

            const x = d3.scaleSqrt([0, 100], ["red", "blue"]);

        If either domain or range are not specified, each defaults to [0, 1]. This is a
        convenience method equivalent to d3.scalePow(…).exponent(0.5).
        Examples · Source · If exponent is specified, sets the current exponent to the given
        numeric value and returns this scale.
        .. code:: javascript

            const x = d3.scalePow([0, 100], ["red", "blue"]).exponent(2);

        If exponent is not specified, returns the current exponent, which defaults to 1.
        .. code:: javascript

            x.exponent() // 2

        If the exponent is 1, the pow scale is effectively a linear scale.

        See more informations `here <https://d3js.org/d3-scale/pow#scaleSqrt>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (domain, range))))
        return scaleSqrt(f"d3.scaleSqrt({arguments})")

    @staticmethod
    def scaleLog(domain=None, range=None):
        """
        Examples · Source · Constructs a new log scale with the specified domain and range, the
        base 10, the default interpolator and clamping disabled.
        .. code:: javascript

            const x = d3.scaleLog([1, 10], [0, 960]);

        If domain is not specified, it defaults to [1, 10]. If range is not specified, it
        defaults to [0, 1].

        See more informations `here <https://d3js.org/d3-scale/log#scaleLog>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (domain, range))))
        return scaleLog(f"d3.scaleLog({arguments})")

    @staticmethod
    def scaleSymlog(domain=None, range=None):
        """
        Examples · Source · Constructs a new continuous scale with the specified domain and
        range, the constant 1, the default interpolator and clamping disabled.
        .. code:: javascript

            const x = d3.scaleSymlog([0, 100], [0, 960]);

        If a single argument is specified, it is interpreted as the range. If either domain or
        range are not specified, each defaults to [0, 1].
        .. code:: javascript

            const color = d3.scaleSymlog(["red", "blue"]) // default domain of [0, 1]


        See more informations `here <https://d3js.org/d3-scale/symlog#scaleSymlog>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (domain, range))))
        return scaleSymlog(f"d3.scaleSymlog({arguments})")

    @staticmethod
    def scaleTime(domain=None, range=None):
        """
        Examples · Source · Constructs a new time scale with the specified domain and range,
        the default interpolator and clamping disabled. For example, to create a position
        encoding:
        .. code:: javascript

            const x = d3.scaleTime([new Date(2000, 0, 1), new Date(2000, 0, 2)], [0, 960]);
            x(new Date(2000, 0, 1, 5)); // 200
            x(new Date(2000, 0, 1, 16)); // 640
            x.invert(200); // Sat Jan 01 2000 05:00:00 GMT-0800 (PST)
            x.invert(640); // Sat Jan 01 2000 16:00:00 GMT-0800 (PST)

        If domain is not specified, it defaults to [2000-01-01, 2000-01-02] in local time. If
        range is not specified, it defaults to [0, 1].

        See more informations `here <https://d3js.org/d3-scale/time#scaleTime>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (domain, range))))
        return scaleTime(f"d3.scaleTime({arguments})")

    @staticmethod
    def scaleUtc(domain=None, range=None):
        """
        Examples · Source · Equivalent to scaleTime, but the returned time scale operates in
        Coordinated Universal Time rather than local time. For example, to create a position
        encoding:
        .. code:: javascript

            const x = d3.scaleUtc([new Date("2000-01-01"), new Date("2000-01-02")], [0, 960]);
            x(new Date("2000-01-01T05:00Z")); // 200
            x(new Date("2000-01-01T16:00Z")); // 640
            x.invert(200); // 2000-01-01T05:00Z
            x.invert(640); // 2000-01-01T16:00Z

        If domain is not specified, it defaults to [2000-01-01, 2000-01-02] in UTC time. If
        range is not specified, it defaults to [0, 1].

        See more informations `here <https://d3js.org/d3-scale/time#scaleUtc>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (domain, range))))
        return scaleUtc(f"d3.scaleUtc({arguments})")

    @staticmethod
    def scaleSequential(domain=None, interpolator=None):
        """
        Examples · Source · Constructs a new sequential scale with the specified domain and
        interpolator function or array.
        .. code:: javascript

            const color = d3.scaleSequential([0, 100], d3.interpolateBlues);

        If domain is not specified, it defaults to [0, 1].
        .. code:: javascript

            const color = d3.scaleSequential(d3.interpolateBlues);

        If interpolator is not specified, it defaults to the identity function.
        .. code:: javascript

            const identity = d3.scaleSequential();

        When the scale is applied, the interpolator will be invoked with a value typically in
        the range [0, 1], where 0 represents the minimum value and 1 represents the maximum
        value. For example, to implement the ill-advised angry rainbow scale (please use
        interpolateRainbow instead):
        .. code:: javascript

            const rainbow = d3.scaleSequential((t) => d3.hsl(t * 360, 1, 0.5) + "");

        If interpolator is an array, it represents the scale’s two-element output range and is
        converted to an interpolator function using interpolate.
        .. code:: javascript

            const color = d3.scaleSequential(["red", "blue"]);

        A sequential scale’s domain must be numeric and must contain exactly two values.

        See more informations `here <https://d3js.org/d3-scale/sequential#scaleSequential>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (domain, interpolator))))
        return scaleSequential(f"d3.scaleSequential({arguments})")

    @staticmethod
    def scaleSequentialLog(domain=None, range=None):
        """
        Returns a new sequential scale with a logarithmic transform, analogous to a log scale.

        See more informations `here <https://d3js.org/d3-scale/sequential#scaleSequentialLog>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (domain, range))))
        return scaleSequentialLog(f"d3.scaleSequentialLog({arguments})")

    @staticmethod
    def scaleSequentialPow(domain=None, range=None):
        """
        Returns a new sequential scale with an exponential transform, analogous to a power
        scale.

        See more informations `here <https://d3js.org/d3-scale/sequential#scaleSequentialPow>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (domain, range))))
        return scaleSequentialPow(f"d3.scaleSequentialPow({arguments})")

    @staticmethod
    def scaleSequentialSqrt(domain=None, range=None):
        """
        Returns a new sequential scale with a square-root transform, analogous to a sqrt scale.

        See more informations `here <https://d3js.org/d3-scale/sequential#scaleSequentialSqrt>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (domain, range))))
        return scaleSequentialSqrt(f"d3.scaleSequentialSqrt({arguments})")

    @staticmethod
    def scaleSequentialSymlog(domain=None, range=None):
        """
        Returns a new sequential scale with a symmetric logarithmic transform, analogous to a
        symlog scale.

        See more informations `here <https://d3js.org/d3-scale/sequential#scaleSequentialSymlog>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (domain, range))))
        return scaleSequentialSymlog(f"d3.scaleSequentialSymlog({arguments})")

    @staticmethod
    def scaleSequentialQuantile(domain=None, range=None):
        """
        Source · Returns a new sequential scale with a p-quantile transform, analogous to a
        quantile scale.

        See more informations `here <https://d3js.org/d3-scale/sequential#scaleSequentialQuantile>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (domain, range))))
        return scaleSequentialQuantile(f"d3.scaleSequentialQuantile({arguments})")

    @staticmethod
    def scaleDiverging(domain=None, interpolator=None):
        """
        Examples · Source · Constructs a new diverging scale with the specified domain and
        interpolator function or array.
        .. code:: javascript

            const color = d3.scaleDiverging([-1, 0, 1], d3.interpolateRdBu);

        If domain is not specified, it defaults to [0, 0.5, 1].
        .. code:: javascript

            const color = d3.scaleDiverging(d3.interpolateRdBu);

        If interpolator is not specified, it defaults to the identity function.
        .. code:: javascript

            const identity = d3.scaleDiverging();

        When the scale is applied, the interpolator will be invoked with a value typically in
        the range [0, 1], where 0 represents the extreme negative value, 0.5 represents the
        neutral value, and 1 represents the extreme positive value.
        If interpolator is an array, it represents the scale’s three-element output range and
        is converted to an interpolator function using d3.interpolate and d3.piecewise.
        .. code:: javascript

            const color = d3.scaleDiverging(["blue", "white", "red"]);

        A diverging scale’s domain must be numeric and must contain exactly three values.

        See more informations `here <https://d3js.org/d3-scale/diverging#scaleDiverging>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (domain, interpolator))))
        return scaleDiverging(f"d3.scaleDiverging({arguments})")

    @staticmethod
    def scaleDivergingLog(domain=None, range=None):
        """
        Returns a new diverging scale with a logarithmic transform, analogous to a log scale.

        See more informations `here <https://d3js.org/d3-scale/diverging#scaleDivergingLog>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (domain, range))))
        return scaleDivergingLog(f"d3.scaleDivergingLog({arguments})")

    @staticmethod
    def scaleDivergingPow(domain=None, range=None):
        """
        Returns a new diverging scale with an exponential transform, analogous to a power
        scale.

        See more informations `here <https://d3js.org/d3-scale/diverging#scaleDivergingPow>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (domain, range))))
        return scaleDivergingPow(f"d3.scaleDivergingPow({arguments})")

    @staticmethod
    def scaleDivergingSqrt(domain=None, range=None):
        """
        Returns a new diverging scale with a square-root transform, analogous to a sqrt scale.

        See more informations `here <https://d3js.org/d3-scale/diverging#scaleDivergingSqrt>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (domain, range))))
        return scaleDivergingSqrt(f"d3.scaleDivergingSqrt({arguments})")

    @staticmethod
    def scaleDivergingSymlog(domain=None, range=None):
        """
        Returns a new diverging scale with a symmetric logarithmic transform, analogous to a
        symlog scale.

        See more informations `here <https://d3js.org/d3-scale/diverging#scaleDivergingSymlog>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (domain, range))))
        return scaleDivergingSymlog(f"d3.scaleDivergingSymlog({arguments})")

    @staticmethod
    def scaleQuantize(value=None):
        """
        Examples · Source · Constructs a new quantize scale with the specified domain and
        range.
        .. code:: javascript

            const color = d3.scaleQuantize([0, 100], d3.schemeBlues[9]);

        If either domain or range is not specified, each defaults to [0, 1].
        .. code:: javascript

            const color = d3.scaleQuantize(d3.schemeBlues[9]);


        See more informations `here <https://d3js.org/d3-scale/quantize#scaleQuantize>`_.
        Examples · Source · Given a value in the input domain, returns the corresponding value
        in the output range. For example, to apply a color encoding:
        .. code:: javascript

            const color = d3.scaleQuantize([0, 1], ["brown", "steelblue"]);
            color(0.49); // "brown"
            color(0.51); // "steelblue"

        Or dividing the domain into three equally-sized parts with different range values to
        compute an appropriate stroke width:
        .. code:: javascript

            const width = d3.scaleQuantize([10, 100], [1, 2, 4]);
            width(20); // 1
            width(50); // 2
            width(80); // 4


        See more informations `here <https://d3js.org/d3-scale/quantize#_quantize>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (value,))))
        return scaleQuantize(f"d3.scaleQuantize({arguments})")

    @staticmethod
    def scaleQuantile(value=None):
        """
        Examples · Source · Constructs a new quantile scale with the specified domain and
        range.
        .. code:: javascript

            const color = d3.scaleQuantile(penguins.map((d) => d.body_mass_g), d3.schemeBlues[5]);

        If either domain or range is not specified, each defaults to the empty array. The
        quantile scale is invalid until both a domain and range are specified.

        See more informations `here <https://d3js.org/d3-scale/quantile#scaleQuantile>`_.
        Examples · Source · Given a value in the input domain, returns the corresponding value
        in the output range.
        .. code:: javascript

            color(3000); // "#eff3ff"
            color(4000); // "#6baed6"
            color(5000); // "#08519c"


        See more informations `here <https://d3js.org/d3-scale/quantile#_quantile>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (value,))))
        return scaleQuantile(f"d3.scaleQuantile({arguments})")

    @staticmethod
    def scaleThreshold(value=None):
        """
        Examples · Source · Constructs a new threshold scale with the specified domain and
        range.
        .. code:: javascript

            const color = d3.scaleThreshold([0, 1], ["red", "white", "blue"]);

        If domain is not specified, it defaults to [0.5].
        .. code:: javascript

            const color = d3.scaleThreshold(["red", "blue"]);
            color(0); // "red"
            color(1); // "blue"

        If range is not specified, it defaults to [0, 1].

        See more informations `here <https://d3js.org/d3-scale/threshold#scaleThreshold>`_.
        Examples · Source · Given a value in the input domain, returns the corresponding value
        in the output range. For example:
        .. code:: javascript

            const color = d3.scaleThreshold([0, 1], ["red", "white", "green"]);
            color(-1); // "red"
            color(0); // "white"
            color(0.5); // "white"
            color(1); // "green"
            color(1000); // "green"


        See more informations `here <https://d3js.org/d3-scale/threshold#_threshold>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (value,))))
        return scaleThreshold(f"d3.scaleThreshold({arguments})")

    @staticmethod
    def scaleOrdinal(value=None):
        """
        Examples · Source · Constructs a new ordinal scale with the specified domain and range.
        .. code:: javascript

            const color = d3.scaleOrdinal(["a", "b", "c"], ["red", "green", "blue"]);

        If domain is not specified, it defaults to the empty array. If range is not specified,
        it defaults to the empty array; an ordinal scale always returns undefined until a
        non-empty range is defined.

        See more informations `here <https://d3js.org/d3-scale/ordinal#scaleOrdinal>`_.
        Examples · Source · Given a value in the input domain, returns the corresponding value
        in the output range.
        .. code:: javascript

            color("a") // "red"

        If the given value is not in the scale’s domain, returns the unknown value; or, if the
        unknown value is implicit (the default), then the value is implicitly added to the
        domain and the next-available value in the range is assigned to value, such that this
        and subsequent invocations of the scale given the same input value return the same
        output value.

        See more informations `here <https://d3js.org/d3-scale/ordinal#_ordinal>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (value,))))
        return scaleOrdinal(f"d3.scaleOrdinal({arguments})")

    @staticmethod
    def scaleImplicit():
        """
        Examples · Source · A special value for ordinal.unknown that enables implicit domain
        construction: unknown values are implicitly added to the domain.
        .. code:: javascript

            const color = d3.scaleOrdinal(["a", "b", "c"], d3.schemeTableau10);
            color.unknown(); // d3.scaleImplicit


        See more informations `here <https://d3js.org/d3-scale/ordinal#scaleImplicit>`_.
        """
        return scaleImplicit("d3.scaleImplicit()")

    @staticmethod
    def scaleBand(value=None):
        """
        Examples · Source · Constructs a new band scale with the specified domain and range, no
        padding, no rounding and center alignment.
        .. code:: javascript

            const x = d3.scaleBand(["a", "b", "c"], [0, 960]);

        If a single argument is specified, it is interpreted as the range. If domain is not
        specified, it defaults to the empty domain. If range is not specified, it defaults to
        the unit range [0, 1].

        See more informations `here <https://d3js.org/d3-scale/band#scaleBand>`_.
        Examples · Source · Given a value in the input domain, returns the start of the
        corresponding band derived from the output range.
        .. code:: javascript

            const x = d3.scaleBand(["a", "b", "c"], [0, 960]);
            x("a"); // 0
            x("b"); // 320
            x("c"); // 640
            x("d"); // undefined

        If the given value is not in the scale’s domain, returns undefined.

        See more informations `here <https://d3js.org/d3-scale/band#_band>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (value,))))
        return scaleBand(f"d3.scaleBand({arguments})")

    @staticmethod
    def scalePoint(value=None):
        """
        Examples · Source · Constructs a new point scale with the specified domain and range,
        no padding, no rounding and center alignment. If domain is not specified, it defaults
        to the empty domain. If range is not specified, it defaults to the unit range [0, 1].

        See more informations `here <https://d3js.org/d3-scale/point#scalePoint>`_.
        Examples · Source · Given a value in the input domain, returns the corresponding point
        derived from the output range.
        .. code:: javascript

            const x = d3.scalePoint(["a", "b", "c"], [0, 960]);
            x("a"); // 0
            x("b"); // 480
            x("c"); // 960
            x("d"); // undefined

        If the given value is not in the scale’s domain, returns undefined.

        See more informations `here <https://d3js.org/d3-scale/point#_point>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (value,))))
        return scalePoint(f"d3.scalePoint({arguments})")

    @staticmethod
    def select(selector=None):
        """
        Source · Selects the first element that matches the specified selector string.
        .. code:: javascript

            const svg = d3.select("#chart");

        If no elements match the selector, returns an empty selection. If multiple elements
        match the selector, only the first matching element (in document order) will be
        selected. For example, to select the first anchor element:
        .. code:: javascript

            const anchor = d3.select("a");

        If the selector is not a string, instead selects the specified node; this is useful if
        you already have a reference to a node, such as document.body.
        .. code:: javascript

            d3.select(document.body).style("background", "red");

        Or, to make a clicked paragraph red:
        .. code:: javascript

            d3.selectAll("p").on("click", (event) => d3.select(event.currentTarget).style("color", "red"));


        See more informations `here <https://d3js.org/d3-selection/selecting#select>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (selector,))))
        return select(f"d3.select({arguments})")

    @staticmethod
    def selectAll(selector=None):
        """
        Source · Selects all elements that match the specified selector string.
        .. code:: javascript

            const p = d3.selectAll("p");

        The elements will be selected in document order (top-to-bottom). If no elements in the
        document match the selector, or if the selector is null or undefined, returns an empty
        selection.
        If the selector is not a string, instead selects the specified array of nodes; this is
        useful if you already have a reference to nodes, such as this.childNodes within an
        event listener or a global such as document.links. The nodes may instead be an
        iterable, or a pseudo-array such as a NodeList. For example, to color all links red:
        .. code:: javascript

            d3.selectAll(document.links).style("color", "red");


        See more informations `here <https://d3js.org/d3-selection/selecting#selectAll>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (selector,))))
        return selectAll(f"d3.selectAll({arguments})")

    @staticmethod
    def local():
        """
        Source · Declares a new local variable.
        .. code:: javascript

            const foo = d3.local();

        Like var, each local is a distinct symbolic reference; unlike var, the value of each
        local is also scoped by the DOM.

        See more informations `here <https://d3js.org/d3-selection/locals#local>`_.
        """
        return local("d3.local()")

    @staticmethod
    def arc(*arguments):
        """
        Source · Constructs a new arc generator with the default settings. With default
        settings:
        .. code:: javascript

            const arc = d3.arc();

        Or, with the radii and angles configured as constants:
        .. code:: javascript

            const arc = d3.arc()
                .innerRadius(0)
                .outerRadius(100)
                .startAngle(0)
                .endAngle(Math.PI / 2);


        See more informations `here <https://d3js.org/d3-shape/arc#arc>`_.
        Source · Generates an arc for the given arguments. The arguments are arbitrary; they
        are propagated to the arc generator’s accessor functions along with the this object.
        For example, with the default settings, an object with radii and angles is expected:
        .. code:: javascript

            const arc = d3.arc();

            arc({
              innerRadius: 0,
              outerRadius: 100,
              startAngle: 0,
              endAngle: Math.PI / 2
            }); // "M0,-100A100,100,0,0,1,100,0L0,0Z"

        If the radii and angles are instead defined as constants, you can generate an arc
        without any arguments:
        .. code:: javascript

            d3.arc()
                .innerRadius(0)
                .outerRadius(100)
                .startAngle(0)
                .endAngle(Math.PI / 2)
              (); // "M0,-100A100,100,0,0,1,100,0L0,0Z"

        If the arc generator has a context, then the arc is rendered to this context as a
        sequence of path method calls and this function returns void. Otherwise, a path data
        string is returned.

        See more informations `here <https://d3js.org/d3-shape/arc#_arc>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (*arguments,))))
        return arc(f"d3.arc({arguments})")

    @staticmethod
    def pie(data=None, *arguments):
        """
        Source · Constructs a new pie generator with the default settings.
        .. code:: javascript

            const pie = d3.pie();


        See more informations `here <https://d3js.org/d3-shape/pie#pie>`_.
        Source · Generates a pie for the given array of data, returning an array of objects
        representing each datum’s arc angles. For example, given a set of numbers, here is how
        to compute the angles for a pie chart:
        .. code:: javascript

            const data = [1, 1, 2, 3, 5, 8, 13, 21];
            const pie = d3.pie();
            const arcs = pie(data);

        The resulting arcs is an array of objects:
        .. code:: javascript

            [
              {"data":  1, "value":  1, "index": 6, "startAngle": 6.050474740247008, "endAngle": 6.166830023713296, "padAngle": 0},
              {"data":  1, "value":  1, "index": 7, "startAngle": 6.166830023713296, "endAngle": 6.283185307179584, "padAngle": 0},
              {"data":  2, "value":  2, "index": 5, "startAngle": 5.817764173314431, "endAngle": 6.050474740247008, "padAngle": 0},
              {"data":  3, "value":  3, "index": 4, "startAngle": 5.468698322915565, "endAngle": 5.817764173314431, "padAngle": 0},
              {"data":  5, "value":  5, "index": 3, "startAngle": 4.886921905584122, "endAngle": 5.468698322915565, "padAngle": 0},
              {"data":  8, "value":  8, "index": 2, "startAngle": 3.956079637853813, "endAngle": 4.886921905584122, "padAngle": 0},
              {"data": 13, "value": 13, "index": 1, "startAngle": 2.443460952792061, "endAngle": 3.956079637853813, "padAngle": 0},
              {"data": 21, "value": 21, "index": 0, "startAngle": 0.000000000000000, "endAngle": 2.443460952792061, "padAngle": 0}
            ]

        Each object in the returned array has the following properties:
        This representation is designed to work with the arc generator’s default startAngle,
        endAngle and padAngle accessors. Angles are in radians, with 0 at -y (12 o’clock) and
        positive angles proceeding clockwise.
        The length of the returned array is the same as data, and each element i in the
        returned array corresponds to the element i in the input data. The returned array of
        arcs is in the same order as the data, even when the pie chart is sorted.
        Any additional arguments are arbitrary; they are propagated to the pie generator’s
        accessor functions along with the this object.

        See more informations `here <https://d3js.org/d3-shape/pie#_pie>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (data, *arguments))))
        return pie(f"d3.pie({arguments})")

    @staticmethod
    def line(data=None):
        """
        Source · Constructs a new line generator with the given x and y accessor.
        .. code:: javascript

            const line = d3.line((d) => x(d.Date), (d) => y(d.Close));

        If x or y are not specified, the respective defaults will be used. The above can be
        expressed more explicitly as:
        .. code:: javascript

            const line = d3.line()
                .x((d) => x(d.Date))
                .y((d) => y(d.Close));


        See more informations `here <https://d3js.org/d3-shape/line#line>`_.
        Source · Generates a line for the given array of data.
        .. code:: javascript

            svg.append("path").attr("d", line(data)).attr("stroke", "currentColor");

        If the line generator has a context, then the line is rendered to this context as a
        sequence of path method calls and this function returns void. Otherwise, a path data
        string is returned.

        See more informations `here <https://d3js.org/d3-shape/line#_line>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (data,))))
        return line(f"d3.line({arguments})")

    @staticmethod
    def lineRadial(data=None):
        """
        Source · Constructs a new radial line generator with the default settings.
        .. code:: javascript

            const line = d3.lineRadial();


        See more informations `here <https://d3js.org/d3-shape/radial-line#lineRadial>`_.
        Source · Equivalent to line.
        .. code:: javascript

            svg.append("path").attr("d", line(data)).attr("stroke", "currentColor");


        See more informations `here <https://d3js.org/d3-shape/radial-line#_lineRadial>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (data,))))
        return lineRadial(f"d3.lineRadial({arguments})")

    @staticmethod
    def area(data=None):
        """
        Source · Constructs a new area generator with the given x, y0, and y1 accessors or
        numbers.
        .. code:: javascript

            const area = d3.area((d) => x(d.Date), y(0), (d) => y(d.Close));

        If x, y0 or y1 are not specified, the respective defaults will be used. The above can
        be expressed more explicitly as:
        .. code:: javascript

            const area = d3.area()
                .x((d) => x(d.Date))
                .y0(y(0))
                .y1((d) => y(d.Close));


        See more informations `here <https://d3js.org/d3-shape/area#area>`_.
        Source · Generates an area for the given array of data.
        .. code:: javascript

            svg.append("path").attr("d", area(data));

        If the area generator has a context, then the area is rendered to this context as a
        sequence of path method calls and this function returns void. Otherwise, a path data
        string is returned.

        See more informations `here <https://d3js.org/d3-shape/area#_area>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (data,))))
        return area(f"d3.area({arguments})")

    @staticmethod
    def areaRadial(data=None):
        """
        Source · Constructs a new radial area generator with the default settings.
        .. code:: javascript

            const area = d3.areaRadial();


        See more informations `here <https://d3js.org/d3-shape/radial-area#areaRadial>`_.
        Source · Equivalent to area.
        .. code:: javascript

            svg.append("path").attr("d", area(data));


        See more informations `here <https://d3js.org/d3-shape/radial-area#_areaRadial>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (data,))))
        return areaRadial(f"d3.areaRadial({arguments})")

    @staticmethod
    def curveBasis(context=None):
        """
        Source · Produces a cubic basis spline using the specified control points. The first
        and last points are triplicated such that the spline starts at the first point and ends
        at the last point, and is tangent to the line between the first and second points, and
        to the line between the penultimate and last points.

        See more informations `here <https://d3js.org/d3-shape/curve#curveBasis>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (context,))))
        return curveBasis(f"d3.curveBasis({arguments})")

    @staticmethod
    def curveBasisClosed(context=None):
        """
        Source · Produces a closed cubic basis spline using the specified control points. When
        a line segment ends, the first three control points are repeated, producing a closed
        loop with C2 continuity.

        See more informations `here <https://d3js.org/d3-shape/curve#curveBasisClosed>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (context,))))
        return curveBasisClosed(f"d3.curveBasisClosed({arguments})")

    @staticmethod
    def curveBasisOpen(context=None):
        """
        Source · Produces a cubic basis spline using the specified control points. Unlike
        basis, the first and last points are not repeated, and thus the curve typically does
        not intersect these points.

        See more informations `here <https://d3js.org/d3-shape/curve#curveBasisOpen>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (context,))))
        return curveBasisOpen(f"d3.curveBasisOpen({arguments})")

    @staticmethod
    def curveBundle(context=None):
        """
        Source · Produces a straightened cubic basis spline using the specified control points,
        with the spline straightened according to the curve’s beta, which defaults to 0.85.
        This curve is typically used in hierarchical edge bundling to disambiguate connections,
        as proposed by Danny Holten in Hierarchical Edge Bundles: Visualization of Adjacency
        Relations in Hierarchical Data. This curve does not implement curve.areaStart and
        curve.areaEnd; it is intended to work with d3.line, not d3.area.

        See more informations `here <https://d3js.org/d3-shape/curve#curveBundle>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (context,))))
        return curveBundle(f"d3.curveBundle({arguments})")

    @staticmethod
    def curveBumpX(context=None):
        """
        Source · Produces a Bézier curve between each pair of points, with horizontal tangents
        at each point.

        See more informations `here <https://d3js.org/d3-shape/curve#curveBumpX>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (context,))))
        return curveBumpX(f"d3.curveBumpX({arguments})")

    @staticmethod
    def curveBumpY(context=None):
        """
        Source · Produces a Bézier curve between each pair of points, with vertical tangents at
        each point.

        See more informations `here <https://d3js.org/d3-shape/curve#curveBumpY>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (context,))))
        return curveBumpY(f"d3.curveBumpY({arguments})")

    @staticmethod
    def curveCardinal(context=None):
        """
        Source · Produces a cubic cardinal spline using the specified control points, with
        one-sided differences used for the first and last piece. The default tension is 0.

        See more informations `here <https://d3js.org/d3-shape/curve#curveCardinal>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (context,))))
        return curveCardinal(f"d3.curveCardinal({arguments})")

    @staticmethod
    def curveCardinalClosed(context=None):
        """
        Source · Produces a closed cubic cardinal spline using the specified control points.
        When a line segment ends, the first three control points are repeated, producing a
        closed loop. The default tension is 0.

        See more informations `here <https://d3js.org/d3-shape/curve#curveCardinalClosed>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (context,))))
        return curveCardinalClosed(f"d3.curveCardinalClosed({arguments})")

    @staticmethod
    def curveCardinalOpen(context=None):
        """
        Source · Produces a cubic cardinal spline using the specified control points. Unlike
        curveCardinal, one-sided differences are not used for the first and last piece, and
        thus the curve starts at the second point and ends at the penultimate point. The
        default tension is 0.

        See more informations `here <https://d3js.org/d3-shape/curve#curveCardinalOpen>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (context,))))
        return curveCardinalOpen(f"d3.curveCardinalOpen({arguments})")

    @staticmethod
    def curveCatmullRom(context=None):
        """
        Source · Produces a cubic Catmull–Rom spline using the specified control points and the
        parameter alpha, which defaults to 0.5, as proposed by Yuksel et al. in On the
        Parameterization of Catmull–Rom Curves, with one-sided differences used for the first
        and last piece.

        See more informations `here <https://d3js.org/d3-shape/curve#curveCatmullRom>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (context,))))
        return curveCatmullRom(f"d3.curveCatmullRom({arguments})")

    @staticmethod
    def curveCatmullRomClosed(context=None):
        """
        Source · Produces a closed cubic Catmull–Rom spline using the specified control points
        and the parameter alpha, which defaults to 0.5, as proposed by Yuksel et al. When a
        line segment ends, the first three control points are repeated, producing a closed
        loop.

        See more informations `here <https://d3js.org/d3-shape/curve#curveCatmullRomClosed>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (context,))))
        return curveCatmullRomClosed(f"d3.curveCatmullRomClosed({arguments})")

    @staticmethod
    def curveCatmullRomOpen(context=None):
        """
        Source · Produces a cubic Catmull–Rom spline using the specified control points and the
        parameter alpha, which defaults to 0.5, as proposed by Yuksel et al. Unlike
        curveCatmullRom, one-sided differences are not used for the first and last piece, and
        thus the curve starts at the second point and ends at the penultimate point.

        See more informations `here <https://d3js.org/d3-shape/curve#curveCatmullRomOpen>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (context,))))
        return curveCatmullRomOpen(f"d3.curveCatmullRomOpen({arguments})")

    @staticmethod
    def curveLinear(context=None):
        """
        Source · Produces a polyline through the specified points.

        See more informations `here <https://d3js.org/d3-shape/curve#curveLinear>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (context,))))
        return curveLinear(f"d3.curveLinear({arguments})")

    @staticmethod
    def curveLinearClosed(context=None):
        """
        Source · Produces a closed polyline through the specified points by repeating the first
        point when the line segment ends.

        See more informations `here <https://d3js.org/d3-shape/curve#curveLinearClosed>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (context,))))
        return curveLinearClosed(f"d3.curveLinearClosed({arguments})")

    @staticmethod
    def curveMonotoneX(context=None):
        """
        Source · Produces a cubic spline that preserves monotonicity in y, assuming
        monotonicity in x, as proposed by Steffen in A simple method for monotonic
        interpolation in one dimension: “a smooth curve with continuous first-order derivatives
        that passes through any given set of data points without spurious oscillations. Local
        extrema can occur only at grid points where they are given by the data, but not in
        between two adjacent grid points.”

        See more informations `here <https://d3js.org/d3-shape/curve#curveMonotoneX>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (context,))))
        return curveMonotoneX(f"d3.curveMonotoneX({arguments})")

    @staticmethod
    def curveMonotoneY(context=None):
        """
        Source · Produces a cubic spline that preserves monotonicity in x, assuming
        monotonicity in y, as proposed by Steffen in A simple method for monotonic
        interpolation in one dimension: “a smooth curve with continuous first-order derivatives
        that passes through any given set of data points without spurious oscillations. Local
        extrema can occur only at grid points where they are given by the data, but not in
        between two adjacent grid points.”

        See more informations `here <https://d3js.org/d3-shape/curve#curveMonotoneY>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (context,))))
        return curveMonotoneY(f"d3.curveMonotoneY({arguments})")

    @staticmethod
    def curveNatural(context=None):
        """
        Source · Produces a natural cubic spline with the second derivative of the spline set
        to zero at the endpoints.

        See more informations `here <https://d3js.org/d3-shape/curve#curveNatural>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (context,))))
        return curveNatural(f"d3.curveNatural({arguments})")

    @staticmethod
    def curveStep(context=None):
        """
        Source · Produces a piecewise constant function (a step function) consisting of
        alternating horizontal and vertical lines. The y-value changes at the midpoint of each
        pair of adjacent x-values.

        See more informations `here <https://d3js.org/d3-shape/curve#curveStep>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (context,))))
        return curveStep(f"d3.curveStep({arguments})")

    @staticmethod
    def curveStepAfter(context=None):
        """
        Source · Produces a piecewise constant function (a step function) consisting of
        alternating horizontal and vertical lines. The y-value changes after the x-value.

        See more informations `here <https://d3js.org/d3-shape/curve#curveStepAfter>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (context,))))
        return curveStepAfter(f"d3.curveStepAfter({arguments})")

    @staticmethod
    def curveStepBefore(context=None):
        """
        Source · Produces a piecewise constant function (a step function) consisting of
        alternating horizontal and vertical lines. The y-value changes before the x-value.

        See more informations `here <https://d3js.org/d3-shape/curve#curveStepBefore>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (context,))))
        return curveStepBefore(f"d3.curveStepBefore({arguments})")

    @staticmethod
    def link(*arguments):
        """
        Source · Returns a new link generator using the specified curve. For example, to
        visualize links in a tree diagram rooted on the top edge of the display, you might say:
        .. code:: javascript

            const link = d3.link(d3.curveBumpY)
                .x((d) => d.x)
                .y((d) => d.y);


        See more informations `here <https://d3js.org/d3-shape/link#link>`_.
        Source · Generates a link for the given arguments. The arguments are arbitrary; they
        are propagated to the link generator’s accessor functions along with the this object.
        With the default settings, an object with source and target properties is expected.
        .. code:: javascript

            link({source: [100, 100], target: [300, 300]}) // "M100,100C200,100,200,300,300,300"


        See more informations `here <https://d3js.org/d3-shape/link#_link>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (*arguments,))))
        return link(f"d3.link({arguments})")

    @staticmethod
    def linkVertical():
        """
        Source · Shorthand for link with curveBumpY; suitable for visualizing links in a tree
        diagram rooted on the top edge of the display. Equivalent to:
        .. code:: javascript

            const link = d3.link(d3.curveBumpY);


        See more informations `here <https://d3js.org/d3-shape/link#linkVertical>`_.
        """
        return linkVertical("d3.linkVertical()")

    @staticmethod
    def linkHorizontal():
        """
        Source · Shorthand for link with curveBumpX; suitable for visualizing links in a tree
        diagram rooted on the left edge of the display. Equivalent to:
        .. code:: javascript

            const link = d3.link(d3.curveBumpX);


        See more informations `here <https://d3js.org/d3-shape/link#linkHorizontal>`_.
        """
        return linkHorizontal("d3.linkHorizontal()")

    @staticmethod
    def linkRadial():
        """
        Source · Returns a new link generator with radial tangents. For example, to visualize
        links in a tree diagram rooted in the center of the display, you might say:
        .. code:: javascript

            const link = d3.linkRadial()
                .angle((d) => d.x)
                .radius((d) => d.y);


        See more informations `here <https://d3js.org/d3-shape/radial-link#linkRadial>`_.
        """
        return linkRadial("d3.linkRadial()")

    @staticmethod
    def symbol(*arguments):
        """
        Source · Constructs a new symbol generator of the specified type and size. If not
        specified, type defaults to a circle, and size defaults to 64.
        .. code:: javascript

            svg.append("path").attr("d", d3.symbol(d3.symbolCross));


        See more informations `here <https://d3js.org/d3-shape/symbol#symbol>`_.
        Source · Generates a symbol for the given arguments. The arguments are arbitrary; they
        are propagated to the symbol generator’s accessor functions along with the this object.
        With the default settings, invoking the symbol generator produces a circle of 64 square
        pixels.
        .. code:: javascript

            d3.symbol()() // "M4.514,0A4.514,4.514,0,1,1,-4.514,0A4.514,4.514,0,1,1,4.514,0"

        If the symbol generator has a context, then the symbol is rendered to this context as a
        sequence of path method calls and this function returns void. Otherwise, a path data
        string is returned.

        See more informations `here <https://d3js.org/d3-shape/symbol#_symbol>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (*arguments,))))
        return symbol(f"d3.symbol({arguments})")

    @staticmethod
    def symbolType():
        """
        See more informations `here <https://d3js.org/d3-shape/symbol#symbolType_draw>`_.
        """
        return symbolType("d3.symbolType()")

    @staticmethod
    def stack(data=None, *arguments):
        """
        Source · Constructs a new stack generator with the default settings. See stack for
        usage.

        See more informations `here <https://d3js.org/d3-shape/stack#stack>`_.
        Source · Generates a stack for the given array of data and returns an array
        representing each series. Any additional arguments are arbitrary; they are propagated
        to accessors along with the this object.
        For example, consider this tidy table of monthly fruit sales:
        This could be represented in JavaScript as an array of objects, perhaps parsed from
        CSV:
        .. code:: javascript

            const data = [
              {date: new Date("2015-01-01"), fruit: "apples", sales: 3840},
              {date: new Date("2015-01-01"), fruit: "bananas", sales: 1920},
              {date: new Date("2015-01-01"), fruit: "cherries", sales: 960},
              {date: new Date("2015-01-01"), fruit: "durians", sales: 400},
              {date: new Date("2015-02-01"), fruit: "apples", sales: 1600},
              {date: new Date("2015-02-01"), fruit: "bananas", sales: 1440},
              {date: new Date("2015-02-01"), fruit: "cherries", sales: 960},
              {date: new Date("2015-02-01"), fruit: "durians", sales: 400},
              {date: new Date("2015-03-01"), fruit: "apples", sales: 640},
              {date: new Date("2015-03-01"), fruit: "bananas", sales: 960},
              {date: new Date("2015-03-01"), fruit: "cherries", sales: 640},
              {date: new Date("2015-03-01"), fruit: "durians", sales: 400},
              {date: new Date("2015-04-01"), fruit: "apples", sales: 320},
              {date: new Date("2015-04-01"), fruit: "bananas", sales: 480},
              {date: new Date("2015-04-01"), fruit: "cherries", sales: 640},
              {date: new Date("2015-04-01"), fruit: "durians", sales: 400}
            ];

        To compute the stacked series (a series, or layer, for each fruit; and a stack, or
        column, for each date), we can index the data by date and then fruit, compute the
        distinct fruit names across the data set, and lastly get the sales value for each date
        and fruit.
        .. code:: javascript

            const series = d3.stack()
                .keys(d3.union(data.map(d => d.fruit))) // apples, bananas, cherries, …
                .value(([, group], key) => group.get(key).sales)
              (d3.index(data, d => d.date, d => d.fruit));

        The resulting array has one element per series. Each series has one point per month,
        and each point has a lower and upper value defining the baseline and topline:
        .. code:: javascript

            [
              [[   0, 3840], [   0, 1600], [   0,  640], [   0,  320]], // apples
              [[3840, 5760], [1600, 3040], [ 640, 1600], [ 320,  800]], // bananas
              [[5760, 6720], [3040, 4000], [1600, 2240], [ 800, 1440]], // cherries
              [[6720, 7120], [4000, 4400], [2240, 2640], [1440, 1840]]  // durians
            ]

        Each series in then typically passed to an area generator to render an area chart, or
        used to construct rectangles for a bar chart.
        .. code:: javascript

            svg.append("g")
              .selectAll("g")
              .data(series)
              .join("g")
                .attr("fill", d => color(d.key))
              .selectAll("rect")
              .data(D => D)
              .join("rect")
                .attr("x", d => x(d.data[0]))
                .attr("y", d => y(d[1]))
                .attr("height", d => y(d[0]) - y(d[1]))
                .attr("width", x.bandwidth());

        The series are determined by the keys accessor; each series i in the returned array
        corresponds to the ith key. Each series is an array of points, where each point j
        corresponds to the jth element in the input data. Lastly, each point is represented as
        an array [y0, y1] where y0 is the lower value (baseline) and y1 is the upper value
        (topline); the difference between y0 and y1 corresponds to the computed value for this
        point. The key for each series is available as series.key, and the index as
        series.index. The input data element for each point is available as point.data.

        See more informations `here <https://d3js.org/d3-shape/stack#_stack>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (data, *arguments))))
        return stack(f"d3.stack({arguments})")

    @staticmethod
    def timeInterval(date=None):
        """
        .. code:: javascript

            const utcDay = d3.timeInterval(
              (date) => date.setUTCHours(0, 0, 0, 0), // floor
              (date, step) => date.setUTCDate(date.getUTCDate() + step), // offset
              (start, end) => (end - start) / 864e5, // count
              (date) => date.getUTCDate() - 1 // field
            );

        Source · Constructs a new custom interval given the specified floor and offset
        functions and an optional count function.
        The floor function takes a single date as an argument and rounds it down to the nearest
        interval boundary.
        The offset function takes a date and an integer step as arguments and advances the
        specified date by the specified number of boundaries; the step may be positive,
        negative or zero.
        The optional count function takes a start date and an end date, already floored to the
        current interval, and returns the number of boundaries between the start (exclusive)
        and end (inclusive). If a count function is not specified, the returned interval does
        not expose interval.count or interval.every methods. Note: due to an internal
        optimization, the specified count function must not invoke interval.count on other time
        intervals.
        The optional field function takes a date, already floored to the current interval, and
        returns the field value of the specified date, corresponding to the number of
        boundaries between this date (exclusive) and the latest previous parent boundary. For
        example, for the d3.timeDay interval, this returns the number of days since the start
        of the month. If a field function is not specified, it defaults to counting the number
        of interval boundaries since the UNIX epoch of January 1, 1970 UTC. The field function
        defines the behavior of interval.every.

        See more informations `here <https://d3js.org/d3-time#timeInterval>`_.
        .. code:: javascript

            d3.utcMonday() // the latest preceding Monday, UTC time

        Source · Equivalent to interval.floor, except if date is not specified, it defaults to
        the current time. For example, d3.timeYear(date) and d3.timeYear.floor(date) are
        equivalent.

        See more informations `here <https://d3js.org/d3-time#_interval>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (date,))))
        return timeInterval(f"d3.timeInterval({arguments})")

    @staticmethod
    def timer(callback=None, delay=None, time=None):
        """
        Source · Schedules a new timer, invoking the specified callback repeatedly until the
        timer is stopped. An optional numeric delay in milliseconds may be specified to invoke
        the given callback after a delay; if delay is not specified, it defaults to zero. The
        delay is relative to the specified time in milliseconds; if time is not specified, it
        defaults to now.
        The callback is passed the (apparent) elapsed time since the timer became active. For
        example:
        .. code:: javascript

            const t = d3.timer((elapsed) => {
              console.log(elapsed);
              if (elapsed > 200) t.stop();
            }, 150);

        This produces roughly the following console output:
        .. code:: javascript

            3
            25
            48
            65
            85
            106
            125
            146
            167
            189
            209

        (The exact values may vary depending on your JavaScript runtime and what else your
        computer is doing.) Note that the first elapsed time is 3ms: this is the elapsed time
        since the timer started, not since the timer was scheduled. Here the timer started
        150ms after it was scheduled due to the specified delay. The apparent elapsed time may
        be less than the true elapsed time if the page is backgrounded and
        requestAnimationFrame is paused; in the background, apparent time is frozen.
        If timer is called within the callback of another timer, the new timer callback (if
        eligible as determined by the specified delay and time) will be invoked immediately at
        the end of the current frame, rather than waiting until the next frame. Within a frame,
        timer callbacks are guaranteed to be invoked in the order they were scheduled,
        regardless of their start time.

        See more informations `here <https://d3js.org/d3-timer#timer>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (callback, delay, time))))
        return timer(f"d3.timer({arguments})")

    @staticmethod
    def transition(name=None):
        """
        Source · Returns a new transition on the root element, document.documentElement, with
        the specified name. If a name is not specified, null is used. The new transition is
        only exclusive with other transitions of the same name. The name may also be a
        transition instance; see selection.transition. This method is equivalent to:
        .. code:: javascript

            d3.selection()
              .transition(name)

        This function can also be used to test for transitions (instanceof d3.transition) or to
        extend the transition prototype.

        See more informations `here <https://d3js.org/d3-transition/selecting#transition>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (name,))))
        return transition(f"d3.transition({arguments})")

    @staticmethod
    def zoom(selection=None):
        """
        Source · Creates a new zoom behavior. The returned behavior, zoom, is both an object
        and a function, and is typically applied to selected elements via selection.call.

        See more informations `here <https://d3js.org/d3-zoom#zoom>`_.
        Source · Applies this zoom behavior to the specified selection, binding the necessary
        event listeners to allow panning and zooming, and initializing the zoom transform on
        each selected element to the identity transform if not already defined.
        This function is typically not invoked directly, and is instead invoked via
        selection.call. For example, to instantiate a zoom behavior and apply it to a
        selection:
        .. code:: javascript

            selection.call(d3.zoom().on("zoom", zoomed));

        Internally, the zoom behavior uses selection.on to bind the necessary event listeners
        for zooming. The listeners use the name .zoom, so you can subsequently unbind the zoom
        behavior as follows:
        .. code:: javascript

            selection.on(".zoom", null);

        To disable just wheel-driven zooming (say to not interfere with native scrolling), you
        can remove the zoom behavior’s wheel event listener after applying the zoom behavior to
        the selection:
        .. code:: javascript

            selection
                .call(zoom)
                .on("wheel.zoom", null);

        Alternatively, use zoom.filter for greater control over which events can initiate zoom
        gestures.
        Applying the zoom behavior also sets the -webkit-tap-highlight-color style to
        transparent, disabling the tap highlight on iOS. If you want a different tap highlight
        color, remove or re-apply this style after applying the drag behavior.
        The zoom behavior stores the zoom state on the element to which the zoom behavior was
        applied, not on the zoom behavior itself. This allows the zoom behavior to be applied
        to many elements simultaneously with independent zooming. The zoom state can change
        either on user interaction or programmatically via zoom.transform.
        To retrieve the zoom state, use event.transform on the current zoom event within a zoom
        event listener (see zoom.on), or use zoomTransform for a given node. The latter is
        useful for modifying the zoom state programmatically, say to implement buttons for
        zooming in and out.

        See more informations `here <https://d3js.org/d3-zoom#_zoom>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (selection,))))
        return zoom(f"d3.zoom({arguments})")

    @staticmethod
    def zoomTransform(node=None):
        """
        Source · Returns the current transform for the specified node. Note that node should
        typically be a DOM element, not a selection. (A selection may consist of multiple
        nodes, in different states, and this function only returns a single transform.) If you
        have a selection, call selection.node first:
        .. code:: javascript

            var transform = d3.zoomTransform(selection.node());

        In the context of an event listener, the node is typically the element that received
        the input event (which should be equal to event.transform), this:
        .. code:: javascript

            var transform = d3.zoomTransform(this);

        Internally, an element’s transform is stored as element.__zoom; however, you should use
        this method rather than accessing it directly. If the given node has no defined
        transform, returns the transform of the closest ancestor, or if none exists, the
        identity transformation. The returned transform represents a two-dimensional
        transformation matrix of the form:
        k 0 tx0 k ty0 0 1
        (This matrix is capable of representing only scale and translation; a future release
        may also allow rotation, though this would probably not be a backwards-compatible
        change.) The position ⟨x,y⟩ is transformed to ⟨xk + tx,yk + ty⟩. The transform object
        exposes the following properties:
        These properties should be considered read-only; instead of mutating a transform, use
        transform.scale and transform.translate to derive a new transform. Also see
        zoom.scaleBy, zoom.scaleTo and zoom.translateBy for convenience methods on the zoom
        behavior. To create a transform with a given k, tx, and ty:
        .. code:: javascript

            var t = d3.zoomIdentity.translate(x, y).scale(k);

        To apply the transformation to a Canvas 2D context, use context.translate followed by
        context.scale:
        .. code:: javascript

            context.translate(transform.x, transform.y);
            context.scale(transform.k, transform.k);

        Similarly, to apply the transformation to HTML elements via CSS:
        .. code:: javascript

            div.style("transform", "translate(" + transform.x + "px," + transform.y + "px) scale(" + transform.k + ")");
            div.style("transform-origin", "0 0");

        To apply the transformation to SVG:
        .. code:: javascript

            g.attr("transform", "translate(" + transform.x + "," + transform.y + ") scale(" + transform.k + ")");

        Or more simply, taking advantage of transform.toString:
        .. code:: javascript

            g.attr("transform", transform);

        Note that the order of transformations matters! The translate must be applied before
        the scale.

        See more informations `here <https://d3js.org/d3-zoom#zoomTransform>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (node,))))
        return zoomTransform(f"d3.zoomTransform({arguments})")

    @staticmethod
    def selection():
        """
        Source · Selects the root element, document.documentElement.
        .. code:: javascript

            const root = d3.selection();

        This function can also be used to test for selections (instanceof d3.selection) or to
        extend the selection prototype. For example, to add a method to check checkboxes:
        .. code:: javascript

            d3.selection.prototype.checked = function(value) {
              return arguments.length < 1
                  ? this.property("checked")
                  : this.property("checked", !!value);
            };

        And then to use:
        .. code:: javascript

            d3.selectAll("input[type=checkbox]").checked(true);


        See more informations `here <https://d3js.org/d3-selection/selecting#selection>`_.

        See more informations `here <https://d3js.org/d3-selection/modifying#selection_attr>`_.

        See more informations `here <https://d3js.org/d3-selection/joining#selection_data>`_.

        See more informations `here <https://d3js.org/d3-selection/events#selection_on>`_.

        See more informations `here <https://d3js.org/d3-selection/control-flow#selection_each>`_.

        See more informations `here <https://d3js.org/d3-transition/selecting#selection_transition>`_.
        """
        return selection("d3.selection()")

svg = selection(content="svg")