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

from functools import partial
from operator import is_not

class axisRight:
    def __init__(self, content="axisRight"):
        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})"

    def scale(self, scale=None):
        """
        Source · If scale is specified, sets the scale and returns the axis. If scale is not
        specified, returns the current scale.
        .. code:: javascript

            const xAxis = d3.axisBottom().scale(x);


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


    def ticks(self, *arguments):
        """
        Sets the arguments that will be passed to scale.ticks and scale.tickFormat when the
        axis is rendered, and returns the axis generator.
        The meaning of the arguments depends on the axis’ scale type: most commonly, the
        arguments are a suggested count for the number of ticks (or a time interval for time
        scales), and an optional format specifier to customize how the tick values are
        formatted. For example, to generate twenty ticks with SI-prefix formatting on a linear
        scale, say:
        .. code:: javascript

            axis.ticks(20, "s");

        To generate ticks every fifteen minutes with a time scale, say:
        .. code:: javascript

            axis.ticks(d3.timeMinute.every(15));

        This method is a convenience function for axis.tickArguments. For example, this:
        .. code:: javascript

            axis.ticks(10);

        Is equivalent to:
        .. code:: javascript

            axis.tickArguments([10]);

        This method has no effect if the scale does not implement scale.ticks, as with band and
        point scales. To set the tick values explicitly, use axis.tickValues. To set the tick
        format explicitly, use axis.tickFormat. To generate tick values directly, use
        scale.ticks.

        See more informations `here <https://d3js.org/d3-axis#axis_ticks>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (*arguments,))))
        return axisRight(content=f"{self.content}.ticks({arguments})")


    def tickArguments(self, arguments=None):
        """
        Source · If arguments is specified, sets the arguments that will be passed to
        scale.ticks and scale.tickFormat when the axis is rendered, and returns the axis
        generator. See also axis.ticks, which is used more commonly.
        The meaning of the arguments depends on the axis’ scale type: most commonly, the
        arguments are a suggested count for the number of ticks (or a time interval for time
        scales), and an optional format specifier to customize how the tick values are
        formatted. For example, to generate twenty ticks with SI-prefix formatting on a linear
        scale, say:
        .. code:: javascript

            axis.tickArguments([20, "s"]);

        To generate ticks every fifteen minutes with a time scale, say:
        .. code:: javascript

            axis.tickArguments([d3.timeMinute.every(15)]);

        If arguments is not specified, returns the current tick arguments, which defaults to
        the empty array. If arguments is specified, this method has no effect if the scale does
        not implement scale.ticks, as with band and point scales. To set the tick values
        explicitly, use axis.tickValues. To set the tick format explicitly, use
        axis.tickFormat.

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


    def tickValues(self, values=None):
        """
        Source · If a values iterable is specified, the specified values are used for ticks
        rather than the scale’s automatic tick generator. For example, to generate ticks at
        specific values:
        .. code:: javascript

            const axis = d3.axisBottom(x).tickValues([1, 2, 3, 5, 8, 13, 21]);

        The explicit tick values take precedence over the tick arguments set by
        axis.tickArguments. However, any tick arguments will still be passed to the scale’s
        tickFormat function if a tick format is not also set.
        If values is null, clears any previously-set explicit tick values and reverts back to
        the scale’s tick generator. If values is not specified, returns the current tick
        values, which defaults to null.

        See more informations `here <https://d3js.org/d3-axis#axis_tickValues>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (values,))))
        return axisRight(content=f"{self.content}.tickValues({arguments})")


    def tickFormat(self, format=None):
        """
        Source · If format is specified, sets the tick format function and returns the axis.
        For example, to display integers with comma-grouping for thousands:
        .. code:: javascript

            axis.tickFormat(d3.format(",.0f"));

        More commonly, a format specifier is passed to axis.ticks, which has the advantage of
        setting the format precision automatically based on the tick interval:
        .. code:: javascript

            axis.ticks(10, ",f");

        See d3-format and d3-time-format for help creating formatters.
        If format is not specified, returns the current format function, which defaults to
        null. A null format indicates that the scale’s default formatter should be used, which
        is generated by calling scale.tickFormat. In this case, the arguments specified by
        axis.tickArguments are likewise passed to scale.tickFormat.

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


    def tickSize(self, size=None):
        """
        Source · If size is specified, sets the inner and outer tick size to the specified
        value and returns the axis.
        .. code:: javascript

            const axis = d3.axisBottom(x).tickSize(0);

        If size is not specified, returns the current inner tick size, which defaults to 6.
        .. code:: javascript

            axis.tickSize() // 0


        See more informations `here <https://d3js.org/d3-axis#axis_tickSize>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (size,))))
        return axisRight(content=f"{self.content}.tickSize({arguments})")


    def tickSizeInner(self, size=None):
        """
        Source · If size is specified, sets the inner tick size to the specified value and
        returns the axis.
        .. code:: javascript

            const axis = d3.axisBottom(x).tickSizeInner(0);

        If size is not specified, returns the current inner tick size, which defaults to 6.
        .. code:: javascript

            axis.tickSizeInner() // 0

        The inner tick size controls the length of the tick lines, offset from the native
        position of the axis.

        See more informations `here <https://d3js.org/d3-axis#axis_tickSizeInner>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (size,))))
        return axisRight(content=f"{self.content}.tickSizeInner({arguments})")


    def tickSizeOuter(self, size=None):
        """
        Source · If size is specified, sets the outer tick size to the specified value and
        returns the axis.
        .. code:: javascript

            const axis = d3.axisBottom(x).tickSizeOuter(0);

        If size is not specified, returns the current outer tick size, which defaults to 6.
        .. code:: javascript

            axis.tickSizeOuter() // 0

        The outer tick size controls the length of the square ends of the domain path, offset
        from the native position of the axis. Thus, the “outer ticks” are not actually ticks
        but part of the domain path, and their position is determined by the associated scale’s
        domain extent. Thus, outer ticks may overlap with the first or last inner tick. An
        outer tick size of 0 suppresses the square ends of the domain path, instead producing a
        straight line.

        See more informations `here <https://d3js.org/d3-axis#axis_tickSizeOuter>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (size,))))
        return axisRight(content=f"{self.content}.tickSizeOuter({arguments})")


    def tickPadding(self, padding=None):
        """
        Source · If padding is specified, sets the padding to the specified value in pixels and
        returns the axis.
        .. code:: javascript

            const axis = d3.axisBottom(x).tickPadding(0);

        If padding is not specified, returns the current padding which defaults to 3 pixels.
        .. code:: javascript

            axis.tickPadding() // 0


        See more informations `here <https://d3js.org/d3-axis#axis_tickPadding>`_.
        """
        arguments = ", ".join(map(repr, filter(partial(is_not, None), (padding,))))
        return axisRight(content=f"{self.content}.tickPadding({arguments})")


    def offset(self, offset=None):
        """
        Source · If offset is specified, sets the pixel offset to the specified value in pixels
        and returns the axis.
        .. code:: javascript

            const axis = d3.axisBottom(x).offset(0);

        If offset is not specified, returns the current pixel offset.
        .. code:: javascript

            axis.offset() // 0

        The pixel offset defaults to 0 on devices with a devicePixelRatio greater than 1, and
        0.5 otherwise. This default pixel offset ensures crisp edges on low-resolution devices.

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

