class MarkerBuilder {

    private double[] size = {6};

    // Note, a marker can have a color, or color array, but not both
    private String[] color;
    private double[] colorArray;

    private Gradient gradient;
    private Palette colorScalePalette;
    private boolean cAuto = DEFAULT_C_AUTO;
    private double cMin;
    private double cMax;
    private Line line;
    private boolean autoColorScale = DEFAULT_AUTO_COLOR_SCALE;
    private boolean showScale = DEFAULT_SHOW_SCALE;
    private boolean reverseScale = DEFAULT_REVERSE_SCALE;
    private double opacity = DEFAULT_OPACITY;
    private Symbol symbol;
    private SizeMode sizeMode = DEFAULT_SIZE_MODE;
    private ColorBar colorBar;

    public MarkerBuilder size(double... size) {<FILL_FUNCTION_BODY>}

    public MarkerBuilder size(NumericColumn<?> size) {
      return size(size.asDoubleArray());
    }

    /**
     * Has an effect only if `marker.color` is set to a numerical array and `cmin`, `cmax` are also
     * set. In this case, it controls whether the range of colors in `colorscale` is mapped to the
     * range of values in the `color` array (`cauto: True`), or the `cmin`/`cmax` values (`cauto:
     * False`).
     *
     * <p>Defaults to `False` when `cmin`, `cmax` are set by the user.
     */
    public MarkerBuilder cAuto(boolean b) {
      this.cAuto = b;
      return this;
    }

    /**
     * Has an effect only if `marker.color` is set to a numerical array. Reverses the color mapping
     * if True (`cmin` will correspond to the last color in the array and `cmax` will correspond to
     * the first color).
     */
    public MarkerBuilder reverseScale(boolean b) {
      this.reverseScale = b;
      return this;
    }

    /** Sets an outline around the marker */
    public MarkerBuilder line(Line line) {
      this.line = line;
      return this;
    }

    /** Sets a gradient for the marker */
    public MarkerBuilder gradient(Gradient gradient) {
      this.gradient = gradient;
      return this;
    }

    /** Sets the ColorBar to display the scale for the marker */
    public MarkerBuilder colorBar(ColorBar colorBar) {
      this.colorBar = colorBar;
      return this;
    }

    /**
     * Has an effect only if `marker.color` is set to a numerical array. Determines whether the
     * colorscale is a default palette (`autocolorscale: True`) or the palette determined by
     * `marker.colorscale`. In case `colorscale` is unspecified or `autocolorscale` is True, the
     * default palette will be chosen according to whether numbers in the `color` array are all
     * positive, all negative or mixed.
     *
     * <p>Defaults to true
     */
    public MarkerBuilder autoColorScale(boolean b) {
      this.autoColorScale = b;
      return this;
    }

    /**
     * Has an effect only if `marker.color` is set to a numerical array. Sets the lower and upper
     * bound of the color domain. Values should be associated to the `marker.color` array index
     */
    public MarkerBuilder cMinAndMax(double min, double max) {
      this.cMin = min;
      this.cMax = max;
      return this;
    }

    /**
     * Has an effect only if `marker.color` is set to a numerical array. Determines whether or not a
     * colorbar is displayed.
     */
    public MarkerBuilder showScale(boolean b) {
      this.showScale = b;
      return this;
    }

    /**
     * Sets the colorscale and only has an effect if `marker.color` is set to a numerical array. The
     * colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba,
     * hex, hsl, hsv, or named color string.
     *
     * <p>At minimum, a mapping for the lowest (0) and highest (1) values are required. For example,
     * `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`.
     *
     * <p>To control the bounds of the colorscale in color space, use `marker.cmin` and
     * `marker.cmax`.
     */
    public MarkerBuilder colorScale(Palette palette) {
      this.colorScalePalette = palette;
      return this;
    }

    /** Sets the opacity. Value must be between 0 and 1 inclusive */
    public MarkerBuilder opacity(double opacity) {
      Preconditions.checkArgument(opacity >= 0 && opacity <= 1);
      this.opacity = opacity;
      return this;
    }

    /** Sets the marker color to a single value */
    public MarkerBuilder color(String color) {
      this.color = new String[1];
      this.color[0] = color;
      this.colorArray = null;
      return this;
    }

    /** Sets the marker color to an array of color values */
    public MarkerBuilder color(String[] color) {
      this.color = color;
      this.colorArray = null;
      return this;
    }

    /**
     * Sets the marker color to an array of numeric values for use when a color scale is provided
     */
    public MarkerBuilder color(double[] color) {
      this.colorArray = color;
      this.color = null;
      return this;
    }

    /** Sets the symbol for the marker */
    public MarkerBuilder symbol(Symbol symbol) {
      this.symbol = symbol;
      return this;
    }

    /**
     * Sets the size mode for the marker
     *
     * <p>Has an effect only if `marker.size` is set to a numerical array. Sets the rule for which
     * the data in `size` is converted to pixels, either as area or the diameter
     */
    public MarkerBuilder sizeMode(SizeMode sizeMode) {
      this.sizeMode = sizeMode;
      return this;
    }

    public Marker build() {
      return new Marker(this);
    }
  }

      String errorMessage = "All sizes in size array must be greater than 0.";
      for (double d : size) {
        Preconditions.checkArgument(d > 0, errorMessage);
      }
      this.size = size;
      return this;
    
<methods>public non-sealed void <init>() ,public java.lang.String asJSON() ,public abstract java.lang.String asJavascript() ,public java.lang.String toString() <variables>private final PebbleEngine engine,protected static final ObjectMapper mapper